refactor: resolve comments from Mike and Ben

Also added linting and fix those and a travis configuration.

Author: hansl

.travis.yml

@@ -0,0 +1,27 @@
+dist: trusty
+
+language: node_js
+
+env:
+  global:
+    - DBUS_SESSION_BUS_ADDRESS=/dev/null
+
+matrix:
+  fast_finish: true
+  include:
+    - node_js: "6"
+      os: linux
+      env: SCRIPT=lint
+    - node_js: "6"
+      os: linux
+      env: SCRIPT=test
+
+before_install:
+  # Install yarn.
+  - curl -o- -L https://yarnpkg.com/install.sh | bash
+  - export PATH="$HOME/.yarn/bin:$PATH"
+  - yarn config set spin false
+  - yarn config set progress false
+
+script:
+  - if [[ "$SCRIPT" ]]; then npm run $SCRIPT; fi

bin/sdk-admin renamed to bin/devkit-admin

@@ -10,12 +10,9 @@
 require('../lib/bootstrap-local');
 
 const minimist = require('minimist');
+const path = require('path');
 
 const args = minimist(process.argv.slice(2));
+const scriptName = path.join('../scripts', args._.shift());
 
-
-switch (args._[0]) {
-  case 'test': require('../scripts/test').default(args); break;
-
-  default: console.log('Unknown command: ' + args._[0]); break;
-}
+require(scriptName).default(args);

lib/bootstrap-local.js

@@ -15,12 +15,12 @@ const ts = require('typescript');
 
 Error.stackTraceLimit = Infinity;
 
-global._SdkIsLocal = true;
-global._SdkRoot = path.resolve(__dirname, '..');
-global._SdkPackages = require('./packages').packages;
-global._SdkTools = require('./packages').tools;
+global._DevKitIsLocal = true;
+global._DevKitRoot = path.resolve(__dirname, '..');
+global._DevKitPackages = require('./packages').packages;
+global._DevKitTools = require('./packages').tools;
 
-global._SdkRequireHook = null;
+global._DevKitRequireHook = null;
 
 
 const compilerOptions = ts.readConfigFile(path.join(__dirname, '../tsconfig.json'), p => {
@@ -32,7 +32,7 @@ const oldRequireTs = require.extensions['.ts'];
 require.extensions['.ts'] = function (m, filename) {
   // If we're in node module, either call the old hook or simply compile the
   // file without transpilation. We do not touch node_modules/**.
-  // We do touch `Angular SDK` files anywhere though.
+  // We do touch `Angular DevK` files anywhere though.
   if (!filename.match(/@angular\/cli\b/) && filename.match(/node_modules/)) {
     if (oldRequireTs) {
       return oldRequireTs(m, filename);
@@ -46,8 +46,8 @@ require.extensions['.ts'] = function (m, filename) {
   try {
     let result = ts.transpile(source, compilerOptions['compilerOptions'], filename);
 
-    if (global._SdkRequireHook) {
-      result = global._SdkRequireHook(result, filename);
+    if (global._DevKitRequireHook) {
+      result = global._DevKitRequireHook(result, filename);
     }
 
     // Send it to node to execute.

package.json

@@ -1,18 +1,22 @@
 {
-  "name": "@angular/sdk",
+  "name": "@angular/devkit",
   "version": "0.0.0",
   "description": "Software Development Kit for Angular",
   "bin": {
-    "sdk-admin": "./bin/sdk-admin",
+    "devkit-admin": "./bin/devkit-admin",
     "schematics": "./bin/schematics"
   },
   "keywords": [],
   "scripts": {
-    "test": "./bin/sdk-admin test"
+    "admin": "./bin/devkit-admin",
+    "build": "tsc -p tsconfig.json",
+    "fix": "npm run lint -- --fix",
+    "lint": "tslint --config tslint.json --project tsconfig.json --type-check",
+    "test": "./bin/devkit-admin test"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/angular/sdk.git"
+    "url": "https://github.com/angular/devkit.git"
   },
   "engines": {
     "node": ">= 6.9.0",
@@ -21,9 +25,9 @@
   "author": "Angular Authors",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/angular/sdk/issues"
+    "url": "https://github.com/angular/devkit/issues"
   },
-  "homepage": "https://github.com/angular/sdk",
+  "homepage": "https://github.com/angular/devkit",
   "dependencies": {
     "@ngtools/json-schema": "^1.0.9",
     "@ngtools/logger": "^1.0.1",

packages/schematics/package.json

@@ -10,11 +10,11 @@
     "blueprints",
     "code generation",
     "schematics",
-    "Angular SDK"
+    "Angular DevKit"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/angular/sdk.git"
+    "url": "https://github.com/angular/devkit.git"
   },
   "engines": {
     "node": ">= 6.9.0",
@@ -23,9 +23,9 @@
   "author": "Angular Authors",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/angular/sdk/issues"
+    "url": "https://github.com/angular/devkit/issues"
   },
-  "homepage": "https://github.com/angular/sdk",
+  "homepage": "https://github.com/angular/devkit",
   "dependencies": {
   }
 }

packages/schematics/src/engine/engine.ts

@@ -33,7 +33,7 @@ export class UnknownCollectionException extends BaseException {
 }
 export class UnknownSchematicException extends BaseException {
   constructor(name: string, collection: Collection<any, any>) {
-    super(`Schematic "${name}" not found in collection "${collection.name}".`);
+    super(`Schematic "${name}" not found in collection "${collection.description.name}".`);
   }
 }
 
@@ -68,11 +68,11 @@ export class SchematicEngine<CollectionT, SchematicT> implements Engine<Collecti
   createSchematic(
       name: string,
       collection: Collection<CollectionT, SchematicT>): Schematic<CollectionT, SchematicT> {
-    const collectionImpl = this._collectionCache.get(collection.name);
-    const schematicMap = this._schematicCache.get(collection.name);
+    const collectionImpl = this._collectionCache.get(collection.description.name);
+    const schematicMap = this._schematicCache.get(collection.description.name);
     if (!collectionImpl || !schematicMap || collectionImpl !== collection) {
       // This is weird, maybe the collection was created by another engine?
-      throw new UnknownCollectionException(collection.name);
+      throw new UnknownCollectionException(collection.description.name);
     }
 
     let schematic = schematicMap.get(name);

packages/schematics/src/engine/interface.ts

@@ -13,38 +13,39 @@ import {Url} from 'url';
 
 /**
  * The description (metadata) of a collection. This type contains every information the engine
- * needs to run. The CollectionT type parameter contains additional metadata that you want to
- * store while remaining type-safe.
+ * needs to run. The CollectionMetadataT type parameter contains additional metadata that you
+ * want to store while remaining type-safe.
  */
-export type CollectionDescription<CollectionT extends {}> = CollectionT & {
+export type CollectionDescription<CollectionMetadataT extends {}> = CollectionMetadataT & {
   readonly name: string;
 };
 
 /**
  * The description (metadata) of a schematic. This type contains every information the engine
- * needs to run. The SchematicT and CollectionT type parameters contain additional metadata
- * that you want to store while remaining type-safe.
+ * needs to run. The SchematicMetadataT and CollectionMetadataT type parameters contain additional
+ * metadata that you want to store while remaining type-safe.
  */
-export type SchematicDescription<CollectionT extends {}, SchematicT extends {}> = SchematicT & {
-  readonly collection: CollectionDescription<CollectionT>;
+export type SchematicDescription<CollectionMetadataT extends {},
+                                 SchematicMetadataT extends {}> = SchematicMetadataT & {
+  readonly collection: CollectionDescription<CollectionMetadataT>;
   readonly name: string;
 };
 
 
 /**
  * The Host for the Engine. Specifically, the piece of the tooling responsible for resolving
- * collections and schematics descriptions. The SchematicT and CollectionT type parameters contain
- * additional metadata that you want to store while remaining type-safe.
+ * collections and schematics descriptions. The SchematicMetadataT and CollectionMetadataT type
+ * parameters contain additional metadata that you want to store while remaining type-safe.
  */
-export interface EngineHost<CollectionT extends {}, SchematicT extends {}> {
-  createCollectionDescription(name: string): CollectionDescription<CollectionT> | null;
+export interface EngineHost<CollectionMetadataT extends {}, SchematicMetadataT extends {}> {
+  createCollectionDescription(name: string): CollectionDescription<CollectionMetadataT> | null;
   createSchematicDescription(
       name: string,
-      collection: CollectionDescription<CollectionT>):
-        SchematicDescription<CollectionT, SchematicT> | null;
+      collection: CollectionDescription<CollectionMetadataT>):
+        SchematicDescription<CollectionMetadataT, SchematicMetadataT> | null;
   getSchematicRuleFactory<OptionT>(
-      schematic: SchematicDescription<CollectionT, SchematicT>,
-      collection: CollectionDescription<CollectionT>): RuleFactory<OptionT>;
+      schematic: SchematicDescription<CollectionMetadataT, SchematicMetadataT>,
+      collection: CollectionDescription<CollectionMetadataT>): RuleFactory<OptionT>;
   createSourceFromUrl(url: Url): Source | null;
 
   readonly defaultMergeStrategy?: MergeStrategy;
@@ -55,16 +56,18 @@ export interface EngineHost<CollectionT extends {}, SchematicT extends {}> {
  * The root Engine for creating and running schematics and collections. Everything related to
  * a schematic execution starts from this interface.
  *
- * CollectionT is, by default, a generic Collection metadata type. This is used throughout the
- * engine typings so that you can use a type that's merged into descriptions, while being type-safe.
+ * CollectionMetadataT is, by default, a generic Collection metadata type. This is used throughout
+ * the engine typings so that you can use a type that's merged into descriptions, while being
+ * type-safe.
  *
- * SchematicT is a type that contains additional typing for the Schematic Description.
+ * SchematicMetadataT is a type that contains additional typing for the Schematic Description.
  */
-export interface Engine<CollectionT extends {}, SchematicT extends {}> {
-  createCollection(name: string): Collection<CollectionT, SchematicT>;
+export interface Engine<CollectionMetadataT extends {}, SchematicMetadataT extends {}> {
+  createCollection(name: string): Collection<CollectionMetadataT, SchematicMetadataT>;
   createSchematic(
       name: string,
-      collection: Collection<CollectionT, SchematicT>): Schematic<CollectionT, SchematicT>;
+      collection: Collection<CollectionMetadataT, SchematicMetadataT>
+  ): Schematic<CollectionMetadataT, SchematicMetadataT>;
   createSourceFromUrl(url: Url): Source;
 
   readonly defaultMergeStrategy: MergeStrategy;
@@ -75,21 +78,20 @@ export interface Engine<CollectionT extends {}, SchematicT extends {}> {
  * A Collection as created by the Engine. This should be used by the tool to create schematics,
  * or by rules to create other schematics as well.
  */
-export interface Collection<CollectionT, SchematicT> {
-  readonly name: string;
-  readonly description: CollectionDescription<CollectionT>;
+export interface Collection<CollectionMetadataT, SchematicMetadataT> {
+  readonly description: CollectionDescription<CollectionMetadataT>;
 
-  createSchematic(name: string): Schematic<CollectionT, SchematicT>;
+  createSchematic(name: string): Schematic<CollectionMetadataT, SchematicMetadataT>;
 }
 
 
 /**
  * A Schematic as created by the Engine. This should be used by the tool to execute the main
  * schematics, or by rules to execute other schematics as well.
  */
-export interface Schematic<CollectionT, SchematicT> {
-  readonly description: SchematicDescription<CollectionT, SchematicT>;
-  readonly collection: Collection<CollectionT, SchematicT>;
+export interface Schematic<CollectionMetadataT, SchematicMetadataT> {
+  readonly description: SchematicDescription<CollectionMetadataT, SchematicMetadataT>;
+  readonly collection: Collection<CollectionMetadataT, SchematicMetadataT>;
 
   call<T>(options: T, host: Observable<Tree>): Observable<Tree>;
 }
@@ -99,9 +101,9 @@ export interface Schematic<CollectionT, SchematicT> {
  * A SchematicContext. Contains information necessary for Schematics to execute some rules, for
  * example when using another schematics, as we need the engine and collection.
  */
-export interface TypedSchematicContext<CollectionT, SchematicT> {
-  readonly engine: Engine<CollectionT, SchematicT>;
-  readonly schematic: Schematic<CollectionT, SchematicT>;
+export interface TypedSchematicContext<CollectionMetadataT, SchematicMetadataT> {
+  readonly engine: Engine<CollectionMetadataT, SchematicMetadataT>;
+  readonly schematic: Schematic<CollectionMetadataT, SchematicMetadataT>;
   readonly host: Observable<Tree>;
   readonly strategy: MergeStrategy;
 }

packages/schematics/src/engine/schematic.ts

@@ -17,7 +17,6 @@ import {Tree} from '../tree/interface';
 import {BaseException} from '../exception/exception';
 
 import {Observable} from 'rxjs/Observable';
-import 'rxjs/add/observable/fromPromise';
 import 'rxjs/add/observable/of';
 import 'rxjs/add/operator/concatMap';