lint-staged 11.0.0 → 11.1.2

package/README.md

@@ -25,7 +25,7 @@ This project contains a script that will run arbitrary shell tasks with a list o
 The fastest way to start using lint-staged is to run the following command in your terminal:
 
 ```bash
-npx mrm lint-staged
+npx mrm@2 lint-staged
 ```
 
 This command will install and configure [husky](https://github.com/typicode/husky) and lint-staged depending on the code quality tools from your project's `package.json` dependencies, so please make sure you install (`npm install --save-dev`) and configure all code quality tools like [Prettier](https://prettier.io) and [ESLint](https://eslint.org) prior to that.
@@ -71,7 +71,7 @@ Options:
                                      tasks serially (default: true)
   -q, --quiet                        disable lint-staged’s own console output (default: false)
   -r, --relative                     pass relative filepaths to tasks (default: false)
-  -x, --shell                        skip parsing of tasks for better shell support (default:
+  -x, --shell [path]                 skip parsing of tasks for better shell support (default:
                                      false)
   -v, --verbose                      show task output even when tasks succeed; by default only
                                      failed output is shown (default: false)
@@ -90,7 +90,7 @@ Options:
 - **`--no-stash`**: By default a backup stash will be created before running the tasks, and all task modifications will be reverted in case of an error. This option will disable creating the stash, and instead leave all modifications in the index when aborting the commit.
 - **`--quiet`**: Supress all CLI output, except from tasks.
 - **`--relative`**: Pass filepaths relative to `process.cwd()` (where `lint-staged` runs) to tasks. Default is `false`.
-- **`--shell`**: By default linter commands will be parsed for speed and security. This has the side-effect that regular shell scripts might not work as expected. You can skip parsing of commands with this option.
+- **`--shell`**: By default linter commands will be parsed for speed and security. This has the side-effect that regular shell scripts might not work as expected. You can skip parsing of commands with this option. To use a specific shell, use a path like `--shell "/bin/bash"`.
 - **`--verbose`**: Show task output even when tasks succeed. By default only failed output is shown.
 
 ## Configuration
@@ -445,36 +445,14 @@ For example, here is `jest` running on all `.js` files with the `NODE_ENV` varia
 
 </details>
 
-### Automatically fix code style with `prettier` for any format prettier supports
+### Automatically fix code style with `prettier` for any format Prettier supports
 
 <details>
   <summary>Click to expand</summary>
 
-You need to add `micromatch` as a dev dependency.
-
-```sh
-$ npm i --save-dev micromatch
-```
-
-```js
-// lint-staged.config.js
-const micromatch = require('micromatch')
-const prettier = require('prettier')
-
-const prettierSupportedExtensions = prettier
-  .getSupportInfo()
-  .languages.map(({ extensions }) => extensions)
-  .flat()
-const addQuotes = (a) => `"${a}"`
-
-module.exports = (allStagedFiles) => {
-  const prettierFiles = micromatch(
-    allStagedFiles,
-    prettierSupportedExtensions.map((extension) => `**/*${extension}`)
-  )
-  return prettierFiles.length > 0
-    ? [`prettier --write ${prettierFiles.map(addQuotes).join(' ')}`]
-    : []
+```json
+{
+  "*": "prettier --ignore-unknown --write"
 }
 ```
 

package/bin/lint-staged.js

@@ -42,7 +42,7 @@ cmdline
   )
   .option('-q, --quiet', 'disable lint-staged’s own console output', false)
   .option('-r, --relative', 'pass relative filepaths to tasks', false)
-  .option('-x, --shell', 'skip parsing of tasks for better shell support', false)
+  .option('-x, --shell [path]', 'skip parsing of tasks for better shell support', false)
   .option(
     '-v, --verbose',
     'show task output even when tasks succeed; by default only failed output is shown',
@@ -85,7 +85,7 @@ const options = {
   stash: !!cmdlineOptions.stash, // commander inverts `no-<x>` flags to `!x`
   quiet: !!cmdlineOptions.quiet,
   relative: !!cmdlineOptions.relative,
-  shell: !!cmdlineOptions.shell,
+  shell: cmdlineOptions.shell /* Either a boolean or a string pointing to the shell */,
   verbose: !!cmdlineOptions.verbose,
 }
 

package/lib/generateTasks.js

@@ -16,39 +16,35 @@ const debug = require('debug')('lint-staged:gen-tasks')
  * @param {boolean} [options.files] - Staged filepaths
  * @param {boolean} [options.relative] - Whether filepaths to should be relative to gitDir
  */
-module.exports = function generateTasks({
-  config,
-  cwd = process.cwd(),
-  gitDir,
-  files,
-  relative = false,
-}) {
+const generateTasks = ({ config, cwd = process.cwd(), gitDir, files, relative = false }) => {
   debug('Generating linter tasks')
 
   const absoluteFiles = files.map((file) => normalize(path.resolve(gitDir, file)))
   const relativeFiles = absoluteFiles.map((file) => normalize(path.relative(cwd, file)))
 
-  return Object.entries(config).map(([pattern, commands]) => {
+  return Object.entries(config).map(([rawPattern, commands]) => {
+    let pattern = rawPattern
+
     const isParentDirPattern = pattern.startsWith('../')
 
-    const fileList = micromatch(
-      relativeFiles
-        // Only worry about children of the CWD unless the pattern explicitly
-        // specifies that it concerns a parent directory.
-        .filter((file) => {
-          if (isParentDirPattern) return true
-          return !file.startsWith('..') && !path.isAbsolute(file)
-        }),
-      pattern,
-      {
-        cwd,
-        dot: true,
-        // If pattern doesn't look like a path, enable `matchBase` to
-        // match against filenames in every directory. This makes `*.js`
-        // match both `test.js` and `subdirectory/test.js`.
-        matchBase: !pattern.includes('/'),
-      }
-    ).map((file) => normalize(relative ? file : path.resolve(cwd, file)))
+    // Only worry about children of the CWD unless the pattern explicitly
+    // specifies that it concerns a parent directory.
+    const filteredFiles = relativeFiles.filter((file) => {
+      if (isParentDirPattern) return true
+      return !file.startsWith('..') && !path.isAbsolute(file)
+    })
+
+    const matches = micromatch(filteredFiles, pattern, {
+      cwd,
+      dot: true,
+      // If the pattern doesn't look like a path, enable `matchBase` to
+      // match against filenames in every directory. This makes `*.js`
+      // match both `test.js` and `subdirectory/test.js`.
+      matchBase: !pattern.includes('/'),
+      strictBrackets: true,
+    })
+
+    const fileList = matches.map((file) => normalize(relative ? file : path.resolve(cwd, file)))
 
     const task = { pattern, commands, fileList }
     debug('Generated task: \n%O', task)
@@ -56,3 +52,5 @@ module.exports = function generateTasks({
     return task
   })
 }
+
+module.exports = generateTasks

package/lib/index.js

@@ -1,6 +1,5 @@
 'use strict'
 
-const dedent = require('dedent')
 const { cosmiconfig } = require('cosmiconfig')
 const debugLog = require('debug')('lint-staged')
 const stringifyObject = require('stringify-object')
@@ -8,13 +7,16 @@ const stringifyObject = require('stringify-object')
 const { PREVENTED_EMPTY_COMMIT, GIT_ERROR, RESTORE_STASH_EXAMPLE } = require('./messages')
 const printTaskOutput = require('./printTaskOutput')
 const runAll = require('./runAll')
-const { ApplyEmptyCommitError, GetBackupStashError, GitError } = require('./symbols')
-const formatConfig = require('./formatConfig')
+const {
+  ApplyEmptyCommitError,
+  ConfigNotFoundError,
+  GetBackupStashError,
+  GitError,
+} = require('./symbols')
 const validateConfig = require('./validateConfig')
+const validateOptions = require('./validateOptions')
 
-const errConfigNotFound = new Error('Config could not be found')
-
-function resolveConfig(configPath) {
+const resolveConfig = (configPath) => {
   try {
     return require.resolve(configPath)
   } catch {
@@ -22,7 +24,7 @@ function resolveConfig(configPath) {
   }
 }
 
-function loadConfig(configPath) {
+const loadConfig = (configPath) => {
   const explorer = cosmiconfig('lint-staged', {
     searchPlaces: [
       'package.json',
@@ -56,14 +58,14 @@ function loadConfig(configPath) {
  * @param {number} [options.maxArgLength] - Maximum argument string length
  * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
  * @param {boolean} [options.relative] - Pass relative filepaths to tasks
- * @param {boolean} [options.shell] - Skip parsing of tasks for better shell support
+ * @param {boolean|string} [options.shell] - Skip parsing of tasks for better shell support
  * @param {boolean} [options.stash] - Enable the backup stash, and revert in case of errors
  * @param {boolean} [options.verbose] - Show task output even when tasks succeed; by default only failed output is shown
  * @param {Logger} [logger]
  *
  * @returns {Promise<boolean>} Promise of whether the linting passed or failed
  */
-module.exports = async function lintStaged(
+const lintStaged = async (
   {
     allowEmpty = false,
     concurrent = true,
@@ -79,92 +81,80 @@ module.exports = async function lintStaged(
     verbose = false,
   } = {},
   logger = console
-) {
-  try {
-    debugLog('Loading config using `cosmiconfig`')
-
-    const resolved = configObject
-      ? { config: configObject, filepath: '(input)' }
-      : await loadConfig(configPath)
-    if (resolved == null) throw errConfigNotFound
-
-    debugLog('Successfully loaded config from `%s`:\n%O', resolved.filepath, resolved.config)
-    // resolved.config is the parsed configuration object
-    // resolved.filepath is the path to the config file that was found
-    const formattedConfig = formatConfig(resolved.config)
-    const config = validateConfig(formattedConfig)
-    if (debug) {
-      // Log using logger to be able to test through `consolemock`.
-      logger.log('Running lint-staged with the following config:')
-      logger.log(stringifyObject(config, { indent: '  ' }))
-    } else {
-      // We might not be in debug mode but `DEBUG=lint-staged*` could have
-      // been set.
-      debugLog('lint-staged config:\n%O', config)
-    }
+) => {
+  await validateOptions({ shell }, logger)
 
-    // Unset GIT_LITERAL_PATHSPECS to not mess with path interpretation
-    debugLog('Unset GIT_LITERAL_PATHSPECS (was `%s`)', process.env.GIT_LITERAL_PATHSPECS)
-    delete process.env.GIT_LITERAL_PATHSPECS
-
-    try {
-      const ctx = await runAll(
-        {
-          allowEmpty,
-          concurrent,
-          config,
-          cwd,
-          debug,
-          maxArgLength,
-          quiet,
-          relative,
-          shell,
-          stash,
-          verbose,
-        },
-        logger
-      )
-      debugLog('Tasks were executed successfully!')
-      printTaskOutput(ctx, logger)
-      return true
-    } catch (runAllError) {
-      if (runAllError && runAllError.ctx && runAllError.ctx.errors) {
-        const { ctx } = runAllError
-        if (ctx.errors.has(ApplyEmptyCommitError)) {
-          logger.warn(PREVENTED_EMPTY_COMMIT)
-        } else if (ctx.errors.has(GitError) && !ctx.errors.has(GetBackupStashError)) {
-          logger.error(GIT_ERROR)
-          if (ctx.shouldBackup) {
-            // No sense to show this if the backup stash itself is missing.
-            logger.error(RESTORE_STASH_EXAMPLE)
-          }
-        }
+  debugLog('Loading config using `cosmiconfig`')
+
+  const resolved = configObject
+    ? { config: configObject, filepath: '(input)' }
+    : await loadConfig(configPath)
+
+  if (resolved == null) {
+    logger.error(`${ConfigNotFoundError.message}.`)
+    throw ConfigNotFoundError
+  }
+
+  debugLog('Successfully loaded config from `%s`:\n%O', resolved.filepath, resolved.config)
+
+  // resolved.config is the parsed configuration object
+  // resolved.filepath is the path to the config file that was found
+  const config = validateConfig(resolved.config, logger)
 
-        printTaskOutput(ctx, logger)
-        return false
+  if (debug) {
+    // Log using logger to be able to test through `consolemock`.
+    logger.log('Running lint-staged with the following config:')
+    logger.log(stringifyObject(config, { indent: '  ' }))
+  } else {
+    // We might not be in debug mode but `DEBUG=lint-staged*` could have
+    // been set.
+    debugLog('lint-staged config:\n%O', config)
+  }
+
+  // Unset GIT_LITERAL_PATHSPECS to not mess with path interpretation
+  debugLog('Unset GIT_LITERAL_PATHSPECS (was `%s`)', process.env.GIT_LITERAL_PATHSPECS)
+  delete process.env.GIT_LITERAL_PATHSPECS
+
+  try {
+    const ctx = await runAll(
+      {
+        allowEmpty,
+        concurrent,
+        config,
+        cwd,
+        debug,
+        maxArgLength,
+        quiet,
+        relative,
+        shell,
+        stash,
+        verbose,
+      },
+      logger
+    )
+    debugLog('Tasks were executed successfully!')
+    printTaskOutput(ctx, logger)
+    return true
+  } catch (runAllError) {
+    if (runAllError && runAllError.ctx && runAllError.ctx.errors) {
+      const { ctx } = runAllError
+      if (ctx.errors.has(ApplyEmptyCommitError)) {
+        logger.warn(PREVENTED_EMPTY_COMMIT)
+      } else if (ctx.errors.has(GitError) && !ctx.errors.has(GetBackupStashError)) {
+        logger.error(GIT_ERROR)
+        if (ctx.shouldBackup) {
+          // No sense to show this if the backup stash itself is missing.
+          logger.error(RESTORE_STASH_EXAMPLE)
+        }
       }
 
-      // Probably a compilation error in the config js file. Pass it up to the outer error handler for logging.
-      throw runAllError
-    }
-  } catch (lintStagedError) {
-    if (lintStagedError === errConfigNotFound) {
-      logger.error(`${lintStagedError.message}.`)
-    } else {
-      // It was probably a parsing error
-      logger.error(dedent`
-        Could not parse lint-staged config.
-
-        ${lintStagedError}
-      `)
+      printTaskOutput(ctx, logger)
+      return false
     }
-    logger.error() // empty line
-    // Print helpful message for all errors
-    logger.error(dedent`
-      Please make sure you have created it correctly.
-      See https://github.com/okonet/lint-staged#configuration.
-    `)
-
-    throw lintStagedError
+
+    // Probably a compilation error in the config js file. Pass it up to the outer error handler for logging.
+    throw runAllError
   }
 }
+
+module.exports = lintStaged

package/lib/makeCmdTasks.js

@@ -3,8 +3,8 @@
 const cliTruncate = require('cli-truncate')
 const debug = require('debug')('lint-staged:make-cmd-tasks')
 
+const { configurationError } = require('./messages')
 const resolveTaskFn = require('./resolveTaskFn')
-const { createError } = require('./validateConfig')
 
 const STDOUT_COLUMNS_DEFAULT = 80
 
@@ -51,7 +51,7 @@ const makeCmdTasks = async ({ commands, files, gitDir, renderer, shell, verbose
       // Do the validation here instead of `validateConfig` to skip evaluating the function multiple times
       if (isFn && typeof command !== 'string') {
         throw new Error(
-          createError(
+          configurationError(
             '[Function]',
             'Function task should return a string or an array of strings',
             resolved

package/lib/messages.js

@@ -2,11 +2,26 @@
 
 const chalk = require('chalk')
 const { error, info, warning } = require('log-symbols')
+const format = require('stringify-object')
+
+const configurationError = (opt, helpMsg, value) =>
+  `${chalk.redBright(`${error} Validation Error:`)}
+
+  Invalid value for '${chalk.bold(opt)}': ${chalk.bold(
+    format(value, { inlineCharacterLimit: Number.POSITIVE_INFINITY })
+  )}
+
+  ${helpMsg}`
 
 const NOT_GIT_REPO = chalk.redBright(`${error} Current directory is not a git directory!`)
 
 const FAILED_GET_STAGED_FILES = chalk.redBright(`${error} Failed to get staged files!`)
 
+const incorrectBraces = (before, after) => `${warning} ${chalk.yellow(
+  `Detected incorrect braces with only single value: \`${before}\`. Reformatted as: \`${after}\``
+)}
+`
+
 const NO_STAGED_FILES = `${info} No staged files found.`
 
 const NO_TASKS = `${info} No staged files match any configured task.`
@@ -27,6 +42,14 @@ const SKIPPED_GIT_ERROR = 'Skipped because of previous git error.'
 
 const GIT_ERROR = `\n  ${error} ${chalk.red(`lint-staged failed due to a git error.`)}`
 
+const invalidOption = (name, value, message) => `${chalk.redBright(`${error} Validation Error:`)}
+
+  Invalid value for option '${chalk.bold(name)}': ${chalk.bold(value)}
+
+  ${message}
+
+See https://github.com/okonet/lint-staged#command-line-flags`
+
 const PREVENTED_EMPTY_COMMIT = `
   ${warning} ${chalk.yellow(`lint-staged prevented an empty git commit.
   Use the --allow-empty option to continue, or check your task configuration`)}
@@ -42,16 +65,19 @@ const RESTORE_STASH_EXAMPLE = `  Any lost modifications can be restored from a g
 const CONFIG_STDIN_ERROR = 'Error: Could not read config from stdin.'
 
 module.exports = {
-  NOT_GIT_REPO,
+  CONFIG_STDIN_ERROR,
+  configurationError,
+  DEPRECATED_GIT_ADD,
   FAILED_GET_STAGED_FILES,
+  GIT_ERROR,
+  incorrectBraces,
+  invalidOption,
   NO_STAGED_FILES,
   NO_TASKS,
-  skippingBackup,
-  DEPRECATED_GIT_ADD,
-  TASK_ERROR,
-  SKIPPED_GIT_ERROR,
-  GIT_ERROR,
+  NOT_GIT_REPO,
   PREVENTED_EMPTY_COMMIT,
   RESTORE_STASH_EXAMPLE,
-  CONFIG_STDIN_ERROR,
+  SKIPPED_GIT_ERROR,
+  skippingBackup,
+  TASK_ERROR,
 }

package/lib/runAll.js

@@ -147,7 +147,8 @@ const runAll = async (
         matchedFiles.add(file)
       })
 
-      hasDeprecatedGitAdd = subTasks.some((subTask) => subTask.command === 'git add')
+      hasDeprecatedGitAdd =
+        hasDeprecatedGitAdd || subTasks.some((subTask) => subTask.command === 'git add')
 
       chunkListrTasks.push({
         title: `Running tasks for ${task.pattern}`,

package/lib/symbols.js

@@ -1,11 +1,13 @@
 'use strict'
 
 const ApplyEmptyCommitError = Symbol('ApplyEmptyCommitError')
+const ConfigNotFoundError = new Error('Config could not be found')
 const GetBackupStashError = Symbol('GetBackupStashError')
 const GetStagedFilesError = Symbol('GetStagedFilesError')
 const GitError = Symbol('GitError')
 const GitRepoError = Symbol('GitRepoError')
 const HideUnstagedChangesError = Symbol('HideUnstagedChangesError')
+const InvalidOptionsError = new Error('Invalid Options')
 const RestoreMergeStatusError = Symbol('RestoreMergeStatusError')
 const RestoreOriginalStateError = Symbol('RestoreOriginalStateError')
 const RestoreUnstagedChangesError = Symbol('RestoreUnstagedChangesError')
@@ -13,10 +15,12 @@ const TaskError = Symbol('TaskError')
 
 module.exports = {
   ApplyEmptyCommitError,
+  ConfigNotFoundError,
   GetBackupStashError,
   GetStagedFilesError,
   GitError,
   GitRepoError,
+  InvalidOptionsError,
   HideUnstagedChangesError,
   RestoreMergeStatusError,
   RestoreOriginalStateError,

package/lib/validateBraces.js

@@ -0,0 +1,71 @@
+const { incorrectBraces } = require('./messages')
+
+/**
+ * A correctly-formed brace expansion must contain unquoted opening and closing braces,
+ * and at least one unquoted comma or a valid sequence expression.
+ * Any incorrectly formed brace expansion is left unchanged.
+ *
+ * @see https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html
+ *
+ * Lint-staged uses `micromatch` for brace expansion, and its behavior is to treat
+ * invalid brace expansions as literal strings, which means they (typically) do not match
+ * anything.
+ *
+ * This RegExp tries to match most cases of invalid brace expansions, so that they can be
+ * detected, warned about, and re-formatted by removing the braces and thus hopefully
+ * matching the files as intended by the user. The only real fix is to remove the incorrect
+ * braces from user configuration, but this is left to the user (after seeing the warning).
+ *
+ * @example <caption>Globs with brace expansions</caption>
+ * - *.{js,tx}         // expanded as *.js, *.ts
+ * - *.{{j,t}s,css}    // expanded as *.js, *.ts, *.css
+ * - file_{1..10}.css  // expanded as file_1.css, file_2.css, …, file_10.css
+ *
+ * @example <caption>Globs with incorrect brace expansions</caption>
+ * - *.{js}       // should just be *.js
+ * - *.{js,{ts}}  // should just be *.{js,ts}
+ * - *.\{js\}     // escaped braces, so they're treated literally
+ * - *.${js}      // dollar-sign inhibits expansion, so treated literally
+ * - *.{js\,ts}   // the comma is escaped, so treated literally
+ */
+const BRACES_REGEXP = /(?<![\\$])({)(?:(?!(?<!\\),|\.\.|\{|\}).)*?(?<!\\)(})/g
+
+/**
+ * @param {string} pattern
+ * @returns {string}
+ */
+const withoutIncorrectBraces = (pattern) => {
+  let output = `${pattern}`
+  let match = null
+
+  while ((match = BRACES_REGEXP.exec(pattern))) {
+    const fullMatch = match[0]
+    const withoutBraces = fullMatch.replace(/{/, '').replace(/}/, '')
+    output = output.replace(fullMatch, withoutBraces)
+  }
+
+  return output
+}
+
+/**
+ * Validate and remove incorrect brace expansions from glob pattern.
+ * For example `*.{js}` is incorrect because it doesn't contain a `,` or `..`,
+ * and will be reformatted as `*.js`.
+ *
+ * @param {string} pattern the glob pattern
+ * @param {*} logger
+ * @returns {string}
+ */
+const validateBraces = (pattern, logger) => {
+  const fixedPattern = withoutIncorrectBraces(pattern)
+
+  if (fixedPattern !== pattern) {
+    logger.warn(incorrectBraces(pattern, fixedPattern))
+  }
+
+  return fixedPattern
+}
+
+module.exports = validateBraces
+
+module.exports.BRACES_REGEXP = BRACES_REGEXP

package/lib/validateConfig.js

@@ -2,11 +2,11 @@
 
 'use strict'
 
-const chalk = require('chalk')
-const format = require('stringify-object')
-
 const debug = require('debug')('lint-staged:cfg')
 
+const { configurationError } = require('./messages')
+const validateBraces = require('./validateBraces')
+
 const TEST_DEPRECATED_KEYS = new Map([
   ['concurrent', (key) => typeof key === 'boolean'],
   ['chunkSize', (key) => typeof key === 'number'],
@@ -18,76 +18,91 @@ const TEST_DEPRECATED_KEYS = new Map([
   ['relative', (key) => typeof key === 'boolean'],
 ])
 
-const formatError = (helpMsg) => `● Validation Error:
-
-  ${helpMsg}
-
-Please refer to https://github.com/okonet/lint-staged#configuration for more information...`
-
-const createError = (opt, helpMsg, value) =>
-  formatError(`Invalid value for '${chalk.bold(opt)}'.
-
-  ${helpMsg}.
- 
-  Configured value is: ${chalk.bold(
-    format(value, { inlineCharacterLimit: Number.POSITIVE_INFINITY })
-  )}`)
-
 /**
  * Runs config validation. Throws error if the config is not valid.
  * @param config {Object}
  * @returns config {Object}
  */
-module.exports = function validateConfig(config) {
+const validateConfig = (config, logger) => {
   debug('Validating config')
 
-  const errors = []
+  if (!config || (typeof config !== 'object' && typeof config !== 'function')) {
+    throw new Error('Configuration should be an object or a function!')
+  }
 
-  if (!config || typeof config !== 'object') {
-    errors.push('Configuration should be an object!')
-  } else {
-    const entries = Object.entries(config)
+  /**
+   * Function configurations receive all staged files as their argument.
+   * They are not further validated here to make sure the function gets
+   * evaluated only once.
+   *
+   * @see makeCmdTasks
+   */
+  if (typeof config === 'function') {
+    return { '*': config }
+  }
 
-    if (entries.length === 0) {
-      errors.push('Configuration should not be empty!')
-    }
+  if (Object.entries(config).length === 0) {
+    throw new Error('Configuration should not be empty!')
+  }
 
-    entries.forEach(([pattern, task]) => {
-      if (TEST_DEPRECATED_KEYS.has(pattern)) {
-        const testFn = TEST_DEPRECATED_KEYS.get(pattern)
-        if (testFn(task)) {
-          errors.push(
-            createError(
-              pattern,
-              'Advanced configuration has been deprecated. For more info, please visit: https://github.com/okonet/lint-staged',
-              task
-            )
-          )
-        }
-      }
+  const errors = []
 
-      if (
-        (!Array.isArray(task) ||
-          task.some((item) => typeof item !== 'string' && typeof item !== 'function')) &&
-        typeof task !== 'string' &&
-        typeof task !== 'function'
-      ) {
+  /**
+   * Create a new validated config because the keys (patterns) might change.
+   * Since the Object.reduce method already loops through each entry in the config,
+   * it can be used for validating the values at the same time.
+   */
+  const validatedConfig = Object.entries(config).reduce((collection, [pattern, task]) => {
+    /** Versions < 9 had more complex configuration options that are no longer supported. */
+    if (TEST_DEPRECATED_KEYS.has(pattern)) {
+      const testFn = TEST_DEPRECATED_KEYS.get(pattern)
+      if (testFn(task)) {
         errors.push(
-          createError(
-            pattern,
-            'Should be a string, a function, or an array of strings and functions',
-            task
-          )
+          configurationError(pattern, 'Advanced configuration has been deprecated.', task)
         )
       }
-    })
-  }
+
+      /** Return early for deprecated keys to skip validating their (deprecated) values */
+      return collection
+    }
+
+    if (
+      (!Array.isArray(task) ||
+        task.some((item) => typeof item !== 'string' && typeof item !== 'function')) &&
+      typeof task !== 'string' &&
+      typeof task !== 'function'
+    ) {
+      errors.push(
+        configurationError(
+          pattern,
+          'Should be a string, a function, or an array of strings and functions.',
+          task
+        )
+      )
+    }
+
+    /**
+     * A typical configuration error is using invalid brace expansion, like `*.{js}`.
+     * These are automatically fixed and warned about.
+     */
+    const fixedPattern = validateBraces(pattern, logger)
+
+    return { ...collection, [fixedPattern]: task }
+  }, {})
 
   if (errors.length) {
-    throw new Error(errors.join('\n'))
+    const message = errors.join('\n\n')
+
+    logger.error(`Could not parse lint-staged config.
+
+${message}
+
+See https://github.com/okonet/lint-staged#configuration.`)
+
+    throw new Error(message)
   }
 
-  return config
+  return validatedConfig
 }
 
-module.exports.createError = createError
+module.exports = validateConfig

package/lib/validateOptions.js

@@ -0,0 +1,31 @@
+const { promises: fs, constants } = require('fs')
+
+const { invalidOption } = require('./messages')
+const { InvalidOptionsError } = require('./symbols')
+
+const debug = require('debug')('lint-staged:options')
+
+/**
+ * Validate lint-staged options, either from the Node.js API or the command line flags.
+ * @param {*} options
+ * @param {boolean|string} [options.shell] - Skip parsing of tasks for better shell support
+ *
+ * @throws {InvalidOptionsError}
+ */
+const validateOptions = async (options = {}, logger) => {
+  debug('Validating options...')
+
+  /** Ensure the passed shell option is executable */
+  if (typeof options.shell === 'string') {
+    try {
+      await fs.access(options.shell, constants.X_OK)
+    } catch (error) {
+      logger.error(invalidOption('shell', options.shell, error.message))
+      throw InvalidOptionsError
+    }
+  }
+
+  debug('Validated options!')
+}
+
+module.exports = validateOptions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-staged",
-  "version": "11.0.0",
+  "version": "11.1.2",
   "description": "Lint files staged by git",
   "license": "MIT",
   "repository": "https://github.com/okonet/lint-staged",
@@ -32,7 +32,6 @@
     "commander": "^7.2.0",
     "cosmiconfig": "^7.0.0",
     "debug": "^4.3.1",
-    "dedent": "^0.7.0",
     "enquirer": "^2.3.6",
     "execa": "^5.0.0",
     "listr2": "^3.8.2",

package/lib/formatConfig.js

@@ -1,7 +0,0 @@
-module.exports = function formatConfig(config) {
-  if (typeof config === 'function') {
-    return { '*': config }
-  }
-
-  return config
-}