feat(refoundry): publish a new package for refactoring.

This package isnt public or stable yet, so no documentation.

Also included fixes for:
- Fixes angular#2887.

Author: hansl

lib/packages.js

@@ -16,12 +16,19 @@ const packages =
       return { name: pkgName, root: path.join(packageRoot, pkgName) };
     })
     .reduce((packages, pkg) => {
-      let pkgJson = JSON.parse(fs.readFileSync(path.join(pkg.root, 'package.json'), 'utf8'));
+      const packageJsonPath = path.join(pkg.root, 'package.json');
+      let pkgJson;
+      try {
+        pkgJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      } catch (e) {
+        console.error(`Error while parsing "${packageJsonPath}":\n${e.stack}`);
+        process.exit(1);
+      }
       let name = pkgJson['name'];
 
       packages[name] = {
         dist: path.join(__dirname, '../dist', pkg.name),
-        packageJson: path.join(pkg.root, 'package.json'),
+        packageJson: packageJsonPath,
         root: pkg.root,
         relative: path.relative(path.dirname(__dirname), pkg.root),
         main: path.resolve(pkg.root, 'src/index.ts')

package.json

@@ -81,7 +81,7 @@
     "less-loader": "^2.2.3",
     "loader-utils": "^0.2.16",
     "lodash": "^4.11.1",
-    "magic-string": "^0.16.0",
+    "magic-string": "^0.19.0",
     "markdown-it": "4.3.0",
     "markdown-it-terminal": "0.0.3",
     "minimatch": "^3.0.0",

packages/@ngtools/refactory/README.md

@@ -0,0 +1,39 @@
+# Angular Ahead-of-Time Webpack Plugin
+
+Webpack plugin that AoT compiles your Angular components and modules.
+
+## Usage
+In your webpack config, add the following plugin and loader:
+
+```typescript
+import {AotPlugin} from '@ngtools/webpack'
+
+exports = { /* ... */
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        loader: '@ngtools/webpack',
+      }
+    ]
+  },
+
+  plugins: [
+    new AotPlugin({
+      tsConfigPath: 'path/to/tsconfig.json',
+      entryModule: 'path/to/app.module#AppModule'
+    })
+  ]
+}
+```
+
+The loader works with the webpack plugin to compile your TypeScript. It's important to include both, and to not include any other TypeScript compiler loader.
+
+## Options
+
+* `tsConfigPath`. The path to the `tsconfig.json` file. This is required. In your `tsconfig.json`, you can pass options to the Angular Compiler with `angularCompilerOptions`.
+* `basePath`. Optional. The root to use by the compiler to resolve file paths. By default, use the `tsConfigPath` root.
+* `entryModule`. Optional if specified in `angularCompilerOptions`. The path and classname of the main application module. This follows the format `path/to/file#ClassName`.
+* `mainPath`. Optional if `entryModule` is specified. The `main.ts` file containing the bootstrap code. The plugin will use AST to determine the `entryModule`.
+* `skipCodeGeneration`. Optional, defaults to false. Disable code generation and do not refactor the code to bootstrap. This replaces `templateUrl: "string"` with `template: require("string")` (and similar for styles) to allow for webpack to properly link the resources.
+* `typeChecking`. Optional, defaults to true. Enable type checking through your application. This will slow down compilation, but show syntactic and semantic errors in webpack.

packages/@ngtools/refactory/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@ngtools/refactory",
+  "version": "0.0.1",
+  "description": "Library for refactoring angular 2 apps and code.",
+  "main": "./src/index.js",
+  "typings": "src/index.d.ts",
+  "license": "MIT",
+  "keywords": [
+    "ngtools",
+    "angular",
+    "refactor",
+    "typescript",
+    "library"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/angular/angular-cli.git"
+  },
+  "author": "angular",
+  "bugs": {
+    "url": "https://github.com/angular/angular-cli/issues"
+  },
+  "homepage": "https://github.com/angular/angular-cli/tree/master/packages/@ngtools/refactory",
+  "engines": {
+    "node": ">= 4.1.0",
+    "npm": ">= 3.0.0"
+  },
+  "dependencies": {
+    "magic-string": "^0.19.0",
+    "minimatch": "^3.0.0",
+    "source-map": "^0.5.6"
+  },
+  "peerDependencies": {
+    "typescript": "^2.0.2"
+  }
+}

packages/@ngtools/refactory/src/host.ts

@@ -0,0 +1,74 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+
+export interface RefactoryHost {
+  readonly basePath: string;
+
+  stat(filePath: string): fs.Stats | null;
+
+  write(filePath: string, content: string): void;
+  read(filePath: string): string;
+  exists(filePath: string): boolean;
+
+  list(dirPath: string): string[];
+  isDirectory(dirPath: string): boolean;
+}
+
+
+export class InvalidRefactoryHost implements RefactoryHost {
+  get basePath(): string { throw new Error('Unimplemented: basePath'); }
+
+  write(filePath: string, content: string): void { throw new Error('Unimplemented: write'); }
+  read(filePath: string): string { throw new Error('Unimplemented: read'); }
+  exists(filePath: string): boolean { throw new Error('Unimplemented: exists'); }
+
+  list(dirPath: string): string[] { throw new Error('Unimplemented: list'); }
+  isDirectory(dirPath: string): boolean { throw new Error('Unimplemented: isDirectory'); }
+
+  stat(dirPath: string): fs.Stats { throw new Error('Unimplemented: stat'); }
+}
+
+
+export class NullRefactoryHost implements RefactoryHost {
+  constructor(public readonly basePath: string) {}
+
+  write(filePath: string, content: string): void { throw new Error('Unimplemented: write'); }
+  read(filePath: string): string { throw new Error('Unimplemented: read'); }
+  exists(filePath: string): boolean { return false; }
+
+  list(dirPath: string): string[] { return []; }
+  isDirectory(dirPath: string): boolean { return false; }
+
+  stat(dirPath: string): fs.Stats { return null; }
+}
+
+
+export class NodeRefactoryHost implements RefactoryHost {
+  constructor(private _basePath: string = '/') {}
+  private _normalize(p: string) {
+    return path.normalize(path.isAbsolute(p) ? p : path.join(this._basePath, p));
+  }
+
+  get basePath(): string { return this._basePath; }
+
+  stat(filePath: string): fs.Stats {
+    return fs.statSync(filePath);
+  }
+
+  write(filePath: string, content: string): void {
+    fs.writeFileSync(this._normalize(filePath), content, 'utf8');
+  }
+  read(filePath: string): string {
+    return fs.readFileSync(this._normalize(filePath), 'utf8');
+  }
+  exists(filePath: string): boolean {
+    return fs.existsSync(this._normalize(filePath));
+  }
+  list(dirPath: string): string[] {
+    return fs.readdirSync(this._normalize(dirPath));
+  }
+  isDirectory(dirPath: string): boolean {
+    return fs.statSync(this._normalize(dirPath)).isDirectory();
+  }
+}

packages/@ngtools/refactory/src/index.ts

@@ -0,0 +1,10 @@
+
+export {Refactory} from './refactory';
+
+// Hosts
+export {RefactoryHost, NullRefactoryHost, NodeRefactoryHost, InvalidRefactoryHost} from './host';
+export {VirtualRefactoryHost} from './utils/virtual_refactory_host'
+export * from './utils/host_adapters';
+
+// Languages
+export * from './language/index';

packages/@ngtools/refactory/src/language/file.ts

@@ -0,0 +1,17 @@
+import {Refactory} from '../refactory';
+import {StaticSymbol} from './symbol';
+
+export abstract class File {
+  constructor(protected _filePath: string, protected _refactory: Refactory) {}
+
+  get path() { return this._filePath; }
+  get refactory() { return this._refactory; }
+
+  abstract resolveSymbol(name: string): StaticSymbol;
+}
+
+export class UnknownFile extends File {
+  resolveSymbol(name: string): StaticSymbol {
+    throw new Error(`Trying to resolve symbol "${name}" in an unknown file language.`);
+  }
+}

packages/@ngtools/refactory/src/language/index.ts

@@ -0,0 +1,7 @@
+
+export * from './file';
+export * from './symbol';
+
+
+// Typescript
+export * from './typescript/index';

packages/@ngtools/refactory/src/language/symbol.ts

@@ -0,0 +1,9 @@
+import {File} from './file';
+
+
+export class StaticSymbol {
+  constructor(protected _name: string, protected _file: File) {}
+
+  get file() { return this._file; }
+  get name() { return this._name; }
+}

packages/@ngtools/refactory/src/language/typescript.spec.ts

@@ -0,0 +1,96 @@
+import {Decorator} from './typescript/decorator';
+import {TypeScriptFile} from './typescript/file';
+import {Refactory} from '../refactory';
+import {VirtualRefactoryHost} from '../utils/virtual_refactory_host';
+import {NullRefactoryHost} from '../host';
+
+const tsFileSystem: {[path: string]: string} = {
+  '/tsconfig.json': '{}',
+  '/file.ts': `console.log('hello');`,
+  '/file1.ts': `
+    /**
+     * @annotation
+     */
+    function MyAnnotation(obj: any) { return () => {}; }
+    function NotAnnotation() { return () => {}; }
+    function NotFunctionCall() {}
+  
+    @NotFunctionCall
+    @NotAnnotation()
+    @MyAnnotation({ hello: 'world' })
+    class MyClass {}
+    
+    export class MyOther {}
+  `,
+  '/import1.ts': `
+    import {Symbol11} from './import1_def';
+    import * as Def from './import1_def';
+    import DefaultImport from './import1_def';
+    
+    import 'import2_def';
+  `,
+  '/import1_def.ts': `
+    export function Symbol11() {}
+    export default function Symbol12() {}
+  `,
+  '/import2_def.ts': `
+    export function Symbol21() {}
+    export default function Symbol22() {}
+  `
+};
+
+
+describe('TypeScriptFile', () => {
+  let refactory: Refactory;
+
+  beforeEach(() => {
+    const host = new VirtualRefactoryHost(new NullRefactoryHost('/'));
+    for (const p of Object.keys(tsFileSystem)) {
+      host.write(p, tsFileSystem[p]);
+    }
+
+    refactory = Refactory.fromTsConfig('/tsconfig.json', host);
+  });
+
+  it('works with a file', () => {
+    let file: TypeScriptFile = refactory.getFile('/file.ts') as TypeScriptFile;
+    expect(file).not.toBeNull();
+    expect(file.transpile({}).outputText).toMatch(/console.log\('hello'\)/);
+  });
+
+  describe('classes', () => {
+    it('can see class names', () => {
+      let file1: TypeScriptFile = refactory.getFile('/file1.ts') as TypeScriptFile;
+      expect(file1.classes.map(c => c.name)).toEqual(['MyClass', 'MyOther']);
+    });
+
+    it('can see decorators', () => {
+      let file1: TypeScriptFile = refactory.getFile('/file1.ts') as TypeScriptFile;
+      // Should ignore NotAnnotation.
+      expect(file1.classes[0].decorators.map((a: Decorator) => a.name))
+        .toEqual(['NotFunctionCall', 'NotAnnotation', 'MyAnnotation']);
+    });
+
+    it('can remove()', () => {
+      let file1: TypeScriptFile = refactory.getFile('/file1.ts') as TypeScriptFile;
+      file1.classes[0].remove();
+
+      const output = file1.transpile({}).outputText;
+      expect(output).toContain('MyOther');
+      expect(output).not.toContain('MyClass');
+    });
+
+    it('knows if its exported', () => {
+      let file1: TypeScriptFile = refactory.getFile('/file1.ts') as TypeScriptFile;
+      expect(file1.classes[0].isExported).toBe(false);
+      expect(file1.classes[1].isExported).toBe(true);
+    });
+  });
+
+  describe('imports', () => {
+    it('understands imports', () => {
+      let import1: TypeScriptFile = refactory.getFile('/import1.ts') as TypeScriptFile;
+      expect(import1.imports.map(i => i.name)).toEqual(['Symbol11']);
+    });
+  });
+});

packages/@ngtools/refactory/src/language/typescript/class.ts

@@ -0,0 +1,37 @@
+import * as ts from 'typescript';
+import {TypeScriptFile} from './file';
+import {Decorator} from './decorator';
+import {TypeScriptStaticSymbol} from './symbol';
+
+
+export class Class extends TypeScriptStaticSymbol<ts.ClassDeclaration> {
+  private constructor(node: ts.ClassDeclaration, file: TypeScriptFile) {
+    super(node.name.text, node, file);
+  }
+
+  static fromNode(node: ts.Node, file: TypeScriptFile): Class {
+    if (node.kind !== ts.SyntaxKind.ClassDeclaration) {
+      throw new Error(`Node of kind ${node.kind} is not a class declaration.`);
+    }
+
+    return new Class(node as ts.ClassDeclaration, file);
+  }
+
+  private _decorators: Decorator[] = null;
+  get decorators(): Decorator[] {
+    if (!this._decorators) {
+      this._decorators = this._node.decorators
+        .map(node => Decorator.fromNode(node, this, this.file))
+        .filter(node => !!node);
+    }
+    return this._decorators;
+  }
+  private _exported: boolean | null = null;
+  get isExported(): boolean {
+    if (this._exported === null) {
+      this._exported = ((this._node.modifiers || []) as Array<ts.Node>)
+        .some((m: ts.Node) => m.kind == ts.SyntaxKind.ExportKeyword);
+    }
+    return this._exported;
+  }
+}