feat: linter runner

src/lint/linter.ts

@@ -3,32 +3,28 @@ import { join } from 'path'
 import { SOURCE_FOLDER } from '../consts'
 import { ESLint } from './eslint'
 import { Formatter } from './formatter'
-import { makeRelativePath, mergeResults } from './results'
+import { LinterRunner } from './runner'
 import { TypeCheck } from './type-check'
 import { TypeCoverage } from './type-coverage'
 
 export async function lint(fix?: boolean, quiet?: boolean) {
   const src = join(process.cwd(), SOURCE_FOLDER)
 
-  const linters = [
-    new ESLint({ src, fix }),
-    new TypeCoverage({ src }),
-    new TypeCheck({ config: 'tsconfig.json' })
-  ]
+  const runner = new LinterRunner()
 
-  const allResults = (await Promise.all(linters.map(linter => linter.run())))
-    .flat()
-    .map(makeRelativePath)
-  const mergedResults = mergeResults(allResults)
+  runner.addLinter(new ESLint({ src, fix }))
+  runner.addLinter(new TypeCoverage({ src }))
+  runner.addLinter(new TypeCheck({ config: 'tsconfig.json' }))
 
-  const errorResults = mergedResults.map(result => {
+  const results = await runner.run()
+  const errorResults = results.map(result => {
     return {
       ...result,
       messages: result.messages.filter(message => message.severity === 2)
     }
   })
   const formatter = new Formatter()
-  const resultText = await formatter.format(quiet ? errorResults : mergedResults)
+  const resultText = await formatter.format(quiet ? errorResults : results)
 
   console.log(resultText)
 }

src/lint/runner.ts

@@ -0,0 +1,22 @@
+import { BaseLinter } from './base'
+import { LintResult, makeRelativePath, mergeResults } from './results'
+
+export class LinterRunner {
+  private linters: BaseLinter[] = []
+
+  addLinter(linter: BaseLinter) {
+    this.linters.push(linter)
+  }
+
+  async run() {
+    const results: LintResult[] = []
+
+    for (const linter of this.linters) {
+      const linterResults = await linter.run()
+
+      results.push(...linterResults)
+    }
+
+    return mergeResults(results.map(makeRelativePath))
+  }
+}

test/lint/linter.test.ts

@@ -56,13 +56,13 @@ describe('Linter', () => {
     }))
 
     ;(ESLint as jest.Mock<any>).mockReturnValue({
-      run: () => ({ filePath: 'file1', messages: [message1] })
+      run: () => ([{ filePath: 'file1', messages: [message1] }])
     })
     ;(TypeCoverage as jest.Mock<any>).mockReturnValue({
-      run: () => ({ filePath: 'file1', messages: [message2] })
+      run: () => ([{ filePath: 'file1', messages: [message2] }])
     })
     ;(TypeCheck as jest.Mock<any>).mockReturnValue({
-      run: () => ({ filePath: 'file2', messages: [message1] })
+      run: () => ([{ filePath: 'file2', messages: [message1] }])
     })
 
     await lint()