[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

@@ -19,6 +19,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);
+      }
+    }
+  });
+}