@dugararchit/cdk 0.0.0-dugararchit

package/schematics/schematics/testing/test-case-setup.ts

@@ -0,0 +1,236 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {parse} from 'jsonc-parser';
+import {getSystemPath, Path} from '@angular-devkit/core';
+import {HostTree, Tree} from '@angular-devkit/schematics';
+import {SchematicTestRunner, UnitTestTree} from '@angular-devkit/schematics/testing';
+import {readFileSync} from 'fs-extra';
+import {sync as globSync} from 'glob';
+import {basename, extname, join, relative, sep} from 'path';
+import {EMPTY} from 'rxjs';
+import {createTestApp} from './test-app';
+
+/** Suffix that indicates whether a given file is a test case input. */
+const TEST_CASE_INPUT_SUFFIX = '_input.ts';
+
+/** Suffix that indicates whether a given file is an expected output of a test case. */
+const TEST_CASE_OUTPUT_SUFFIX = '_expected_output.ts';
+
+/** Name of the folder that can contain test case files which should not run automatically. */
+const MISC_FOLDER_NAME = 'misc';
+
+/** Reads the UTF8 content of the specified file. Normalizes the path and ensures that */
+export function readFileContent(filePath: string): string {
+  return readFileSync(filePath, 'utf8');
+}
+
+/**
+ * Creates a test app schematic tree that will be copied over to a real filesystem location.
+ * This is necessary because otherwise the TypeScript compiler API would not be able to
+ * find source files within the tsconfig project.
+ * TODO(devversion): we should be able to make the TypeScript config parsing respect the
+ * schematic tree. This would allow us to fully take advantage of the virtual file system.
+ */
+export async function createFileSystemTestApp(runner: SchematicTestRunner) {
+  const hostTree = new HostTree();
+  const appTree: UnitTestTree = await createTestApp(runner, {name: 'cdk-testing'}, hostTree);
+
+  // Since the TypeScript compiler API expects all files to be present on the real file system, we
+  // map every file in the app tree to a temporary location on the file system.
+  appTree.files.forEach(f => writeFile(f, appTree.readContent(f)));
+
+  return {
+    appTree,
+    writeFile,
+  };
+
+  function writeFile(filePath: string, content: string) {
+    // Update the temp file system host to reflect the changes in the real file system.
+    // This is still necessary since we depend on the real file system for parsing the
+    // TypeScript project.
+    if (hostTree.exists(filePath)) {
+      hostTree.overwrite(filePath, content);
+    } else {
+      hostTree.create(filePath, content);
+    }
+  }
+}
+
+export async function createTestCaseSetup(
+  migrationName: string,
+  collectionPath: string,
+  inputFiles: string[],
+) {
+  const runner = new SchematicTestRunner('schematics', collectionPath);
+
+  let logOutput = '';
+  runner.logger.subscribe(entry => (logOutput += `${entry.message}\n`));
+  const {appTree, writeFile} = await createFileSystemTestApp(runner);
+
+  _patchTypeScriptDefaultLib(appTree);
+
+  // Write each test-case input to the file-system. This is necessary because otherwise
+  // TypeScript compiler API won't be able to pick up the test cases.
+  inputFiles.forEach(inputFilePath => {
+    const inputTestName = basename(inputFilePath, extname(inputFilePath));
+    const relativePath = `projects/cdk-testing/src/test-cases/${inputTestName}.ts`;
+    const inputContent = readFileContent(inputFilePath);
+
+    writeFile(relativePath, inputContent);
+  });
+
+  const testAppTsconfigPath = 'projects/cdk-testing/tsconfig.app.json';
+  // Parse TypeScript configuration files with JSONC (like the CLI does) as the
+  // config files could contain comments or trailing commas
+  const testAppTsconfig = parse(appTree.readContent(testAppTsconfigPath), [], {
+    allowTrailingComma: true,
+  });
+
+  // include all TypeScript files in the project. Otherwise all test input
+  // files won't be part of the program and cannot be migrated.
+  testAppTsconfig.include.push('src/**/*.ts');
+
+  writeFile(testAppTsconfigPath, JSON.stringify(testAppTsconfig, null, 2));
+
+  const runFixers = async function () {
+    // Patch "executePostTasks" to do nothing. This is necessary since
+    // we cannot run the node install task in unit tests. Rather we just
+    // assert that certain async post tasks are scheduled.
+    // TODO(devversion): RxJS version conflicts between angular-devkit and our dev deps.
+    runner.engine.executePostTasks = () => EMPTY as any;
+
+    await runner.runSchematicAsync(migrationName, {}, appTree).toPromise();
+
+    return {logOutput};
+  };
+
+  return {runner, appTree, writeFile, runFixers};
+}
+
+/**
+ * Resolves all test cases for specified path using Bazel's runfile manifest. Note that we
+ * cannot just use "glob" since the test case files are not copied to the Bazel bin directory
+ * and are just runfiles.
+ */
+export function findBazelVersionTestCases(basePath: string) {
+  const testCasesMap = new Map<string, string[]>();
+  const manifestPath = process.env['RUNFILES_MANIFEST_FILE']!;
+  const runfilesDir = process.env['RUNFILES'];
+
+  // In case we are not on Windows where runfiles are symlinked, we just find all
+  // test case files by using "glob" and store them in our result map.
+  if (!manifestPath) {
+    const runfilesBaseDir = join(runfilesDir!, basePath);
+    const inputFiles = globSync(`**/!(${MISC_FOLDER_NAME})/*${TEST_CASE_INPUT_SUFFIX}`, {
+      cwd: runfilesBaseDir,
+    });
+
+    inputFiles.forEach(inputFile => {
+      // The target version of an input file will be determined from the first
+      // path segment. (e.g. "v6/my_rule_input.ts" will be for "v6")
+      const targetVersion = inputFile.split(sep)[0];
+      const resolvedInputPath = join(runfilesBaseDir, inputFile);
+
+      testCasesMap.set(
+        targetVersion,
+        (testCasesMap.get(targetVersion) || []).concat(resolvedInputPath),
+      );
+    });
+
+    return testCasesMap;
+  }
+
+  // In case runfiles are not symlinked (e.g. on Windows), we resolve all test case files using
+  // the Bazel runfiles manifest. Read more about the manifest here:
+  // https://github.com/bazelbuild/bazel/blob/701913139adc0eba49a7a9963fea4f555fcd844f/src/main/java/com/google/devtools/build/lib/analysis/SourceManifestAction.java#L214-L221
+  readFileSync(manifestPath, 'utf8')
+    .split('\n')
+    .forEach(line => {
+      const [runfilePath, realPath] = line.split(' ');
+
+      // In case the mapped runfile starts with the specified base path and ends with "_input.ts",
+      // we store it in our result map because we assume that this is a test case.
+      if (runfilePath.startsWith(basePath) && runfilePath.endsWith(TEST_CASE_INPUT_SUFFIX)) {
+        const pathSegments = relative(basePath, runfilePath).split(sep);
+        if (pathSegments.includes(MISC_FOLDER_NAME)) {
+          return;
+        }
+        // The target version of an input file will be determined from the first
+        // path segment. (e.g. "v6/my_rule_input.ts" will be for "v6")
+        const targetVersion = pathSegments[0];
+        testCasesMap.set(targetVersion, (testCasesMap.get(targetVersion) || []).concat(realPath));
+      }
+    });
+
+  return testCasesMap;
+}
+
+/**
+ * Sets up the specified test cases using Jasmine by creating the appropriate jasmine
+ * spec definitions. This should be used within a "describe" jasmine closure.
+ */
+export function defineJasmineTestCases(
+  versionName: string,
+  collectionFile: string,
+  inputFiles: string[] | undefined,
+) {
+  // No test cases for the given version are available. Skip setting up tests for that
+  // version.
+  if (!inputFiles) {
+    return;
+  }
+
+  let appTree: UnitTestTree;
+  let testCasesOutputPath: string;
+
+  beforeAll(async () => {
+    const {appTree: _tree, runFixers} = await createTestCaseSetup(
+      `migration-${versionName}`,
+      collectionFile,
+      inputFiles,
+    );
+
+    await runFixers();
+
+    appTree = _tree;
+    testCasesOutputPath = '/projects/cdk-testing/src/test-cases/';
+  });
+
+  // Iterates through every test case directory and generates a jasmine test block that will
+  // verify that the update schematics properly updated the test input to the expected output.
+  inputFiles.forEach(inputFile => {
+    const inputTestName = basename(inputFile, extname(inputFile));
+
+    it(`should apply update schematics to test case: ${inputTestName}`, () => {
+      expect(appTree.readContent(join(testCasesOutputPath, `${inputTestName}.ts`))).toBe(
+        readFileContent(inputFile.replace(TEST_CASE_INPUT_SUFFIX, TEST_CASE_OUTPUT_SUFFIX)),
+      );
+    });
+  });
+}
+
+/**
+ * Patches the specified virtual file system tree to be able to read the TypeScript
+ * default library typings. These need to be readable in unit tests because otherwise
+ * type checking within migration rules is not working as in real applications.
+ */
+export function _patchTypeScriptDefaultLib(tree: Tree) {
+  const _originalRead = tree.read;
+  tree.read = function (filePath: Path) {
+    // In case a file within the TypeScript package is requested, we read the file from
+    // the real file system. This is necessary because within unit tests, the "typeScript"
+    // package from within the Bazel "@npm" repository  is used. The virtual tree can't be
+    // used because the "@npm" repository directory is not part of the virtual file system.
+    if (filePath.match(/node_modules[/\\]typescript/)) {
+      return readFileSync(getSystemPath(filePath));
+    } else {
+      return _originalRead.call(this, filePath);
+    }
+  };
+}

package/schematics/schematics/testing/test-library.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Tree} from '@angular-devkit/schematics';
+import {SchematicTestRunner, UnitTestTree} from '@angular-devkit/schematics/testing';
+
+import {createTestProject} from './test-project';
+
+/** Create a base library used for testing. */
+export async function createTestLibrary(
+  runner: SchematicTestRunner,
+  appOptions = {},
+  tree?: Tree,
+): Promise<UnitTestTree> {
+  return createTestProject(runner, 'library', appOptions, tree);
+}

package/schematics/schematics/testing/test-project.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Tree} from '@angular-devkit/schematics';
+import {SchematicTestRunner, UnitTestTree} from '@angular-devkit/schematics/testing';
+
+/** Create a base project used for testing. */
+export async function createTestProject(
+  runner: SchematicTestRunner,
+  projectType: 'application' | 'library',
+  appOptions = {},
+  tree?: Tree,
+): Promise<UnitTestTree> {
+  const workspaceTree = await runner
+    .runExternalSchematicAsync(
+      '@schematics/angular',
+      'workspace',
+      {
+        name: 'workspace',
+        version: '6.0.0',
+        newProjectRoot: 'projects',
+      },
+      tree,
+    )
+    .toPromise();
+
+  return runner
+    .runExternalSchematicAsync(
+      '@schematics/angular',
+      projectType,
+      {name: 'material', ...appOptions},
+      workspaceTree,
+    )
+    .toPromise();
+}

package/schematics/schematics/testing/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "lib": ["es2015"],
+    "types": ["node", "jasmine", "glob"]
+  }
+}

package/schematics/schematics/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "lib": ["es2017"],
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "outDir": "../../../dist/packages/cdk/schematics",
+    "noEmitOnError": false,
+    "strictNullChecks": true,
+    "useUnknownInCatchVariables": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noImplicitAny": true,
+    "skipDefaultLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedLocals": false,
+    "noImplicitThis": true,
+    "skipLibCheck": true,
+    "strictFunctionTypes": true,
+    "sourceMap": true,
+    "target": "es2015",
+    "types": ["jasmine", "node"]
+  },
+  "exclude": ["**/files/**/*", "**/*.spec.ts", "ng-update/test-cases/**/*", "testing/**/*.ts"],
+  "bazelOptions": {
+    "suppressTsconfigOverrideWarnings": true
+  }
+}

package/schematics/schematics/update-tool/BUILD.bazel

@@ -0,0 +1,19 @@
+load("//tools:defaults.bzl", "ts_library")
+
+package(default_visibility = ["//visibility:public"])
+
+ts_library(
+    name = "update-tool",
+    srcs = glob(["**/*.ts"]),
+    # Schematics can not yet run in ESM module. For now we continue to use CommonJS.
+    # TODO(ESM): remove this once the Angular CLI supports ESM schematics.
+    devmode_module = "commonjs",
+    devmode_target = "es2015",
+    prodmode_module = "commonjs",
+    prodmode_target = "es2015",
+    tsconfig = ":tsconfig.json",
+    deps = [
+        "@npm//@types/node",
+        "@npm//typescript",
+    ],
+)

package/schematics/schematics/update-tool/component-resource-collector.ts

@@ -0,0 +1,195 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {dirname} from 'path';
+import * as ts from 'typescript';
+import {FileSystem, WorkspacePath} from './file-system';
+import {getAngularDecorators} from './utils/decorators';
+import {unwrapExpression} from './utils/functions';
+import {
+  computeLineStartsMap,
+  getLineAndCharacterFromPosition,
+  LineAndCharacter,
+} from './utils/line-mappings';
+import {getPropertyNameText} from './utils/property-name';
+
+export interface ResolvedResource {
+  /** Class declaration that contains this resource. */
+  container: ts.ClassDeclaration | null;
+  /** File content of the given template. */
+  content: string;
+  /** Start offset of the resource content (e.g. in the inline source file) */
+  start: number;
+  /** Whether the given resource is inline or not. */
+  inline: boolean;
+  /** Path to the file that contains this resource. */
+  filePath: WorkspacePath;
+  /**
+   * Gets the character and line of a given position index in the resource.
+   * If the resource is declared inline within a TypeScript source file, the line and
+   * character are based on the full source file content.
+   */
+  getCharacterAndLineOfPosition: (pos: number) => LineAndCharacter;
+}
+
+/**
+ * Collector that can be used to find Angular templates and stylesheets referenced within
+ * given TypeScript source files (inline or external referenced files)
+ */
+export class ComponentResourceCollector {
+  resolvedTemplates: ResolvedResource[] = [];
+  resolvedStylesheets: ResolvedResource[] = [];
+
+  constructor(public typeChecker: ts.TypeChecker, private _fileSystem: FileSystem) {}
+
+  visitNode(node: ts.Node) {
+    if (node.kind === ts.SyntaxKind.ClassDeclaration) {
+      this._visitClassDeclaration(node as ts.ClassDeclaration);
+    }
+  }
+
+  private _visitClassDeclaration(node: ts.ClassDeclaration) {
+    if (!node.decorators || !node.decorators.length) {
+      return;
+    }
+
+    const ngDecorators = getAngularDecorators(this.typeChecker, node.decorators);
+    const componentDecorator = ngDecorators.find(dec => dec.name === 'Component');
+
+    // In case no "@Component" decorator could be found on the current class, skip.
+    if (!componentDecorator) {
+      return;
+    }
+
+    const decoratorCall = componentDecorator.node.expression;
+
+    // In case the component decorator call is not valid, skip this class declaration.
+    if (decoratorCall.arguments.length !== 1) {
+      return;
+    }
+
+    const componentMetadata = unwrapExpression(decoratorCall.arguments[0]);
+
+    // Ensure that the component metadata is an object literal expression.
+    if (!ts.isObjectLiteralExpression(componentMetadata)) {
+      return;
+    }
+
+    const sourceFile = node.getSourceFile();
+    const filePath = this._fileSystem.resolve(sourceFile.fileName);
+    const sourceFileDirPath = dirname(sourceFile.fileName);
+
+    // Walk through all component metadata properties and determine the referenced
+    // HTML templates (either external or inline)
+    componentMetadata.properties.forEach(property => {
+      if (!ts.isPropertyAssignment(property)) {
+        return;
+      }
+
+      const propertyName = getPropertyNameText(property.name);
+
+      if (propertyName === 'styles' && ts.isArrayLiteralExpression(property.initializer)) {
+        property.initializer.elements.forEach(el => {
+          if (ts.isStringLiteralLike(el)) {
+            // Need to add an offset of one to the start because the template quotes are
+            // not part of the template content.
+            const templateStartIdx = el.getStart() + 1;
+            this.resolvedStylesheets.push({
+              filePath,
+              container: node,
+              content: el.text,
+              inline: true,
+              start: templateStartIdx,
+              getCharacterAndLineOfPosition: pos =>
+                ts.getLineAndCharacterOfPosition(sourceFile, pos + templateStartIdx),
+            });
+          }
+        });
+      }
+
+      // In case there is an inline template specified, ensure that the value is statically
+      // analyzable by checking if the initializer is a string literal-like node.
+      if (propertyName === 'template' && ts.isStringLiteralLike(property.initializer)) {
+        // Need to add an offset of one to the start because the template quotes are
+        // not part of the template content.
+        const templateStartIdx = property.initializer.getStart() + 1;
+        this.resolvedTemplates.push({
+          filePath,
+          container: node,
+          content: property.initializer.text,
+          inline: true,
+          start: templateStartIdx,
+          getCharacterAndLineOfPosition: pos =>
+            ts.getLineAndCharacterOfPosition(sourceFile, pos + templateStartIdx),
+        });
+      }
+
+      if (propertyName === 'styleUrls' && ts.isArrayLiteralExpression(property.initializer)) {
+        property.initializer.elements.forEach(el => {
+          if (ts.isStringLiteralLike(el)) {
+            const stylesheetPath = this._fileSystem.resolve(sourceFileDirPath, el.text);
+            const stylesheet = this.resolveExternalStylesheet(stylesheetPath, node);
+
+            if (stylesheet) {
+              this.resolvedStylesheets.push(stylesheet);
+            }
+          }
+        });
+      }
+
+      if (propertyName === 'templateUrl' && ts.isStringLiteralLike(property.initializer)) {
+        const templateUrl = property.initializer.text;
+        const templatePath = this._fileSystem.resolve(sourceFileDirPath, templateUrl);
+
+        // In case the template does not exist in the file system, skip this
+        // external template.
+        if (!this._fileSystem.fileExists(templatePath)) {
+          return;
+        }
+
+        const fileContent = this._fileSystem.read(templatePath);
+
+        if (fileContent) {
+          const lineStartsMap = computeLineStartsMap(fileContent);
+
+          this.resolvedTemplates.push({
+            filePath: templatePath,
+            container: node,
+            content: fileContent,
+            inline: false,
+            start: 0,
+            getCharacterAndLineOfPosition: p => getLineAndCharacterFromPosition(lineStartsMap, p),
+          });
+        }
+      }
+    });
+  }
+
+  /** Resolves an external stylesheet by reading its content and computing line mappings. */
+  resolveExternalStylesheet(
+    filePath: WorkspacePath,
+    container: ts.ClassDeclaration | null,
+  ): ResolvedResource | null {
+    const fileContent = this._fileSystem.read(filePath);
+
+    if (!fileContent) {
+      return null;
+    }
+
+    const lineStartsMap = computeLineStartsMap(fileContent);
+
+    return {
+      filePath: filePath,
+      container: container,
+      content: fileContent,
+      inline: false,
+      start: 0,
+      getCharacterAndLineOfPosition: pos => getLineAndCharacterFromPosition(lineStartsMap, pos),
+    };
+  }
+}

package/schematics/schematics/update-tool/file-system.ts

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {UpdateRecorder} from './update-recorder';
+
+/**
+ * A workspace path semantically is equivalent to the `Path` type provided by the
+ * Angular devkit. Paths denoted with such a type are guaranteed to be representing
+ * paths of a given virtual file system. This means that the root of a path can be
+ * different, and does not necessarily need to match the root in the real file system.
+ *
+ * For example: Consider we have a project in `/home/<..>/my-project`. Then a path
+ * like `/package.json` could actually refer to the `package.json` file in `my-project`.
+ * Note that in the real file system this would not match though.
+ *
+ * One wonder why another type has been declared for such paths, when there already
+ * is the `Path` type provided by the devkit. We do this for a couple of reasons:
+ *
+ *   1. The update-tool cannot have a dependency on the Angular devkit as that one
+ *      is not synced into g3. We want to be able to run migrations in g3 if needed.
+ */
+export type WorkspacePath = string & {
+  // Brand signature matches the devkit paths so that existing path
+  // utilities from the Angular devkit can be conveniently used.
+  __PRIVATE_DEVKIT_PATH: void;
+};
+
+/** Interface that describes a directory. */
+export interface DirectoryEntry {
+  /** List of directories inside the directory. */
+  directories: string[];
+  /** List of files inside the directory. */
+  files: string[];
+}
+
+/**
+ * Abstraction of the file system that migrations can use to record and apply
+ * changes. This is necessary to support virtual file systems as used in the CLI devkit.
+ */
+export abstract class FileSystem {
+  /** Checks whether the given file exists. */
+  abstract fileExists(path: WorkspacePath): boolean;
+  /** Checks whether the given directory exists. */
+  abstract directoryExists(path: WorkspacePath): boolean;
+  /** Gets the contents of the given file. */
+  abstract read(filePath: WorkspacePath): string | null;
+  /** Reads the given directory to retrieve children. */
+  abstract readDirectory(dirPath: WorkspacePath): DirectoryEntry;
+  /**
+   * Creates an update recorder for the given file. Edits can be recorded and
+   * committed in batches. Changes are not applied automatically because otherwise
+   * migrations would need to re-read files, or account for shifted file contents.
+   */
+  abstract edit(filePath: WorkspacePath): UpdateRecorder;
+  /** Applies all changes which have been recorded in update recorders. */
+  abstract commitEdits(): void;
+  /** Creates a new file with the given content. */
+  abstract create(filePath: WorkspacePath, content: string): void;
+  /** Overwrites an existing file with the given content. */
+  abstract overwrite(filePath: WorkspacePath, content: string): void;
+  /** Deletes the given file. */
+  abstract delete(filePath: WorkspacePath): void;
+  /**
+   * Resolves given paths to a resolved path in the file system. For example, the devkit
+   * tree considers the actual workspace directory as file system root.
+   *
+   * Follows the same semantics as the native path `resolve` method. i.e. segments
+   * are processed in reverse. The last segment is considered the target and the
+   * function will iterate from the target through other segments until it finds an
+   * absolute path segment.
+   */
+  abstract resolve(...segments: string[]): WorkspacePath;
+}