feat(@angular/cli): specify multiple default collections

Author: tomastrajan

packages/@angular/cli/commands/generate.ts

@@ -7,6 +7,8 @@ import 'rxjs/add/observable/of';
 import 'rxjs/add/operator/ignoreElements';
 import {
   getCollection,
+  getCollectionNameForSchematicName,
+  getCollectionNames,
   getEngineHost
 } from '../utilities/schematics';
 import { DynamicPathOptions, dynamicPathParser } from '../utilities/dynamic-path-parser';
@@ -17,7 +19,7 @@ import { SchematicAvailableOptions } from '../tasks/schematic-get-options';
 const Command = require('../ember-cli/lib/models/command');
 const SilentError = require('silent-error');
 
-const { cyan, yellow } = chalk;
+const { cyan, yellow, white } = chalk;
 const separatorRegEx = /[\/\\]/g;
 
 
@@ -65,8 +67,10 @@ export default Command.extend({
     '<schematic>'
   ],
 
-  getCollectionName(rawArgs: string[]) {
-    let collectionName = CliConfig.getValue('defaults.schematics.collection');
+  getCollectionName(schematicName: string, rawArgs: string[]) {
+    let collectionName = getCollectionNameForSchematicName(
+      getCollectionNames(), schematicName);
+
     if (rawArgs) {
       const parsedArgs = this.parseArgs(rawArgs, false);
       if (parsedArgs.options.collection) {
@@ -103,7 +107,7 @@ export default Command.extend({
       ui: this.ui,
       project: this.project
     });
-    const collectionName = this.getCollectionName(rawArgs);
+    const collectionName = this.getCollectionName(schematicName, rawArgs);
 
     return getOptionsTask.run({
         schematicName,
@@ -172,7 +176,7 @@ export default Command.extend({
       project: this.project
     });
     const collectionName = commandOptions.collection ||
-      CliConfig.getValue('defaults.schematics.collection');
+      this.getCollectionName(schematicName);
 
     if (collectionName === '@schematics/angular' && schematicName === 'interface' && rawArgs[2]) {
       commandOptions.type = rawArgs[2];
@@ -188,10 +192,9 @@ export default Command.extend({
 
   printDetailedHelp: function (_options: any, rawArgs: any): string | Promise<string> {
     const engineHost = getEngineHost();
-    const collectionName = this.getCollectionName();
-    const collection = getCollection(collectionName);
     const schematicName = rawArgs[1];
     if (schematicName) {
+      const collectionName = this.getCollectionName(schematicName);
       const SchematicGetHelpOutputTask = require('../tasks/schematic-get-help-output').default;
       const getHelpOutputTask = new SchematicGetHelpOutputTask({
         ui: this.ui,
@@ -204,16 +207,22 @@ export default Command.extend({
       })
       .then((output: string[]) => {
         return [
+          yellow(collectionName),
           cyan(`ng generate ${schematicName} ${cyan('[name]')} ${cyan('<options...>')}`),
           ...output
         ].join('\n');
       });
     } else {
-      const schematicNames: string[] = engineHost.listSchematics(collection);
       const output: string[] = [];
-      output.push(cyan('Available schematics:'));
-      schematicNames.forEach(schematicName => {
-        output.push(yellow(`    ${schematicName}`));
+      output.push(cyan('Available collections & schematics:'));
+      const collections = getCollectionNames()
+        .map((collectionName: string) => getCollection(collectionName));
+      collections.forEach((collection: any) => {
+        output.push(yellow(`\n${collection.name}`));
+        const schematicNames: string[] = engineHost.listSchematics(collection);
+        schematicNames.forEach(schematicName => {
+          output.push(white(`    ${schematicName}`));
+        });
       });
       return Promise.resolve(output.join('\n'));
     }

packages/@angular/cli/commands/new.ts

@@ -6,8 +6,12 @@ import { CliConfig } from '../models/config';
 import { validateProjectName } from '../utilities/validate-project-name';
 import { oneLine } from 'common-tags';
 import { SchematicAvailableOptions } from '../tasks/schematic-get-options';
+import {
+  getCollectionNameForSchematicName,
+  getCollectionNames
+} from '../utilities/schematics';
 
-const { cyan } = chalk;
+const { cyan, yellow } = chalk;
 
 const Command = require('../ember-cli/lib/models/command');
 const SilentError = require('silent-error');
@@ -70,8 +74,9 @@ const NewCommand = Command.extend({
     return CliConfig.fromProject(projectPath) !== null;
   },
 
-  getCollectionName(rawArgs: string[]) {
-    let collectionName = CliConfig.fromGlobal().get('defaults.schematics.collection');
+  getCollectionName(schematicName: string, rawArgs: string[]) {
+    let collectionName = getCollectionNameForSchematicName(
+      getCollectionNames(), schematicName);
     if (rawArgs) {
       const parsedArgs = this.parseArgs(rawArgs, false);
       if (parsedArgs.options.collection) {
@@ -88,6 +93,7 @@ const NewCommand = Command.extend({
     }
 
     const schematicName = CliConfig.getValue('defaults.schematics.newApp');
+    const collectionName = this.getCollectionName(schematicName, rawArgs);
 
     if (/^\d/.test(rawArgs[1])) {
       SilentError.debugOrThrow('@angular/cli/commands/generate',
@@ -103,7 +109,7 @@ const NewCommand = Command.extend({
 
     return getOptionsTask.run({
       schematicName,
-      collectionName: this.getCollectionName(rawArgs)
+      collectionName
     })
       .then((availableOptions: SchematicAvailableOptions) => {
         this.registerOptions({
@@ -137,10 +143,11 @@ const NewCommand = Command.extend({
       `);
     }
 
+    commandOptions.schematicName = CliConfig.fromGlobal().get('defaults.schematics.newApp');
     if (commandOptions.collection) {
       commandOptions.collectionName = commandOptions.collection;
     } else {
-      commandOptions.collectionName = this.getCollectionName(rawArgs);
+      commandOptions.collectionName = this.getCollectionName(commandOptions.schematicName, rawArgs);
     }
 
     const InitTask = require('../tasks/init').default;
@@ -158,8 +165,8 @@ const NewCommand = Command.extend({
   },
 
   printDetailedHelp: function (): string | Promise<string> {
-    const collectionName = this.getCollectionName();
     const schematicName = CliConfig.getValue('defaults.schematics.newApp');
+    const collectionName = this.getCollectionName(schematicName);
     const SchematicGetHelpOutputTask = require('../tasks/schematic-get-help-output').default;
     const getHelpOutputTask = new SchematicGetHelpOutputTask({
       ui: this.ui,
@@ -172,6 +179,7 @@ const NewCommand = Command.extend({
     })
     .then((output: string[]) => {
       const outputLines = [
+        yellow(collectionName),
         cyan(`ng new ${cyan('[name]')} ${cyan('<options...>')}`),
         ...output
       ];

packages/@angular/cli/lib/config/schema.json

@@ -565,10 +565,18 @@
           "type": "object",
           "properties": {
             "collection": {
-              "description": "The schematics collection to use.",
+              "description": "The base schematics collection to use.",
               "type": "string",
               "default": "@schematics/angular"
             },
+            "collections": {
+              "description": "The additional schematics collections to use.",
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "default": []
+            },
             "newApp": {
               "description": "The new app schematic.",
               "type": "string",

packages/@angular/cli/tasks/init.ts

@@ -72,15 +72,14 @@ export default Task.extend({
     });
 
     const cwd = this.project.root;
-    const schematicName = CliConfig.fromGlobal().get('defaults.schematics.newApp');
     commandOptions.version = packageJson.version;
 
     const runOptions = {
       taskOptions: commandOptions,
       workingDir: cwd,
       emptyHost: true,
       collectionName: commandOptions.collectionName,
-      schematicName
+      schematicName: commandOptions.schematicName
     };
 
     return schematicRunTask.run(runOptions)

packages/@angular/cli/tasks/schematic-get-options.ts

@@ -1,6 +1,5 @@
 const Task = require('../ember-cli/lib/models/task');
 const stringUtils = require('ember-cli-string-utils');
-import { CliConfig } from '../models/config';
 import { getCollection, getSchematic } from '../utilities/schematics';
 
 export interface SchematicGetOptions {
@@ -19,10 +18,7 @@ export interface SchematicAvailableOptions {
 
 export default Task.extend({
   run: function (options: SchematicGetOptions): Promise<SchematicAvailableOptions[]> {
-    const collectionName = options.collectionName ||
-      CliConfig.getValue('defaults.schematics.collection');
-
-    const collection = getCollection(collectionName);
+    const collection = getCollection(options.collectionName);
 
     const schematic = getSchematic(collection, options.schematicName);
 

packages/@angular/cli/utilities/schematics.ts

@@ -20,6 +20,7 @@ import { SchemaClassFactory } from '@ngtools/json-schema';
 import 'rxjs/add/operator/concatMap';
 import 'rxjs/add/operator/map';
 
+import { CliConfig } from '../models/config';
 const SilentError = require('silent-error');
 
 const engineHost = new NodeModulesEngineHost();
@@ -61,3 +62,25 @@ export function getSchematic(collection: Collection<any, any>,
                              schematicName: string): Schematic<any, any> {
   return collection.createSchematic(schematicName);
 }
+
+export function getCollectionNames() {
+  const collectionNames = [CliConfig.getValue('defaults.schematics.collection')];
+  const additionalCollections = CliConfig.getValue('defaults.schematics.collections');
+  if (additionalCollections && additionalCollections.length) {
+    collectionNames.unshift(...additionalCollections);
+  }
+  return collectionNames;
+}
+
+export function getCollectionNameForSchematicName(collectionNames: string[],
+                                                  schematicName: string): string {
+  return collectionNames.filter((collectionName: string) => {
+    let schematic;
+    try {
+      schematic = getSchematic(getCollection(collectionName), schematicName);
+    } catch (e) {
+      // it's OK, schematic doesn't exists in collection
+    }
+    return !!schematic;
+  })[0];
+}

tests/acceptance/new.spec.ts

@@ -12,20 +12,23 @@ describe('Acceptance: ng new', function () {
   beforeEach((done) => {
     // Increase timeout for these tests only.
     originalTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
-    jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000;
+    jasmine.DEFAULT_TIMEOUT_INTERVAL = 15000;
 
     spyOn(console, 'error');
     // symlink custom collections to node_modules, so we can use with ng new
     // it is a bit dirty, but bootstrap-local tricks won't work here
     fs.symlinkSync(`${process.cwd()}/tests/collections/@custom`, `./node_modules/@custom`, 'dir');
+    fs.symlinkSync(`${process.cwd()}/tests/collections/@custom-other`, `./node_modules/@custom-other`, 'dir');
 
     tmp.setup('./tmp')
       .then(() => process.chdir('./tmp'))
       .then(() => done());
   }, 10000);
 
   afterEach((done) => {
+    ng(['set', 'defaults.schematics.collections=null', '--global']);
     fs.unlinkSync(path.join(__dirname, '/../../node_modules/@custom'));
+    fs.unlinkSync(path.join(__dirname, '/../../node_modules/@custom-other'));
     jasmine.DEFAULT_TIMEOUT_INTERVAL = originalTimeout;
     tmp.teardown('./tmp').then(() => done());
   });
@@ -184,4 +187,19 @@ describe('Acceptance: ng new', function () {
     })
     .then(done, done.fail);
   });
+
+  it('should use schematic from default collections', (done) => {
+    return ng(['set', 'defaults.schematics.collections=["@custom/application"]', '--global'])
+      .then(() => ng(['new', 'foo', '--skip-install', '--skip-git']))
+      .then(() => expect(() => fs.readFileSync('emptyapp', 'utf8')).not.toThrow())
+      .then(done, done.fail);
+  });
+
+  it('should use schematic from first matching collection from default collections', (done) => {
+    return ng(['set', 'defaults.schematics.collections=["@custom-other/application","@custom/application"]', '--global'])
+      .then(() => ng(['new', 'foo', '--skip-install', '--skip-git']))
+      .then(() => expect(() => fs.readFileSync('veryemptyapp', 'utf8')).not.toThrow())
+      .then(done, done.fail);
+  });
+
 });