TypeScript Linter.lint方法代码示例

function lint(dir: string): void {
  const options = {
    rulesDirectory: join(paths.base_dir, "tslint", "rules"),
    formatter: "stylish",
    fix: argv.fix || false,
  }

  const program = Linter.createProgram(join(dir, "tsconfig.json"))
  const linter = new Linter(options, program)
  const files = Linter.getFileNames(program)

  for (const file of files) {
    const config = Configuration.findConfiguration("./tslint.json", file).results
    const contents = program.getSourceFile(file)!.getFullText()
    linter.lint(file, contents, config)
  }

  const result = linter.getResult()

  if (result.errorCount != 0) {
    for (const line of result.output.trim().split("\n"))
      log(line)

    if (argv.emitError)
      process.exit(1)
  }
}

const lintingFailures = absolutePathToFiles.reduce<RuleFailure[]>((failures, absPath) => {
  const source = fs.readFileSync(absPath, 'utf8')
  linter.lint(absPath, source, configuration)
  const results = linter.getResult()

  if (results.failureCount > 0) {
    return failures.concat(results.failures)
  } else {
    return failures
  }
}, [] as RuleFailure[])

    workSet.forEach(fileName => {
      cancellationToken.throwIfCancellationRequested();

      try {
        this.linter.lint(fileName, undefined, this.linterConfig);
      } catch (e) {
        if (
          fs.existsSync(fileName) &&
          // check the error type due to file system lag
          !(e instanceof Error) &&
          !(e.constructor.name === 'FatalError') &&
          !(e.message && e.message.trim().startsWith('Invalid source file'))
        ) {
          // it's not because file doesn't exist - throw error
          throw e;
        }
      }
    });

function lint(dir: string): void {
  for (const file of scan(dir, [".ts"])) {
    const options = {
      rulesDirectory: join(paths.base_dir, "tslint", "rules"),
      formatter: "stylish",
      fix: argv.fix || false,
    }

    const linter = new Linter(options)
    const config = Configuration.findConfiguration("./tslint.json", file).results
    linter.lint(file, read(file)!, config)
    const result = linter.getResult()

    if (result.errorCount != 0) {
      for (const line of result.output.trim().split("\n"))
        log(line)
    }
  }
}

/**
 * A helper function for specs. Lints the given `source` string against the `ruleName` with
 *  `options`.
 *
 *  You're unlikely to use these in actual specs. Usually you'd use some of the following:
 *    - `assertAnnotated` or
 *    - `assertSuccess`.
 *
 * @param ruleName the name of the rule which is being tested
 * @param source the source code, as a string
 * @param options additional options for the lint rule
 * @returns {LintResult} the result of linting
 */
function lint(ruleName: string, source: string | ts.SourceFile, options: any): tslint.LintResult {
  let configuration = {
    extends: [],
    rules: new Map<string, Partial<tslint.IOptions>>(),
    jsRules: new Map<string, Partial<tslint.IOptions>>(),
    rulesDirectory: []
  };
  if (!options) {
    options = [];
  }
  const ops: Partial<tslint.IOptions> = { ruleName, ruleArguments: options, disabledIntervals: [] };
  configuration.rules.set(ruleName, ops);
  const linterOptions: tslint.ILinterOptions = {
    formatter: 'json',
    rulesDirectory: './dist/src',
    formattersDirectory: null,
    fix: false
  };

  let linter = new tslint.Linter(linterOptions, undefined);
  if (typeof source === 'string') {
    linter.lint('file.ts', source, configuration);
  } else {
    const rules = loadRules(convertRuleOptions(configuration.rules), linterOptions.rulesDirectory, false);
    const res = [].concat.apply([], rules.map(r => r.apply(source))) as tslint.RuleFailure[];
    const errCount = res.filter(r => !r.getRuleSeverity || r.getRuleSeverity() === 'error').length;
    return {
      errorCount: errCount,
      warningCount: res.length - errCount,
      output: '',
      format: null,
      fixes: [].concat.apply(res.map(r => r.getFix())),
      failures: res
    };
  }
  return linter.getResult();
}