refactor/clone-cdk-schematics (#21)

* refactor(ast): clone original code

* refactor(ast): clone original code

* refactor(ng-module-imports): clone original code

* refactor(build-components): clone original code

* refactor(get-project): clone original code

* refactor(html-head-element): clone original code

* refactor(package-config): clone original code

* build: remove @angular/cdk

Author: nitayneeman

package-lock.json

@@ -37,7 +37,6 @@
   "dependencies": {
     "@angular-devkit/core": "^8.3.21",
     "@angular-devkit/schematics": "^8.3.21",
-    "@angular/cdk": "^8.2.3",
     "@schematics/angular": "^8.3.21",
     "@schematics/update": "^0.803.21",
     "rxjs": "^6.4.0",

package.json

@@ -151,7 +151,7 @@ export interface WorkspaceTargets<TProjectType extends ProjectType = ProjectType
   e2e?: E2EBuilderTarget;
   'app-shell'?: AppShellBuilderTarget;
   'extract-i18n'?: ExtractI18nBuilderTarget;
-  // TODO(hans): change this any to unknown when google3 supports TypeScript 3.0.
+  // TODO change this any to unknown when google3 supports TypeScript 3.0.
   // tslint:disable-next-line:no-any
   [key: string]: any;
 }

src/angular/workspace-models.ts

@@ -0,0 +1,8 @@
+export * from './ng-add/package-config';
+export * from './utils/ast';
+export * from './utils/build-component';
+export * from './utils/get-project';
+export * from './utils/html-head-element';
+export * from './utils/project-main-file';
+export * from './utils/project-targets';
+export * from './utils/version-agnostic-typescript';

src/cdk/index.ts

@@ -0,0 +1,32 @@
+import { Tree } from '@angular-devkit/schematics';
+
+/**
+ * Sorts the keys of the given object.
+ * @returns A new object instance with sorted keys
+ */
+function sortObjectByKeys(obj: object) {
+  return Object.keys(obj)
+    .sort()
+    .reduce((result, key) => (result[key] = obj[key]) && result, {});
+}
+
+/** Adds a package to the package.json in the given host tree. */
+export function addPackageToPackageJson(host: Tree, pkg: string, version: string): Tree {
+  if (host.exists('package.json')) {
+    const sourceText = host.read('package.json')!.toString('utf-8');
+    const json = JSON.parse(sourceText);
+
+    if (!json.dependencies) {
+      json.dependencies = {};
+    }
+
+    if (!json.dependencies[pkg]) {
+      json.dependencies[pkg] = version;
+      json.dependencies = sortObjectByKeys(json.dependencies);
+    }
+
+    host.overwrite('package.json', JSON.stringify(json, null, 2));
+  }
+
+  return host;
+}

src/cdk/ng-add/package-config.ts

@@ -0,0 +1,45 @@
+import { SchematicsException, Tree } from '@angular-devkit/schematics';
+import { addImportToModule, getAppModulePath, InsertChange, WorkspaceProject } from '../../angular';
+import { getProjectMainFile } from './project-main-file';
+import { ts, typescript } from './version-agnostic-typescript';
+
+/** Reads file given path and returns TypeScript source file. */
+export function getSourceFile(host: Tree, path: string): typescript.SourceFile {
+  const buffer = host.read(path);
+  if (!buffer) {
+    throw new SchematicsException(`Could not find file for path: ${path}`);
+  }
+  return ts.createSourceFile(path, buffer.toString(), ts.ScriptTarget.Latest, true);
+}
+
+/** Import and add module to root app module. */
+export function addModuleImportToRootModule(host: Tree, moduleName: string, src: string, project: WorkspaceProject) {
+  const modulePath = getAppModulePath(host, getProjectMainFile(project));
+  addModuleImportToModule(host, modulePath, moduleName, src);
+}
+
+/**
+ * Import and add module to specific module path.
+ * @param host the tree we are updating
+ * @param modulePath src location of the module to import
+ * @param moduleName name of module to import
+ * @param src src location to import
+ */
+export function addModuleImportToModule(host: Tree, modulePath: string, moduleName: string, src: string) {
+  const moduleSource = getSourceFile(host, modulePath);
+
+  if (!moduleSource) {
+    throw new SchematicsException(`Module not found: ${modulePath}`);
+  }
+
+  const changes = addImportToModule(<any>moduleSource, modulePath, moduleName, src);
+  const recorder = host.beginUpdate(modulePath);
+
+  changes.forEach(change => {
+    if (change instanceof InsertChange) {
+      recorder.insertLeft(change.pos, change.toAdd);
+    }
+  });
+
+  host.commitUpdate(recorder);
+}

src/cdk/utils/ast.ts

@@ -0,0 +1,81 @@
+import { SchematicsException, Tree } from '@angular-devkit/schematics';
+import * as ts from 'typescript';
+
+/**
+ * Whether the Angular module in the given path imports the specified module class name.
+ */
+export function hasNgModuleImport(tree: Tree, modulePath: string, className: string): boolean {
+  const moduleFileContent = tree.read(modulePath);
+
+  if (!moduleFileContent) {
+    throw new SchematicsException(`Could not read Angular module file: ${modulePath}`);
+  }
+
+  const parsedFile = ts.createSourceFile(modulePath, moduleFileContent.toString(), ts.ScriptTarget.Latest, true);
+  const ngModuleMetadata = findNgModuleMetadata(parsedFile);
+
+  if (!ngModuleMetadata) {
+    throw new SchematicsException(`Could not find NgModule declaration inside: "${modulePath}"`);
+  }
+
+  for (let property of ngModuleMetadata!.properties) {
+    if (
+      !ts.isPropertyAssignment(property) ||
+      property.name.getText() !== 'imports' ||
+      !ts.isArrayLiteralExpression(property.initializer)
+    ) {
+      continue;
+    }
+
+    if (property.initializer.elements.some(element => element.getText() === className)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Resolves the last identifier that is part of the given expression. This helps resolving
+ * identifiers of nested property access expressions (e.g. myNamespace.core.NgModule).
+ */
+function resolveIdentifierOfExpression(expression: ts.Expression): ts.Identifier | null {
+  if (ts.isIdentifier(expression)) {
+    return expression;
+  } else if (ts.isPropertyAccessExpression(expression)) {
+    return expression.name;
+  }
+  return null;
+}
+
+/**
+ * Finds a NgModule declaration within the specified TypeScript node and returns the
+ * corresponding metadata for it. This function searches breadth first because
+ * NgModule's are usually not nested within other expressions or declarations.
+ */
+function findNgModuleMetadata(rootNode: ts.Node): ts.ObjectLiteralExpression | null {
+  // Add immediate child nodes of the root node to the queue.
+  const nodeQueue: ts.Node[] = [...rootNode.getChildren()];
+
+  while (nodeQueue.length) {
+    const node = nodeQueue.shift()!;
+
+    if (ts.isDecorator(node) && ts.isCallExpression(node.expression) && isNgModuleCallExpression(node.expression)) {
+      return node.expression.arguments[0] as ts.ObjectLiteralExpression;
+    } else {
+      nodeQueue.push(...node.getChildren());
+    }
+  }
+
+  return null;
+}
+
+/** Whether the specified call expression is referring to a NgModule definition. */
+function isNgModuleCallExpression(callExpression: ts.CallExpression): boolean {
+  if (!callExpression.arguments.length || !ts.isObjectLiteralExpression(callExpression.arguments[0])) {
+    return false;
+  }
+
+  const decoratorIdentifier = resolveIdentifierOfExpression(callExpression.expression);
+  return decoratorIdentifier ? decoratorIdentifier.text === 'NgModule' : false;
+}