js-build-tools 6.5.0 → 6.7.0

package/functions/partials/neostandardLint.mjs

@@ -1,142 +1,142 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import through from 'through2'
-import { ESLint } from 'eslint'
-import { importModule } from './loadPeer.mjs'
-
-// neostandard (js-build-tools' chosen style - a maintained, TypeScript-aware successor to `standard`, see
-// https://github.com/neostandard/neostandard) ships ESM-only, see importModule for how it is imported.
-const importNeostandard = () => importModule('neostandard')
-
-/**
- * Read the `env` a project already declared for Standard (the `standard` field in its package.json), so a project
- * migrating from `standard` keeps its globals (jest, browser, ...) without touching package.json.
- * @param {string} cwd
- * @returns {Array<string>}
- * @private
- */
-const readEnv = cwd => {
-  try {
-    return JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8')).standard?.env ?? []
-  } catch {
-    return []
-  }
-}
-
-/**
- * Build an ESLint instance configured with neostandard, honoring the project's own package.json `standard.env`,
- * plus an optional layer of rule overrides (see gulp.config.mjs's `lint.rules`) for a rule that is wrong for this
- * project specifically rather than something to fix in its code - for example a test fixture whose content
- * neostandard mistakes for a real syntax problem. Scoped to the same files neostandard itself lints (its own
- * `defaultFilePatterns.all`), per neostandard's own guidance: an unscoped rule-tweak layer would otherwise apply
- * to every lintable file, including ones from an unrelated plugin this project never defined.
- * @param {Object} options
- * @param {string} options.cwd
- * @param {boolean} options.ts
- * @param {boolean} options.fix
- * @param {Object<string, *>} [options.rules={}]
- * @returns {Promise<ESLint>} eslint's ESLint instance
- * @private
- */
-const buildEslint = async ({ cwd, ts, fix, rules = {} }) => {
-  const { neostandard, defaultFilePatterns } = await importNeostandard()
-  const baseConfig = neostandard({ ts, env: readEnv(cwd) })
-  if (Object.keys(rules).length) {
-    baseConfig.push({ files: defaultFilePatterns.all, rules })
-  }
-  return new ESLint({
-    cwd,
-    fix,
-    overrideConfigFile: true,
-    baseConfig
-  })
-}
-
-/**
- * Print a file's lint messages, if it has any.
- * @memberOf module:partials
- * @param {Vinyl} file
- * @param {{messages: Array<{line: number, column: number, message: string}>, errorCount: number, warningCount: number}} result
- * @returns {undefined}
- */
-const printFileReport = (file, result) => {
-  if (!result.messages.length) {
-    return
-  }
-  console.log(path.relative(file.cwd, file.path))
-  result.messages.forEach(({ line, column, message }) => console.log(`line ${line}:${column}\t${message}`))
-  console.log(`✖ ${result.errorCount} error\t⚠ ${result.warningCount} warning\n`)
-}
-
-/**
- * Lint every file streaming through with neostandard and, unless `fix` is false, apply the automatic fixes to the
- * file's contents so a following `dest()` writes the fixed version. Remaining problems are printed along with a
- * summary once the stream ends; they only fail the stream when `failOnError` is set (the standalone `lint` task),
- * never during `build`.
- *
- * One ESLint instance is built from the first file's own cwd and reused for the rest of the stream, since every
- * file in a given lint pass shares the same project (and so the same config).
- * @memberOf module:partials
- * @param {Object} [options={}]
- * @param {boolean} [options.fix=true] - Apply neostandard's automatic fixes to the file contents.
- * @param {boolean} [options.ts=false] - Lint `.ts` files too, with type-aware rules (see neostandard's `ts` option).
- * @param {Object<string, *>} [options.rules={}] - ESLint rule overrides layered on top of neostandard's own rules
- * (see gulp.config.mjs's `lint.rules`).
- * @param {boolean} [options.failOnError=false] - Emit an error once the stream ends if any lint errors remain after
- * fixing, so a command-line run exits non-zero.
- * @param {function(Object): Promise<{lintText: Function}>} [loadEslint] - Resolves an ESLint-shaped linter. Real
- * callers should never need to pass this - it exists so tests can supply a stand-in, since this project's
- * CommonJS-transform-based Jest setup cannot execute a real dynamic import() of neostandard (ESM-only).
- * @returns {stream.Transform} With a `totals` property ({errors, warnings}), complete once the stream ends.
- */
-export const neostandardLint = (
-  { fix = true, ts = false, rules = {}, failOnError = false } = {},
-  loadEslint = buildEslint
-) => {
-  const totals = { errors: 0, warnings: 0 }
-  let eslintPromise = null
-  const linter = through.obj(
-    function (file, enc, callback) {
-      if (file.isNull()) {
-        callback(null, file)
-        return
-      }
-      if (file.isStream()) {
-        callback(new Error('neostandardLint: streaming file contents are not supported.'))
-        return
-      }
-      if (!eslintPromise) {
-        eslintPromise = loadEslint({ cwd: file.cwd, ts, fix, rules })
-      }
-      eslintPromise
-        .then(eslint => eslint.lintText(file.contents.toString(), { filePath: file.path }))
-        .then(results => {
-          // No result at all means the file is ignored by the project's ESLint configuration.
-          const [result] = results
-          if (result) {
-            if (typeof result.output === 'string') {
-              file.contents = Buffer.from(result.output)
-            }
-            totals.errors += result.errorCount
-            totals.warnings += result.warningCount
-            printFileReport(file, result)
-          }
-          callback(null, file)
-        }, callback)
-    },
-    function (callback) {
-      console.log('neostandard linter results')
-      console.log('======================================')
-      console.log(`✖ Errors total: ${totals.errors}`)
-      console.log(`⚠ Warnings total: ${totals.warnings}\n`)
-      if (failOnError && totals.errors) {
-        callback(new Error(`neostandard found ${totals.errors} lint error(s) that could not be fixed automatically.`))
-        return
-      }
-      callback()
-    }
-  )
-  // Read by lintSource, which can only fail once the fixed files have been written, after this stream has ended.
-  linter.totals = totals
-  return linter
-}
+import fs from 'node:fs'
+import path from 'node:path'
+import through from 'through2'
+import { ESLint } from 'eslint'
+import { importModule } from './loadPeer.mjs'
+
+// neostandard (js-build-tools' chosen style - a maintained, TypeScript-aware successor to `standard`, see
+// https://github.com/neostandard/neostandard) ships ESM-only, see importModule for how it is imported.
+const importNeostandard = () => importModule('neostandard')
+
+/**
+ * Read the `env` a project already declared for Standard (the `standard` field in its package.json), so a project
+ * migrating from `standard` keeps its globals (jest, browser, ...) without touching package.json.
+ * @param {string} cwd
+ * @returns {Array<string>}
+ * @private
+ */
+const readEnv = cwd => {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8')).standard?.env ?? []
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Build an ESLint instance configured with neostandard, honoring the project's own package.json `standard.env`,
+ * plus an optional layer of rule overrides (see gulp.config.mjs's `lint.rules`) for a rule that is wrong for this
+ * project specifically rather than something to fix in its code - for example a test fixture whose content
+ * neostandard mistakes for a real syntax problem. Scoped to the same files neostandard itself lints (its own
+ * `defaultFilePatterns.all`), per neostandard's own guidance: an unscoped rule-tweak layer would otherwise apply
+ * to every lintable file, including ones from an unrelated plugin this project never defined.
+ * @param {Object} options
+ * @param {string} options.cwd
+ * @param {boolean} options.ts
+ * @param {boolean} options.fix
+ * @param {Object<string, *>} [options.rules={}]
+ * @returns {Promise<ESLint>} eslint's ESLint instance
+ * @private
+ */
+const buildEslint = async ({ cwd, ts, fix, rules = {} }) => {
+  const { neostandard, defaultFilePatterns } = await importNeostandard()
+  const baseConfig = neostandard({ ts, env: readEnv(cwd) })
+  if (Object.keys(rules).length) {
+    baseConfig.push({ files: defaultFilePatterns.all, rules })
+  }
+  return new ESLint({
+    cwd,
+    fix,
+    overrideConfigFile: true,
+    baseConfig
+  })
+}
+
+/**
+ * Print a file's lint messages, if it has any.
+ * @memberOf module:partials
+ * @param {Vinyl} file
+ * @param {{messages: Array<{line: number, column: number, message: string}>, errorCount: number, warningCount: number}} result
+ * @returns {undefined}
+ */
+const printFileReport = (file, result) => {
+  if (!result.messages.length) {
+    return
+  }
+  console.log(path.relative(file.cwd, file.path))
+  result.messages.forEach(({ line, column, message }) => console.log(`line ${line}:${column}\t${message}`))
+  console.log(`✖ ${result.errorCount} error\t⚠ ${result.warningCount} warning\n`)
+}
+
+/**
+ * Lint every file streaming through with neostandard and, unless `fix` is false, apply the automatic fixes to the
+ * file's contents so a following `dest()` writes the fixed version. Remaining problems are printed along with a
+ * summary once the stream ends; they only fail the stream when `failOnError` is set (the standalone `lint` task),
+ * never during `build`.
+ *
+ * One ESLint instance is built from the first file's own cwd and reused for the rest of the stream, since every
+ * file in a given lint pass shares the same project (and so the same config).
+ * @memberOf module:partials
+ * @param {Object} [options={}]
+ * @param {boolean} [options.fix=true] - Apply neostandard's automatic fixes to the file contents.
+ * @param {boolean} [options.ts=false] - Lint `.ts` files too, with type-aware rules (see neostandard's `ts` option).
+ * @param {Object<string, *>} [options.rules={}] - ESLint rule overrides layered on top of neostandard's own rules
+ * (see gulp.config.mjs's `lint.rules`).
+ * @param {boolean} [options.failOnError=false] - Emit an error once the stream ends if any lint errors remain after
+ * fixing, so a command-line run exits non-zero.
+ * @param {function(Object): Promise<{lintText: Function}>} [loadEslint] - Resolves an ESLint-shaped linter. Real
+ * callers should never need to pass this - it exists so tests can supply a stand-in, since this project's
+ * CommonJS-transform-based Jest setup cannot execute a real dynamic import() of neostandard (ESM-only).
+ * @returns {stream.Transform} With a `totals` property ({errors, warnings}), complete once the stream ends.
+ */
+export const neostandardLint = (
+  { fix = true, ts = false, rules = {}, failOnError = false } = {},
+  loadEslint = buildEslint
+) => {
+  const totals = { errors: 0, warnings: 0 }
+  let eslintPromise = null
+  const linter = through.obj(
+    function (file, enc, callback) {
+      if (file.isNull()) {
+        callback(null, file)
+        return
+      }
+      if (file.isStream()) {
+        callback(new Error('neostandardLint: streaming file contents are not supported.'))
+        return
+      }
+      if (!eslintPromise) {
+        eslintPromise = loadEslint({ cwd: file.cwd, ts, fix, rules })
+      }
+      eslintPromise
+        .then(eslint => eslint.lintText(file.contents.toString(), { filePath: file.path }))
+        .then(results => {
+          // No result at all means the file is ignored by the project's ESLint configuration.
+          const [result] = results
+          if (result) {
+            if (typeof result.output === 'string') {
+              file.contents = Buffer.from(result.output)
+            }
+            totals.errors += result.errorCount
+            totals.warnings += result.warningCount
+            printFileReport(file, result)
+          }
+          callback(null, file)
+        }, callback)
+    },
+    function (callback) {
+      console.log('neostandard linter results')
+      console.log('======================================')
+      console.log(`✖ Errors total: ${totals.errors}`)
+      console.log(`⚠ Warnings total: ${totals.warnings}\n`)
+      if (failOnError && totals.errors) {
+        callback(new Error(`neostandard found ${totals.errors} lint error(s) that could not be fixed automatically.`))
+        return
+      }
+      callback()
+    }
+  )
+  // Read by lintSource, which can only fail once the fixed files have been written, after this stream has ended.
+  linter.totals = totals
+  return linter
+}

package/functions/partials/neostandardLint.test.mjs

@@ -1,131 +1,131 @@
-import Vinyl from 'vinyl'
-import { Readable } from 'node:stream'
-import { neostandardLint } from './neostandardLint.mjs'
-
-const makeFile = (contents, filePath = '/project/src/example.js') => new Vinyl({
-  cwd: '/project',
-  base: '/project/src',
-  path: filePath,
-  contents
-})
-
-const run = (transform, files) => new Promise((resolve, reject) => {
-  const out = []
-  transform.on('data', file => out.push(file)).on('end', () => resolve(out)).on('error', reject)
-  files.forEach(file => transform.write(file))
-  transform.end()
-})
-
-const fakeEslint = (resultFor) => ({
-  lintText: jest.fn((text, options) => Promise.resolve(resultFor(text, options)))
-})
-
-let logSpy
-
-beforeEach(() => {
-  logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
-})
-
-afterEach(() => {
-  logSpy.mockRestore()
-})
-
-describe('neostandardLint', () => {
-  test('replaces file contents with the fixed output and hands ESLint the file path', async () => {
-    expect.assertions(3)
-    const eslint = fakeEslint((text) => [{ messages: [], errorCount: 0, warningCount: 0, output: text.replace(/"/g, '\'') }])
-    const [linted] = await run(neostandardLint({ fix: true }, () => Promise.resolve(eslint)), [makeFile(Buffer.from('const a = "b"'))])
-    expect(linted.contents.toString()).toEqual('const a = \'b\'')
-    expect(eslint.lintText).toHaveBeenCalledWith('const a = "b"', { filePath: '/project/src/example.js' })
-    expect(linted.path).toEqual('/project/src/example.js')
-  })
-
-  test('leaves the contents alone when ESLint has no fixed output (nothing needed fixing)', async () => {
-    expect.assertions(1)
-    const eslint = fakeEslint(() => [{ messages: [], errorCount: 0, warningCount: 0 }])
-    const [linted] = await run(neostandardLint({}, () => Promise.resolve(eslint)), [makeFile(Buffer.from('const a = 1'))])
-    expect(linted.contents.toString()).toEqual('const a = 1')
-  })
-
-  test('builds the linter once per stream, from the first file, and reuses it for the rest', async () => {
-    expect.assertions(1)
-    const loadEslint = jest.fn(() => Promise.resolve(fakeEslint(() => [{ messages: [], errorCount: 0, warningCount: 0 }])))
-    await run(
-      neostandardLint({}, loadEslint),
-      [makeFile(Buffer.from('a'), '/project/src/a.js'), makeFile(Buffer.from('b'), '/project/src/b.js')]
-    )
-    expect(loadEslint).toHaveBeenCalledTimes(1)
-  })
-
-  test('passes fix and ts through to the loader', async () => {
-    expect.assertions(1)
-    const loadEslint = jest.fn(() => Promise.resolve(fakeEslint(() => [{ messages: [], errorCount: 0, warningCount: 0 }])))
-    await run(neostandardLint({ fix: false, ts: true }, loadEslint), [makeFile(Buffer.from('x'))])
-    expect(loadEslint).toHaveBeenCalledWith({ cwd: '/project', ts: true, fix: false, rules: {} })
-  })
-
-  test('passes rule overrides through to the loader', async () => {
-    expect.assertions(1)
-    const loadEslint = jest.fn(() => Promise.resolve(fakeEslint(() => [{ messages: [], errorCount: 0, warningCount: 0 }])))
-    const rules = { 'no-template-curly-in-string': 'off' }
-    await run(neostandardLint({ rules }, loadEslint), [makeFile(Buffer.from('x'))])
-    expect(loadEslint).toHaveBeenCalledWith({ cwd: '/project', ts: false, fix: true, rules })
-  })
-
-  test('passes a file through untouched when the project ignores it (ESLint returns no results)', async () => {
-    expect.assertions(2)
-    const eslint = fakeEslint(() => [])
-    const [linted] = await run(neostandardLint({}, () => Promise.resolve(eslint)), [makeFile(Buffer.from('var x=1'))])
-    expect(linted.contents.toString()).toEqual('var x=1')
-    expect(logSpy).toHaveBeenCalledWith('✖ Errors total: 0')
-  })
-
-  test('skips null-content files without linting them', async () => {
-    expect.assertions(2)
-    const eslint = fakeEslint(() => [])
-    const [passed] = await run(neostandardLint({}, () => Promise.resolve(eslint)), [makeFile(null)])
-    expect(passed.isNull()).toBeTruthy()
-    expect(eslint.lintText).not.toHaveBeenCalled()
-  })
-
-  test('errors on streaming file contents, which cannot be linted', async () => {
-    expect.assertions(1)
-    const streamFile = makeFile(Readable.from(['x']))
-    await expect(run(neostandardLint({}, () => Promise.resolve(fakeEslint(() => []))), [streamFile])).rejects.toThrow(/streaming/)
-  })
-
-  test('prints per-file problems and a summary of totals across all files, without failing', async () => {
-    expect.assertions(5)
-    const eslint = fakeEslint((text, { filePath }) => filePath.endsWith('a.js')
-      ? [{ messages: [{ line: 2, column: 7, message: 'unused b' }, { line: 3, column: 1, message: 'bad thing' }], errorCount: 2, warningCount: 0 }]
-      : [{ messages: [{ line: 1, column: 1, message: 'just a warning' }], errorCount: 0, warningCount: 1 }])
-    const out = await run(
-      neostandardLint({}, () => Promise.resolve(eslint)),
-      [makeFile(Buffer.from('a'), '/project/src/a.js'), makeFile(Buffer.from('b'), '/project/src/b.js')]
-    )
-    expect(out).toHaveLength(2)
-    expect(logSpy).toHaveBeenCalledWith('src/a.js')
-    expect(logSpy).toHaveBeenCalledWith('line 2:7\tunused b')
-    expect(logSpy).toHaveBeenCalledWith('✖ Errors total: 2')
-    expect(logSpy).toHaveBeenCalledWith('⚠ Warnings total: 1\n')
-  })
-
-  test('with failOnError, fails the stream once it ends if any errors remain', async () => {
-    expect.assertions(2)
-    const eslint = fakeEslint(() => [{ messages: [{ line: 1, column: 1, message: 'bad thing' }], errorCount: 1, warningCount: 0 }])
-    await expect(run(neostandardLint({ failOnError: true }, () => Promise.resolve(eslint)), [makeFile(Buffer.from('a'))]))
-      .rejects.toThrow('neostandard found 1 lint error(s)')
-    expect(logSpy).toHaveBeenCalledWith('✖ Errors total: 1')
-  })
-
-  test('with failOnError, still passes when there are only warnings', async () => {
-    expect.assertions(1)
-    const eslint = fakeEslint(() => [{ messages: [{ line: 1, column: 1, message: 'just a warning' }], errorCount: 0, warningCount: 1 }])
-    await expect(run(neostandardLint({ failOnError: true }, () => Promise.resolve(eslint)), [makeFile(Buffer.from('a'))])).resolves.toHaveLength(1)
-  })
-
-  test('surfaces a failure to load or run the linter as a stream error', async () => {
-    expect.assertions(1)
-    await expect(run(neostandardLint({}, () => Promise.reject(new Error('cannot load'))), [makeFile(Buffer.from('x'))])).rejects.toThrow('cannot load')
-  })
-})
+import Vinyl from 'vinyl'
+import { Readable } from 'node:stream'
+import { neostandardLint } from './neostandardLint.mjs'
+
+const makeFile = (contents, filePath = '/project/src/example.js') => new Vinyl({
+  cwd: '/project',
+  base: '/project/src',
+  path: filePath,
+  contents
+})
+
+const run = (transform, files) => new Promise((resolve, reject) => {
+  const out = []
+  transform.on('data', file => out.push(file)).on('end', () => resolve(out)).on('error', reject)
+  files.forEach(file => transform.write(file))
+  transform.end()
+})
+
+const fakeEslint = (resultFor) => ({
+  lintText: jest.fn((text, options) => Promise.resolve(resultFor(text, options)))
+})
+
+let logSpy
+
+beforeEach(() => {
+  logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+})
+
+afterEach(() => {
+  logSpy.mockRestore()
+})
+
+describe('neostandardLint', () => {
+  test('replaces file contents with the fixed output and hands ESLint the file path', async () => {
+    expect.assertions(3)
+    const eslint = fakeEslint((text) => [{ messages: [], errorCount: 0, warningCount: 0, output: text.replace(/"/g, '\'') }])
+    const [linted] = await run(neostandardLint({ fix: true }, () => Promise.resolve(eslint)), [makeFile(Buffer.from('const a = "b"'))])
+    expect(linted.contents.toString()).toEqual('const a = \'b\'')
+    expect(eslint.lintText).toHaveBeenCalledWith('const a = "b"', { filePath: '/project/src/example.js' })
+    expect(linted.path).toEqual('/project/src/example.js')
+  })
+
+  test('leaves the contents alone when ESLint has no fixed output (nothing needed fixing)', async () => {
+    expect.assertions(1)
+    const eslint = fakeEslint(() => [{ messages: [], errorCount: 0, warningCount: 0 }])
+    const [linted] = await run(neostandardLint({}, () => Promise.resolve(eslint)), [makeFile(Buffer.from('const a = 1'))])
+    expect(linted.contents.toString()).toEqual('const a = 1')
+  })
+
+  test('builds the linter once per stream, from the first file, and reuses it for the rest', async () => {
+    expect.assertions(1)
+    const loadEslint = jest.fn(() => Promise.resolve(fakeEslint(() => [{ messages: [], errorCount: 0, warningCount: 0 }])))
+    await run(
+      neostandardLint({}, loadEslint),
+      [makeFile(Buffer.from('a'), '/project/src/a.js'), makeFile(Buffer.from('b'), '/project/src/b.js')]
+    )
+    expect(loadEslint).toHaveBeenCalledTimes(1)
+  })
+
+  test('passes fix and ts through to the loader', async () => {
+    expect.assertions(1)
+    const loadEslint = jest.fn(() => Promise.resolve(fakeEslint(() => [{ messages: [], errorCount: 0, warningCount: 0 }])))
+    await run(neostandardLint({ fix: false, ts: true }, loadEslint), [makeFile(Buffer.from('x'))])
+    expect(loadEslint).toHaveBeenCalledWith({ cwd: '/project', ts: true, fix: false, rules: {} })
+  })
+
+  test('passes rule overrides through to the loader', async () => {
+    expect.assertions(1)
+    const loadEslint = jest.fn(() => Promise.resolve(fakeEslint(() => [{ messages: [], errorCount: 0, warningCount: 0 }])))
+    const rules = { 'no-template-curly-in-string': 'off' }
+    await run(neostandardLint({ rules }, loadEslint), [makeFile(Buffer.from('x'))])
+    expect(loadEslint).toHaveBeenCalledWith({ cwd: '/project', ts: false, fix: true, rules })
+  })
+
+  test('passes a file through untouched when the project ignores it (ESLint returns no results)', async () => {
+    expect.assertions(2)
+    const eslint = fakeEslint(() => [])
+    const [linted] = await run(neostandardLint({}, () => Promise.resolve(eslint)), [makeFile(Buffer.from('var x=1'))])
+    expect(linted.contents.toString()).toEqual('var x=1')
+    expect(logSpy).toHaveBeenCalledWith('✖ Errors total: 0')
+  })
+
+  test('skips null-content files without linting them', async () => {
+    expect.assertions(2)
+    const eslint = fakeEslint(() => [])
+    const [passed] = await run(neostandardLint({}, () => Promise.resolve(eslint)), [makeFile(null)])
+    expect(passed.isNull()).toBeTruthy()
+    expect(eslint.lintText).not.toHaveBeenCalled()
+  })
+
+  test('errors on streaming file contents, which cannot be linted', async () => {
+    expect.assertions(1)
+    const streamFile = makeFile(Readable.from(['x']))
+    await expect(run(neostandardLint({}, () => Promise.resolve(fakeEslint(() => []))), [streamFile])).rejects.toThrow(/streaming/)
+  })
+
+  test('prints per-file problems and a summary of totals across all files, without failing', async () => {
+    expect.assertions(5)
+    const eslint = fakeEslint((text, { filePath }) => filePath.endsWith('a.js')
+      ? [{ messages: [{ line: 2, column: 7, message: 'unused b' }, { line: 3, column: 1, message: 'bad thing' }], errorCount: 2, warningCount: 0 }]
+      : [{ messages: [{ line: 1, column: 1, message: 'just a warning' }], errorCount: 0, warningCount: 1 }])
+    const out = await run(
+      neostandardLint({}, () => Promise.resolve(eslint)),
+      [makeFile(Buffer.from('a'), '/project/src/a.js'), makeFile(Buffer.from('b'), '/project/src/b.js')]
+    )
+    expect(out).toHaveLength(2)
+    expect(logSpy).toHaveBeenCalledWith('src/a.js')
+    expect(logSpy).toHaveBeenCalledWith('line 2:7\tunused b')
+    expect(logSpy).toHaveBeenCalledWith('✖ Errors total: 2')
+    expect(logSpy).toHaveBeenCalledWith('⚠ Warnings total: 1\n')
+  })
+
+  test('with failOnError, fails the stream once it ends if any errors remain', async () => {
+    expect.assertions(2)
+    const eslint = fakeEslint(() => [{ messages: [{ line: 1, column: 1, message: 'bad thing' }], errorCount: 1, warningCount: 0 }])
+    await expect(run(neostandardLint({ failOnError: true }, () => Promise.resolve(eslint)), [makeFile(Buffer.from('a'))]))
+      .rejects.toThrow('neostandard found 1 lint error(s)')
+    expect(logSpy).toHaveBeenCalledWith('✖ Errors total: 1')
+  })
+
+  test('with failOnError, still passes when there are only warnings', async () => {
+    expect.assertions(1)
+    const eslint = fakeEslint(() => [{ messages: [{ line: 1, column: 1, message: 'just a warning' }], errorCount: 0, warningCount: 1 }])
+    await expect(run(neostandardLint({ failOnError: true }, () => Promise.resolve(eslint)), [makeFile(Buffer.from('a'))])).resolves.toHaveLength(1)
+  })
+
+  test('surfaces a failure to load or run the linter as a stream error', async () => {
+    expect.assertions(1)
+    await expect(run(neostandardLint({}, () => Promise.reject(new Error('cannot load'))), [makeFile(Buffer.from('x'))])).rejects.toThrow('cannot load')
+  })
+})

package/functions/partials/readmeTemplate.mjs

@@ -1,12 +1,12 @@
-import { dest, src } from 'gulp'
-import * as gulpConfig from '../../gulp.config.mjs'
-import rename from 'gulp-rename'
-
-/**
- * Copy a readme template into the README.md file.
- * @memberOf module:partials
- * @returns {*}
- */
-export const readmeTemplate = () => src(gulpConfig.get('readme.template'))
-  .pipe(rename(gulpConfig.get('readme.file')))
-  .pipe(dest(gulpConfig.get('readme.to')))
+import { dest, src } from 'gulp'
+import * as gulpConfig from '../../gulp.config.mjs'
+import rename from 'gulp-rename'
+
+/**
+ * Copy a readme template into the README.md file.
+ * @memberOf module:partials
+ * @returns {*}
+ */
+export const readmeTemplate = () => src(gulpConfig.get('readme.template'))
+  .pipe(rename(gulpConfig.get('readme.file')))
+  .pipe(dest(gulpConfig.get('readme.to')))

package/functions/partials/readmeTemplate.test.mjs

@@ -1,34 +1,34 @@
-import fs from 'fs'
-import * as setUp from '../test-helpers/setUp.mjs'
-import { readmeTemplate } from './readmeTemplate.mjs'
-
-setUp.setDefaults('test-readme-template')
-const gulpConfig = setUp.gulpConfig
-
-const mainMd = 'MAIN.md'
-const mainTestPath = gulpConfig.get('readme.template')
-
-beforeEach(() => setUp.beforeEach()
-  .then(() => fs.copyFileSync(mainMd, mainTestPath)))
-
-afterEach(setUp.afterEach)
-
-describe('readmeTemplate', () => {
-  test('copies the main contents into the new README.md', done => {
-    const readmeFilePath = gulpConfig.get('readme.to') + gulpConfig.get('readme.file')
-    const mainContents = fs.readFileSync(mainTestPath)
-    expect.assertions(2)
-    readmeTemplate()
-      .on('finish', async () => {
-        await expect(fs.existsSync(readmeFilePath)).toBeTruthy()
-        const readme = await fs.readFileSync(readmeFilePath)
-        // Confirm that the contents for MAIN.md are copied to README.md
-        await expect(readme).toEqual(mainContents)
-        done()
-      })
-      .on('error', error => {
-        console.error('Encountered error', error)
-        done()
-      })
-  })
-})
+import fs from 'fs'
+import * as setUp from '../test-helpers/setUp.mjs'
+import { readmeTemplate } from './readmeTemplate.mjs'
+
+setUp.setDefaults('test-readme-template')
+const gulpConfig = setUp.gulpConfig
+
+const mainMd = 'MAIN.md'
+const mainTestPath = gulpConfig.get('readme.template')
+
+beforeEach(() => setUp.beforeEach()
+  .then(() => fs.copyFileSync(mainMd, mainTestPath)))
+
+afterEach(setUp.afterEach)
+
+describe('readmeTemplate', () => {
+  test('copies the main contents into the new README.md', done => {
+    const readmeFilePath = gulpConfig.get('readme.to') + gulpConfig.get('readme.file')
+    const mainContents = fs.readFileSync(mainTestPath)
+    expect.assertions(2)
+    readmeTemplate()
+      .on('finish', async () => {
+        await expect(fs.existsSync(readmeFilePath)).toBeTruthy()
+        const readme = await fs.readFileSync(readmeFilePath)
+        // Confirm that the contents for MAIN.md are copied to README.md
+        await expect(readme).toEqual(mainContents)
+        done()
+      })
+      .on('error', error => {
+        console.error('Encountered error', error)
+        done()
+      })
+  })
+})