angular-cn/dev-infra/ts-circular-dependencies/index.ts

160 lines
6.6 KiB
TypeScript
Raw Normal View History

#!/usr/bin/env node
/**
* @license
* Copyright Google Inc. 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 {existsSync, readFileSync, writeFileSync} from 'fs';
import {sync as globSync} from 'glob';
import {join, relative, resolve} from 'path';
import * as ts from 'typescript';
import * as yargs from 'yargs';
import chalk from 'chalk';
import {Analyzer, ReferenceChain} from './analyzer';
import {compareGoldens, convertReferenceChainToGolden, Golden} from './golden';
import {convertPathToForwardSlash} from './file_system';
import {getRepoBaseDir} from '../utils/config';
const projectDir = getRepoBaseDir();
const packagesDir = join(projectDir, 'packages/');
// The default glob does not capture deprecated packages such as http, or the webworker platform.
const defaultGlob =
join(packagesDir, '!(http|platform-webworker|platform-webworker-dynamic)/**/*.ts');
if (require.main === module) {
const {_: command, goldenFile, glob, baseDir, warnings} =
yargs.help()
.strict()
.command('check <goldenFile>', 'Checks if the circular dependencies have changed.')
.command('approve <goldenFile>', 'Approves the current circular dependencies.')
.demandCommand()
.option(
'approve',
{type: 'boolean', description: 'Approves the current circular dependencies.'})
.option('warnings', {type: 'boolean', description: 'Prints all warnings.'})
.option('base-dir', {
type: 'string',
description: 'Base directory used for shortening paths in the golden file.',
default: projectDir,
defaultDescription: 'Project directory'
})
.option('glob', {
type: 'string',
description: 'Glob that matches source files which should be checked.',
default: defaultGlob,
defaultDescription: 'All release packages'
})
.argv;
const isApprove = command.includes('approve');
process.exit(main(baseDir, isApprove, goldenFile, glob, warnings));
}
/**
* Runs the ts-circular-dependencies tool.
* @param baseDir Base directory which is used to build up relative file paths in goldens.
* @param approve Whether the detected circular dependencies should be approved.
* @param goldenFile Path to the golden file.
* @param glob Glob that is used to collect all source files which should be checked/approved.
* @param printWarnings Whether warnings should be printed. Warnings for unresolved modules/files
* are not printed by default.
* @returns Status code.
*/
export function main(
baseDir: string, approve: boolean, goldenFile: string, glob: string,
printWarnings: boolean): number {
const analyzer = new Analyzer(resolveModule);
const cycles: ReferenceChain[] = [];
const checkedNodes = new WeakSet<ts.SourceFile>();
globSync(glob, {absolute: true}).forEach(filePath => {
const sourceFile = analyzer.getSourceFile(filePath);
cycles.push(...analyzer.findCycles(sourceFile, checkedNodes));
});
const actual = convertReferenceChainToGolden(cycles, baseDir);
console.info(
chalk.green(` Current number of cycles: ${chalk.yellow(cycles.length.toString())}`));
if (approve) {
writeFileSync(goldenFile, JSON.stringify(actual, null, 2));
console.info(chalk.green('✅ Updated golden file.'));
return 0;
} else if (!existsSync(goldenFile)) {
console.error(chalk.red(`❌ Could not find golden file: ${goldenFile}`));
return 1;
}
// By default, warnings for unresolved files or modules are not printed. This is because
// it's common that third-party modules are not resolved/visited. Also generated files
// from the View Engine compiler (i.e. factories, summaries) cannot be resolved.
if (printWarnings &&
(analyzer.unresolvedFiles.size !== 0 || analyzer.unresolvedModules.size !== 0)) {
console.info(chalk.yellow('The following imports could not be resolved:'));
analyzer.unresolvedModules.forEach(specifier => console.info(`${specifier}`));
analyzer.unresolvedFiles.forEach((value, key) => {
console.info(`${getRelativePath(baseDir, key)}`);
value.forEach(specifier => console.info(` ${specifier}`));
});
}
const expected: Golden = JSON.parse(readFileSync(goldenFile, 'utf8'));
const {fixedCircularDeps, newCircularDeps} = compareGoldens(actual, expected);
const isMatching = fixedCircularDeps.length === 0 && newCircularDeps.length === 0;
if (isMatching) {
console.info(chalk.green('✅ Golden matches current circular dependencies.'));
return 0;
}
console.error(chalk.red('❌ Golden does not match current circular dependencies.'));
if (newCircularDeps.length !== 0) {
console.error(chalk.yellow(` New circular dependencies which are not allowed:`));
newCircularDeps.forEach(c => console.error(`${convertReferenceChainToString(c)}`));
}
if (fixedCircularDeps.length !== 0) {
console.error(
chalk.yellow(` Fixed circular dependencies that need to be removed from the golden:`));
fixedCircularDeps.forEach(c => console.error(`${convertReferenceChainToString(c)}`));
console.info();
// Print the command for updating the golden. Note that we hard-code the script name for
// approving default packages golden in `goldens/`. We cannot infer the script name passed to
// Yarn automatically since script are launched in a child process where `argv0` is different.
if (resolve(goldenFile) === resolve(projectDir, 'goldens/packages-circular-deps.json')) {
console.info(
chalk.yellow(` Please approve the new golden with: yarn ts-circular-deps:approve`));
} else {
console.info(chalk.yellow(
` Please update the golden. The following command can be ` +
`run: yarn ts-circular-deps approve ${getRelativePath(baseDir, goldenFile)}.`));
}
}
return 1;
}
/** Gets the specified path relative to the base directory. */
function getRelativePath(baseDir: string, path: string) {
return convertPathToForwardSlash(relative(baseDir, path));
}
/** Converts the given reference chain to its string representation. */
function convertReferenceChainToString(chain: ReferenceChain<string>) {
return chain.join(' → ');
}
/**
* Custom module resolver that maps specifiers starting with `@angular/` to the
* local packages folder.
*/
function resolveModule(specifier: string) {
if (specifier.startsWith('@angular/')) {
return packagesDir + specifier.substr('@angular/'.length);
}
return null;
}