[tslint] lint typescript code

package.json

@@ -61,8 +61,8 @@
  "debug-break": "node --nolazy --inspect-brk scripts/kibana --dev",
  "precommit": "node scripts/precommit_hook",
  "karma": "karma start",
- "lint": "echo 'use `node scripts/eslint`' && false",
- "lintroller": "echo 'use `node scripts/eslint --fix`' && false",
+ "lint": "echo 'use `node scripts/eslint` and/or `node scripts/tslint`' && false",
+ "lintroller": "echo 'use `node scripts/eslint --fix` and/or `node scripts/tslint --fix`' && false",
  "makelogs": "echo 'use `node scripts/makelogs`' && false",
  "mocha": "echo 'use `node scripts/mocha`' && false",
  "sterilize": "grunt sterilize",
@@ -226,7 +226,11 @@
  "@kbn/eslint-plugin-license-header": "link:packages/kbn-eslint-plugin-license-header",
  "@kbn/plugin-generator": "link:packages/kbn-plugin-generator",
  "@kbn/test": "link:packages/kbn-test",
- "@types/globby": "^6.1.0",
+ "@types/eslint": "^4.16.2",
+ "@types/execa": "^0.9.0",
+ "@types/getopts": "^2.0.0",
+ "@types/glob": "^5.0.35",
+ "@types/listr": "^0.13.0",
  "@types/minimatch": "^2.0.29",
  "angular-mocks": "1.4.7",
  "babel-eslint": "8.1.2",
@@ -283,6 +287,7 @@
  "karma-safari-launcher": "1.0.0",
  "leadfoot": "1.7.5",
  "license-checker": "^16.0.0",
+ "listr": "^0.14.1",
  "load-grunt-config": "0.19.2",
  "makelogs": "^4.0.5",
  "marked-text-renderer": "0.1.0",
@@ -305,6 +310,9 @@
  "ts-jest": "^22.4.6",
  "ts-loader": "^3.5.0",
  "ts-node": "^6.0.3",
+ "tslint": "^5.10.0",
+ "tslint-config-prettier": "^1.12.0",
+ "tslint-plugin-prettier": "^1.3.0",
  "typescript": "^2.8.3",
  "vinyl-fs": "^3.0.2",
  "xml2js": "^0.4.19",

packages/kbn-dev-utils/index.d.ts

@@ -0,0 +1,18 @@
+import { Readable } from 'stream';
+
+type LogLevel = 'silent' | 'error' | 'warning' | 'info' | 'debug' | 'verbose';
+
+export class ToolingLog extends Readable {
+ public verbose(...args: any[]): void;
+ public debug(...args: any[]): void;
+ public info(...args: any[]): void;
+ public success(...args: any[]): void;
+ public warning(...args: any[]): void;
+ public error(errOrMsg: string | Error): void;
+ public write(...args: any[]): void;
+ public indent(spaces: number): void;
+ public getLevel(): LogLevel;
+ public setLevel(level: LogLevel): void;
+}
+
+export function createToolingLog(level?: LogLevel): ToolingLog;

packages/kbn-dev-utils/tsconfig.json

@@ -0,0 +1,6 @@
+{
+ "extends": "../../tsconfig.json",
+ "include": [
+ "index.d.ts"
+ ],
+}

packages/kbn-pm/tslint.yaml

@@ -0,0 +1,19 @@
+extends: ../../tslint.yaml
+
+rules:
+ max-classes-per-file: false
+ interface-name: false
+ variable-name: false
+ no-empty: false
+ object-literal-sort-keys: false
+ member-ordering: false
+ no-console: false
+ only-arrow-functions: false
+ no-shadowed-variable: false
+ no-empty-interface: false
+ ordered-imports: false
+ interface-over-type-literal: false
+ prettier: false
+ prefer-const: false
+ member-access: false
+ no-unused-variable: false

packages/kbn-system-loader/tslint.yaml

@@ -0,0 +1,14 @@
+extends: ../../tslint.yaml
+
+rules:
+ max-classes-per-file: false
+ interface-name: false
+ variable-name: false
+ no-empty: false
+ object-literal-sort-keys: false
+ member-ordering: false
+ member-access: false
+ ordered-imports: false
+ interface-over-type-literal: false
+ array-type: false
+ prefer-const: false

scripts/tslint.js

@@ -0,0 +1,2 @@
+require('../src/babel-register');
+require('../src/dev/tslint').runTslintCli();

src/dev/eslint/lint_files.js

@@ -25,10 +25,10 @@ export function lintFiles(log, files) {
  if (report.warningCount > 0) failTypes.push('warning');
 
  if (!failTypes.length) {
- log.success('%d files linted successfully', files.length);
+ log.success('[eslint] %d files linted successfully', files.length);
  return;
  }
 
  log.error(cli.getFormatter()(report.results));
- throw createFailError(`eslint ${failTypes.join(' & ')}`, 1);
+ throw createFailError(`[eslint] ${failTypes.join(' & ')}`, 1);
 }

src/dev/eslint/pick_files_to_lint.js

@@ -18,11 +18,11 @@ export function pickFilesToLint(log, files) {
  const path = file.getRelativePath();
 
  if (cli.isPathIgnored(path)) {
- log.warning(`%j ignored by .eslintignore`, file);
+ log.warning(`[eslint] %j ignored by .eslintignore`, file);
  return false;
  }
 
- log.debug('linting %j', file);
+ log.debug('[eslint] linting %j', file);
  return true;
  });
 }

src/dev/jest/ts_transform.ts

@@ -1,8 +1,7 @@
 import { getCacheKey, install, process } from 'ts-jest';
 import { JestConfig, TransformOptions } from 'ts-jest/dist/jest-types';
 
-import { transform } from 'typescript';
-import { findProjectForAbsolutePath } from '../typescript';
+import { getTsProjectForAbsolutePath } from '../typescript';
 
 function extendJestConfigJSON(jestConfigJSON: string, filePath: string) {
  const jestConfig = JSON.parse(jestConfigJSON) as JestConfig;
@@ -15,20 +14,30 @@ function extendJestConfig(jestConfig: JestConfig, filePath: string) {
  globals: {
  ...(jestConfig.globals || {}),
  'ts-jest': {
- tsConfigFile: findProjectForAbsolutePath(filePath).getTsConfigPath(),
  skipBabel: true,
+ tsConfigFile: getTsProjectForAbsolutePath(filePath).tsConfigPath,
  },
  },
  };
 }
 
 module.exports = {
- process(src: string, filePath: string, jestConfig: JestConfig, transformOptions: TransformOptions) {
+ process(
+ src: string,
+ filePath: string,
+ jestConfig: JestConfig,
+ transformOptions: TransformOptions
+ ) {
  const extendedConfig = extendJestConfig(jestConfig, filePath);
  return process(src, filePath, extendedConfig, transformOptions);
  },
 
- getCacheKey(src: string, filePath: string, jestConfigJSON: string, transformOptions: TransformOptions) {
+ getCacheKey(
+ src: string,
+ filePath: string,
+ jestConfigJSON: string,
+ transformOptions: TransformOptions
+ ) {
  const extendedConfigJSON = extendJestConfigJSON(jestConfigJSON, filePath);
  return getCacheKey(src, filePath, extendedConfigJSON, transformOptions);
  },

src/dev/precommit_hook/casing_check_config.js

@@ -20,6 +20,7 @@ export const IGNORE_FILE_GLOBS = [
  '**/.*',
  '**/{webpackShims,__mocks__}/**/*',
  'x-pack/docs/**/*',
+ 'src/dev/tslint/rules/*',
 ];
 
 

src/dev/run/index.d.ts

@@ -0,0 +1 @@
+export function createFailError(msg: string, exitCode: number): Error;

src/dev/run_precommit_hook.js

@@ -1,10 +1,17 @@
 import { run } from './run';
 
-import { lintFiles, pickFilesToLint } from './eslint';
+import * as Eslint from './eslint';
+import * as Tslint from './tslint';
 import { getFilesForCommit, checkFileCasing } from './precommit_hook';
 
 run(async ({ log }) => {
  const files = await getFilesForCommit();
  await checkFileCasing(log, files);
- await lintFiles(log, pickFilesToLint(log, files));
+
+ for (const Linter of [Eslint, Tslint]) {
+ const filesToLint = Linter.pickFilesToLint(log, files);
+ if (filesToLint.length > 0) {
+ await Linter.lintFiles(log, filesToLint);
+ }
+ }
 });

src/dev/tslint/index.ts

@@ -0,0 +1,3 @@
+export { runTslintCli } from './run_tslint_cli';
+export { lintFiles } from './lint_files';
+export { pickFilesToLint } from './pick_files_to_lint';

src/dev/tslint/lint_files.ts

@@ -0,0 +1,63 @@
+import { run } from 'tslint/lib/runner';
+
+import { ToolingLog } from '@kbn/dev-utils';
+import { File } from '../file';
+import { createFailError } from '../run';
+import { getTsProjectForAbsolutePath, Project } from '../typescript';
+
+function groupFilesByProject(files: File[]) {
+ const filesByProject: Map<Project, File[]> = new Map();
+
+ files.forEach(file => {
+ const project = getTsProjectForAbsolutePath(file.getAbsolutePath());
+ const filesForProject = filesByProject.get(project);
+
+ if (!filesForProject) {
+ filesByProject.set(project, [file]);
+ } else {
+ filesForProject.push(file);
+ }
+ });
+
+ return filesByProject;
+}
+
+/**
+ * Lints a list of files with eslint. eslint reports are written to the log
+ * and a FailError is thrown when linting errors occur.
+ *
+ * @param {ToolingLog} log
+ * @param {Array<File>} files
+ * @return {undefined}
+ */
+export async function lintFiles(log: ToolingLog, files: File[]) {
+ for (const [project, filesInProject] of groupFilesByProject(files)) {
+ const exitCode = await run(
+ {
+ exclude: [],
+ files: filesInProject.map(f => f.getAbsolutePath()),
+ fix: false,
+ format: 'stylish',
+ project: project.tsConfigPath,
+ },
+ {
+ log(m: string) {
+ log.write(m);
+ },
+ error(m: string) {
+ log.error(m);
+ },
+ }
+ );
+
+ if (exitCode > 0) {
+ throw createFailError(`[tslint] failure`, 1);
+ } else {
+ log.success(
+ '[tslint/%s] %d files linted successfully',
+ project.name,
+ files.length
+ );
+ }
+ }
+}

src/dev/tslint/pick_files_to_lint.ts

@@ -0,0 +1,7 @@
+import { ToolingLog } from '@kbn/dev-utils';
+
+import { File } from '../file';
+
+export function pickFilesToLint(log: ToolingLog, files: File[]) {
+ return files.filter(file => file.isTypescript());
+}

src/dev/tslint/rules/requireLicenseHeaderRule.js

@@ -0,0 +1,29 @@
+const Lint = require('tslint');
+
+const FAILURE_STRING = 'File must start with a license header';
+const RULE_NAME = 'require-license-header';
+
+exports.Rule = class extends Lint.Rules.AbstractRule {
+ apply(sourceFile) {
+ const [headerText] = this.getOptions().ruleArguments;
+
+ if (!headerText) {
+ throw new Error(`${RULE_NAME} requires a single argument containing the header text`);
+ }
+
+ if (sourceFile.text.startsWith(headerText)) {
+ return [];
+ }
+
+ return [
+ new Lint.RuleFailure(
+ sourceFile,
+ 0,
+ 0,
+ FAILURE_STRING,
+ RULE_NAME,
+ new Lint.Replacement(0, 0, `${headerText}\n\n`)
+ )
+ ];
+ }
+};

src/dev/tslint/run_tslint_cli.ts

@@ -0,0 +1,69 @@
+import { resolve } from 'path';
+
+import { createToolingLog } from '@kbn/dev-utils';
+import chalk from 'chalk';
+import execa from 'execa';
+import getopts from 'getopts';
+import Listr from 'listr';
+
+import { Project, PROJECTS } from '../typescript';
+
+class LintFailure {
+ constructor(public project: Project, public error: execa.ExecaError) {}
+}
+
+export function runTslintCli() {
+ const log = createToolingLog('info');
+ log.pipe(process.stdout);
+
+ const opts = getopts(process.argv.slice(2));
+
+ if (!opts.format) {
+ process.argv.push('--format', 'stylish');
+ }
+
+ const list = new Listr(
+ PROJECTS.filter(project => {
+ if (!opts.project) {
+ return true;
+ }
+
+ return resolve(opts.project) === project.tsConfigPath;
+ }).map(project => ({
+ task: () =>
+ execa(
+ 'tslint',
+ [...process.argv.slice(2), '--project', project.tsConfigPath],
+ {
+ cwd: project.directory,
+ env: chalk.enabled ? { FORCE_COLOR: 'true' } : {},
+ stdio: ['ignore', 'pipe', 'pipe'],
+ }
+ ).catch(error => {
+ throw new LintFailure(project, error);
+ }),
+ title: project.name,
+ })),
+ {
+ concurrent: true,
+ exitOnError: false,
+ }
+ );
+
+ list.run().catch((error: any) => {
+ if (!error.errors) {
+ log.error('Unhandled execption!');
+ log.error(error);
+ process.exit(1);
+ }
+
+ for (const e of error.errors) {
+ if (e instanceof LintFailure) {
+ log.write('');
+ log.error(`${e.project.name} failed\n${e.error.stdout}`);
+ } else {
+ log.error(e);
+ }
+ }
+ });
+}