chore: move APIs to async/await (+ fix tests failing) (#270)

* Add editorconfig

* BREAKING: Make Promise based

Fixes #249

Changes the callback based API:s to instead be async and return Promises.

* Keep cli() not returning a promise

Author: voxpelli

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

README.md

@@ -299,7 +299,7 @@ Modify and return `eslintConfig`, or return a new object with the eslint config
 
 ## API Usage
 
-### `engine.lintText(text, [opts], callback)`
+### `engine.lintText(text, [opts])`
 
 Lint the provided source `text` to enforce your defined style. An `opts` object may
 be provided:
@@ -326,7 +326,7 @@ All options are optional, though some ESLint plugins require the `filename` opti
 
 Additional options may be loaded from a `package.json` if it's found for the current working directory. See below for further details.
 
-The `callback` will be called with an `Error` and `results` object.
+Returns a `Promise` resolving to the `results` or rejected with an `Error`.
 
 The `results` object will contain the following properties:
 
@@ -379,7 +379,7 @@ Additional options may be loaded from a `package.json` if it's found for the cur
 
 Both `ignore` and `files` patterns are resolved relative to the current working directory.
 
-The `callback` will be called with an `Error` and `results` object (same as above).
+Returns a `Promise` resolving to the `results` or rejected with an `Error` (same as above).
 
 **NOTE: There is no synchronous version of `engine.lintFiles()`.**
 

bin/cmd.js

@@ -14,6 +14,7 @@ const getStdin = require('get-stdin')
 
 /**
  * @param {Omit<import('../').LinterOptions, 'cmd'> & StandardCliOptions} rawOpts
+ * @returns {void}
  */
 function cli (rawOpts) {
   const opts = {
@@ -99,24 +100,50 @@ Flags (advanced):
     parser: argv.parser
   }
 
-  /** @type {string} */
-  let stdinText
+  const outputFixed = argv.stdin && argv.fix
 
-  if (argv.stdin) {
-    getStdin().then(function (text) {
-      stdinText = text
-      standard.lintText(text, lintOpts, onResult)
-    })
-  } else {
-    standard.lintFiles(argv._, lintOpts, onResult)
+  /**
+   * Print lint errors to stdout -- this is expected output from `standard-engine`.
+   * Note: When fixing code from stdin (`standard --stdin --fix`), the transformed
+   * code is printed to stdout, so print lint errors to stderr in this case.
+   * @type {typeof console.log}
+   */
+  const log = (...args) => {
+    if (outputFixed) {
+      args[0] = opts.cmd + ': ' + args[0]
+      console.error.apply(console, args)
+    } else {
+      console.log.apply(console, args)
+    }
   }
 
-  /** @type {import('../').LinterCallback} */
-  function onResult (err, result) {
-    if (err) return onError(err)
+  Promise.resolve(argv.stdin ? getStdin() : '').then(async stdinText => {
+    /** @type {import('eslint').CLIEngine.LintReport} */
+    let result
+
+    try {
+      result = argv.stdin
+        ? await standard.lintText(stdinText, lintOpts)
+        : await standard.lintFiles(argv._, lintOpts)
+    } catch (err) {
+      console.error(opts.cmd + ': Unexpected linter output:\n')
+      if (err instanceof Error) {
+        console.error(err.stack || err.message)
+      } else {
+        console.error(err)
+      }
+      console.error(
+        '\nIf you think this is a bug in `%s`, open an issue: %s',
+        opts.cmd,
+        opts.bugs
+      )
+      process.exitCode = 1
+      return
+    }
+
     if (!result) throw new Error('expected a result')
 
-    if (argv.stdin && argv.fix) {
+    if (outputFixed) {
       if (result.results[0] && result.results[0].output) {
         // Code contained fixable errors, so print the fixed code
         process.stdout.write(result.results[0].output)
@@ -134,11 +161,7 @@ Flags (advanced):
     console.error('%s: %s (%s)', opts.cmd, opts.tagline, opts.homepage)
 
     // Are any warnings present?
-    const isSomeWarnings = result.results.some(function (result) {
-      return result.messages.some(function (message) {
-        return message.severity === 1
-      })
-    })
+    const isSomeWarnings = result.results.some(item => item.messages.some(message => message.severity === 1))
 
     if (isSomeWarnings) {
       const homepage = opts.homepage != null ? ` (${opts.homepage})` : ''
@@ -150,11 +173,7 @@ Flags (advanced):
     }
 
     // Are any fixable rules present?
-    const isSomeFixable = result.results.some(function (result) {
-      return result.messages.some(function (message) {
-        return !!message.fix
-      })
-    })
+    const isSomeFixable = result.results.some(item => item.messages.some(message => !!message.fix))
 
     if (isSomeFixable) {
       console.error(
@@ -164,53 +183,23 @@ Flags (advanced):
       )
     }
 
-    result.results.forEach(function (result) {
-      result.messages.forEach(function (message) {
+    for (const item of result.results) {
+      for (const message of item.messages) {
         log(
           '  %s:%d:%d: %s%s%s',
-          result.filePath,
+          item.filePath,
           message.line || 0,
           message.column || 0,
           message.message,
           ' (' + message.ruleId + ')',
           message.severity === 1 ? ' (warning)' : ''
         )
-      })
-    })
-
-    process.exitCode = result.errorCount ? 1 : 0
-  }
-
-  /** @param {Error|unknown} err */
-  function onError (err) {
-    console.error(opts.cmd + ': Unexpected linter output:\n')
-    if (err instanceof Error) {
-      console.error(err.stack || err.message)
-    } else {
-      console.error(err)
+      }
     }
-    console.error(
-      '\nIf you think this is a bug in `%s`, open an issue: %s',
-      opts.cmd,
-      opts.bugs
-    )
-    process.exitCode = 1
-  }
 
-  /**
-   * Print lint errors to stdout -- this is expected output from `standard-engine`.
-   * Note: When fixing code from stdin (`standard --stdin --fix`), the transformed
-   * code is printed to stdout, so print lint errors to stderr in this case.
-   * @type {typeof console.log}
-   */
-  function log (...args) {
-    if (argv.stdin && argv.fix) {
-      args[0] = opts.cmd + ': ' + args[0]
-      console.error.apply(console, args)
-    } else {
-      console.log.apply(console, args)
-    }
-  }
+    process.exitCode = result.errorCount ? 1 : 0
+  })
+    .catch(err => process.nextTick(() => { throw err }))
 }
 
 module.exports = cli

index.js

@@ -9,7 +9,6 @@ const { resolveEslintConfig } = require('./lib/resolve-eslint-config')
 
 /** @typedef {ConstructorParameters<typeof import('eslint').CLIEngine>[0]} CLIEngineOptions */
 /** @typedef {Omit<import('./lib/resolve-eslint-config').ResolveOptions, 'cmd'|'cwd'>} BaseLintOptions */
-/** @typedef {(err: Error|unknown, result?: import('eslint').CLIEngine.LintReport) => void} LinterCallback */
 
 /**
  * @typedef LinterOptions
@@ -82,51 +81,32 @@ class Linter {
    *
    * @param {string} text file text to lint
    * @param {Omit<BaseLintOptions, 'ignore'|'noDefaultIgnore'> & { filename?: string }} [opts] base options + path of file containing the text being linted
-   * @param {LinterCallback} [cb]
-   * @returns {void}
+   * @returns {Promise<import('eslint').CLIEngine.LintReport>}
    */
-  lintText (text, opts, cb) {
-    if (typeof opts === 'function') return this.lintText(text, undefined, opts)
-    if (!cb) throw new Error('callback is required')
-
-    let result
-    try {
-      result = this.lintTextSync(text, opts)
-    } catch (err) {
-      return process.nextTick(cb, err)
-    }
-    process.nextTick(cb, null, result)
+  async lintText (text, opts) {
+    return this.lintTextSync(text, opts)
   }
 
   /**
    * Lint files to enforce JavaScript Style.
    *
-   * @param {Array.<string>} files          file globs to lint
+   * @param {Array<string>} files file globs to lint
    * @param {BaseLintOptions & { cwd?: string }} [opts] base options + file globs to ignore (has sane defaults) + current working directory (default: process.cwd())
-   * @param {LinterCallback} [cb]
-   * @returns {void}
+   * @returns {Promise<import('eslint').CLIEngine.LintReport>}
    */
-  lintFiles (files, opts, cb) {
-    if (typeof opts === 'function') { return this.lintFiles(files, undefined, opts) }
-    if (!cb) throw new Error('callback is required')
-
+  async lintFiles (files, opts) {
     const eslintConfig = this.resolveEslintConfig(opts)
 
     if (typeof files === 'string') files = [files]
     if (files.length === 0) files = ['.']
 
-    let result
-    try {
-      result = new this.eslint.CLIEngine(eslintConfig).executeOnFiles(files)
-    } catch (err) {
-      return cb(err)
-    }
+    const result = new this.eslint.CLIEngine(eslintConfig).executeOnFiles(files)
 
     if (eslintConfig.fix) {
       this.eslint.CLIEngine.outputFixes(result)
     }
 
-    return cb(null, result)
+    return result
   }
 
   /**

test/api.js

@@ -4,55 +4,51 @@ const test = require('tape')
 
 const { Linter } = require('../')
 
-function getStandard () {
+async function getStandard () {
   return new Linter({
     cmd: 'pocketlint',
     version: '0.0.0',
     eslint,
-    eslintConfig: require('../tmp/standard/options').eslintConfig
+    eslintConfig: (await import('../tmp/standard/options.js')).default.eslintConfig
   })
 }
 
-test('api: lintFiles', function (t) {
-  t.plan(3)
-  const standard = getStandard()
-  standard.lintFiles([], { cwd: path.join(__dirname, '../bin') }, function (err, result) {
-    t.error(err, 'no error while linting')
-    t.equal(typeof result, 'object', 'result is an object')
-    t.equal(result.errorCount, 0)
-  })
+test('api: lintFiles', async function (t) {
+  t.plan(2)
+  const standard = await getStandard()
+  const result = await standard.lintFiles([], { cwd: path.join(__dirname, '../bin') })
+  t.equal(typeof result, 'object', 'result is an object')
+  t.equal(result.errorCount, 0)
 })
 
-test('api: lintText', function (t) {
-  t.plan(3)
-  const standard = getStandard()
-  standard.lintText('console.log("hi there")\n', function (err, result) {
-    t.error(err, 'no error while linting')
-    t.equal(typeof result, 'object', 'result is an object')
-    t.equal(result.errorCount, 1, 'should have used single quotes')
-  })
+test('api: lintText', async function (t) {
+  t.plan(2)
+  const standard = await getStandard()
+  const result = await standard.lintText('console.log("hi there")\n')
+  t.equal(typeof result, 'object', 'result is an object')
+  t.equal(result.errorCount, 1, 'should have used single quotes')
 })
 
-test('api: lintTextSync', function (t) {
+test('api: lintTextSync', async function (t) {
   t.plan(2)
-  const standard = getStandard()
+  const standard = await getStandard()
   const result = standard.lintTextSync('console.log("hi there")\n')
   t.equal(typeof result, 'object', 'result is an object')
   t.equal(result.errorCount, 1, 'should have used single quotes')
 })
 
-test('api: resolveEslintConfig -- avoid this.eslintConfig parser mutation', function (t) {
+test('api: resolveEslintConfig -- avoid this.eslintConfig parser mutation', async function (t) {
   t.plan(2)
-  const standard = getStandard()
-  const opts = standard.resolveEslintConfig({ parser: 'blah' })
+  const standard = await getStandard()
+  const opts = await standard.resolveEslintConfig({ parser: 'blah' })
   t.equal(opts.parser, 'blah')
   t.equal(standard.eslintConfig.parser, undefined)
 })
 
-test('api: resolveEslintConfig -- avoid this.eslintConfig global mutation', function (t) {
+test('api: resolveEslintConfig -- avoid this.eslintConfig global mutation', async function (t) {
   t.plan(2)
-  const standard = getStandard()
-  const opts = standard.resolveEslintConfig({ globals: ['what'] })
+  const standard = await getStandard()
+  const opts = await standard.resolveEslintConfig({ globals: ['what'] })
   t.deepEqual(opts.globals, ['what'])
   t.deepEqual(standard.eslintConfig.globals, [])
 })