lint-staged 12.1.7 → 12.2.0

package/README.md

@@ -2,8 +2,30 @@
 
 Run linters against staged git files and don't let :poop: slip into your code base!
 
+```
+$ git commit
+
+✔ Preparing lint-staged...
+❯ Running tasks for staged files...
+  ❯ packages/frontend/.lintstagedrc.json — 1 file
+    ↓ *.js — no files [SKIPPED]
+    ❯ *.{json,md} — 1 file
+      ⠹ prettier --write
+  ↓ packages/backend/.lintstagedrc.json — 2 files
+    ❯ *.js — 2 files
+      ⠼ eslint --fix
+    ↓ *.{json,md} — no files [SKIPPED]
+◼ Applying modifications from tasks...
+◼ Cleaning up temporary files...
+```
+
+<details>
+<summary>See asciinema video</summary>
+
 [![asciicast](https://asciinema.org/a/199934.svg)](https://asciinema.org/a/199934)
 
+</details>
+
 ## Why
 
 Linting makes more sense when run before committing your code. By doing so you can ensure no errors go into the repository and enforce code style. But running a lint process on a whole project is slow, and linting results can be irrelevant. Ultimately you only want to lint files that will be committed.
@@ -116,6 +138,8 @@ Starting with v3.1 you can now use different ways of configuring lint-staged:
 
 Configuration should be an object where each value is a command to run and its key is a glob pattern to use for this command. This package uses [micromatch](https://github.com/micromatch/micromatch) for glob patterns. JavaScript files can also export advanced configuration as a function. See [Using JS configuration files](#using-js-configuration-files) for more info.
 
+You can also place multiple configuration files in different directories inside a project. For a given staged file, the closest configuration file will always be used. See ["How to use `lint-staged` in a multi-package monorepo?"](#how-to-use-lint-staged-in-a-multi-package-monorepo) for more info and an example.
+
 #### `package.json` example:
 
 ```json
@@ -644,12 +668,32 @@ _Thanks to [this comment](https://youtrack.jetbrains.com/issue/IDEA-135454#comme
 <details>
   <summary>Click to expand</summary>
 
-Starting with v5.0, `lint-staged` automatically resolves the git root **without any** additional configuration. You configure `lint-staged` as you normally would if your project root and git root were the same directory.
+Install _lint-staged_ on the monorepo root level, and add separate configuration files in each package. When running, _lint-staged_ will always use the configuration closest to a staged file, so having separate configuration files makes sure linters do not "leak" into other packages.
+
+For example, in a monorepo with `packages/frontend/.lintstagedrc.json` and `packages/backend/.lintstagedrc.json`, a staged file inside `packages/frontend/` will only match that configuration, and not the one in `packages/backend/`.
+
+**Note**: _lint-staged_ discovers the closest configuration to each staged file, even if that configuration doesn't include any matching globs. Given these example configurations:
 
-If you wish to use `lint-staged` in a multi package monorepo, it is recommended to install [`husky`](https://github.com/typicode/husky) in the root package.json.
-[`lerna`](https://github.com/lerna/lerna) can be used to execute the `precommit` script in all sub-packages.
+```js
+// ./.lintstagedrc.json
+{ "*.md": "prettier --write" }
+```
+
+```js
+// ./packages/frontend/.lintstagedrc.json
+{ "*.js": "eslint --fix" }
+```
+
+When committing `./packages/frontend/README.md`, it **will not run** _prettier_, because the configuration in the `frontend/` directory is closer to the file and doesn't include it. You should treat all _lint-staged_ configuration files as isolated and separated from each other. You can always use JS files to "extend" configurations, for example:
 
-Example repo: [sudo-suhas/lint-staged-multi-pkg](https://github.com/sudo-suhas/lint-staged-multi-pkg).
+```js
+import baseConfig from '../.lintstagedrc.js'
+
+export default {
+  ...baseConfig,
+  '*.js': 'eslint --fix',
+}
+```
 
 </details>
 

package/lib/dynamicImport.js

@@ -0,0 +1,3 @@
+import { pathToFileURL } from 'url'
+
+export const dynamicImport = (path) => import(pathToFileURL(path)).then((module) => module.default)

package/lib/generateTasks.js

@@ -16,11 +16,10 @@ const debugLog = debug('lint-staged:generateTasks')
  * @param {boolean} [options.files] - Staged filepaths
  * @param {boolean} [options.relative] - Whether filepaths to should be relative to gitDir
  */
-export const generateTasks = ({ config, cwd = process.cwd(), gitDir, files, relative = false }) => {
+export const generateTasks = ({ config, cwd = process.cwd(), files, relative = false }) => {
   debugLog('Generating linter tasks')
 
-  const absoluteFiles = files.map((file) => normalize(path.resolve(gitDir, file)))
-  const relativeFiles = absoluteFiles.map((file) => normalize(path.relative(cwd, file)))
+  const relativeFiles = files.map((file) => normalize(path.relative(cwd, file)))
 
   return Object.entries(config).map(([rawPattern, commands]) => {
     let pattern = rawPattern

package/lib/getConfigGroups.js

@@ -0,0 +1,77 @@
+/** @typedef {import('./index').Logger} Logger */
+
+import path from 'path'
+
+import { loadConfig } from './loadConfig.js'
+import { ConfigNotFoundError } from './symbols.js'
+import { validateConfig } from './validateConfig.js'
+
+/**
+ * Return matched files grouped by their configuration.
+ *
+ * @param {object} options
+ * @param {Object} [options.configObject] - Explicit config object from the js API
+ * @param {string} [options.configPath] - Explicit path to a config file
+ * @param {string} [options.cwd] - Current working directory
+ * @param {Logger} logger
+ */
+export const getConfigGroups = async ({ configObject, configPath, files }, logger = console) => {
+  // Return explicit config object from js API
+  if (configObject) {
+    const config = validateConfig(configObject, 'config object', logger)
+    return { '': { config, files } }
+  }
+
+  // Use only explicit config path instead of discovering multiple
+  if (configPath) {
+    const { config, filepath } = await loadConfig({ configPath }, logger)
+
+    if (!config) {
+      logger.error(`${ConfigNotFoundError.message}.`)
+      throw ConfigNotFoundError
+    }
+
+    const validatedConfig = validateConfig(config, filepath, logger)
+    return { [configPath]: { config: validatedConfig, files } }
+  }
+
+  // Group files by their base directory
+  const filesByDir = files.reduce((acc, file) => {
+    const dir = path.normalize(path.dirname(file))
+
+    if (dir in acc) {
+      acc[dir].push(file)
+    } else {
+      acc[dir] = [file]
+    }
+
+    return acc
+  }, {})
+
+  // Group files by their discovered config
+  // { '.lintstagedrc.json': { config: {...}, files: [...] } }
+  const configGroups = {}
+
+  await Promise.all(
+    Object.entries(filesByDir).map(([dir, files]) => {
+      // Discover config from the base directory of the file
+      return loadConfig({ cwd: dir }, logger).then(({ config, filepath }) => {
+        if (!config) {
+          logger.error(`${ConfigNotFoundError.message}.`)
+          throw ConfigNotFoundError
+        }
+
+        if (filepath in configGroups) {
+          // Re-use cached config and skip validation
+          configGroups[filepath].files.push(...files)
+          return
+        }
+
+        const validatedConfig = validateConfig(config, filepath, logger)
+        configGroups[filepath] = { config: validatedConfig, files }
+      })
+    })
+  )
+
+  return configGroups
+}

package/lib/getStagedFiles.js

@@ -1,16 +1,28 @@
+import path from 'path'
+
+import normalize from 'normalize-path'
+
 import { execGit } from './execGit.js'
 
-export const getStagedFiles = async (options) => {
+export const getStagedFiles = async ({ cwd = process.cwd() } = {}) => {
   try {
     // Docs for --diff-filter option: https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---diff-filterACDMRTUXB82308203
     // Docs for -z option: https://git-scm.com/docs/git-diff#Documentation/git-diff.txt--z
-    const lines = await execGit(
-      ['diff', '--staged', '--diff-filter=ACMR', '--name-only', '-z'],
-      options
+    const lines = await execGit(['diff', '--staged', '--diff-filter=ACMR', '--name-only', '-z'], {
+      cwd,
+    })
+
+    if (!lines) return []
+
+    // With `-z`, git prints `fileA\u0000fileB\u0000fileC\u0000` so we need to
+    // remove the last occurrence of `\u0000` before splitting
+    return (
+      lines
+        // eslint-disable-next-line no-control-regex
+        .replace(/\u0000$/, '')
+        .split('\u0000')
+        .map((file) => normalize(path.resolve(cwd, file)))
     )
-    // With `-z`, git prints `fileA\u0000fileB\u0000fileC\u0000` so we need to remove the last occurrence of `\u0000` before splitting
-    // eslint-disable-next-line no-control-regex
-    return lines ? lines.replace(/\u0000$/, '').split('\u0000') : []
   } catch {
     return null
   }

package/lib/index.js

@@ -1,17 +1,9 @@
 import debug from 'debug'
-import inspect from 'object-inspect'
 
-import { loadConfig } from './loadConfig.js'
 import { PREVENTED_EMPTY_COMMIT, GIT_ERROR, RESTORE_STASH_EXAMPLE } from './messages.js'
 import { printTaskOutput } from './printTaskOutput.js'
 import { runAll } from './runAll.js'
-import {
-  ApplyEmptyCommitError,
-  ConfigNotFoundError,
-  GetBackupStashError,
-  GitError,
-} from './symbols.js'
-import { validateConfig } from './validateConfig.js'
+import { ApplyEmptyCommitError, GetBackupStashError, GitError } from './symbols.js'
 import { validateOptions } from './validateOptions.js'
 
 const debugLog = debug('lint-staged')
@@ -58,25 +50,6 @@ const lintStaged = async (
 ) => {
   await validateOptions({ shell }, logger)
 
-  const inputConfig = configObject || (await loadConfig({ configPath, cwd }, logger))
-
-  if (!inputConfig) {
-    logger.error(`${ConfigNotFoundError.message}.`)
-    throw ConfigNotFoundError
-  }
-
-  const config = validateConfig(inputConfig, logger)
-
-  if (debug) {
-    // Log using logger to be able to test through `consolemock`.
-    logger.log('Running lint-staged with the following config:')
-    logger.log(inspect(config, { indent: 2 }))
-  } 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
@@ -86,7 +59,8 @@ const lintStaged = async (
       {
         allowEmpty,
         concurrent,
-        config,
+        configObject,
+        configPath,
         cwd,
         debug,
         maxArgLength,

package/lib/loadConfig.js

@@ -1,11 +1,10 @@
 /** @typedef {import('./index').Logger} Logger */
 
-import { pathToFileURL } from 'url'
-
 import debug from 'debug'
 import { lilconfig } from 'lilconfig'
 import YAML from 'yaml'
 
+import { dynamicImport } from './dynamicImport.js'
 import { resolveConfig } from './resolveConfig.js'
 
 const debugLog = debug('lint-staged:loadConfig')
@@ -28,9 +27,6 @@ const searchPlaces = [
   'lint-staged.config.cjs',
 ]
 
-/** exported for tests */
-export const dynamicImport = (path) => import(pathToFileURL(path)).then((module) => module.default)
-
 const jsonParse = (path, content) => JSON.parse(content)
 
 const yamlParse = (path, content) => YAML.parse(content)
@@ -51,6 +47,8 @@ const loaders = {
   noExt: yamlParse,
 }
 
+const explorer = lilconfig('lint-staged', { searchPlaces, loaders })
+
 /**
  * @param {object} options
  * @param {string} [options.configPath] - Explicit path to a config file
@@ -64,22 +62,22 @@ export const loadConfig = async ({ configPath, cwd }, logger) => {
       debugLog('Searching for configuration from `%s`...', cwd)
     }
 
-    const explorer = lilconfig('lint-staged', { searchPlaces, loaders })
-
     const result = await (configPath
       ? explorer.load(resolveConfig(configPath))
       : explorer.search(cwd))
-    if (!result) return null
+
+    if (!result) return {}
 
     // config is a promise when using the `dynamicImport` loader
     const config = await result.config
+    const filepath = result.filepath
 
-    debugLog('Successfully loaded config from `%s`:\n%O', result.filepath, config)
+    debugLog('Successfully loaded config from `%s`:\n%O', filepath, config)
 
-    return config
+    return { config, filepath }
   } catch (error) {
     debugLog('Failed to load configuration!')
     logger.error(error)
-    return null
+    return {}
   }
 }

package/lib/runAll.js

@@ -1,11 +1,16 @@
 /** @typedef {import('./index').Logger} Logger */
 
+import path from 'path'
+
+import { dim } from 'colorette'
 import debug from 'debug'
 import { Listr } from 'listr2'
+import normalize from 'normalize-path'
 
 import { chunkFiles } from './chunkFiles.js'
 import { execGit } from './execGit.js'
 import { generateTasks } from './generateTasks.js'
+import { getConfigGroups } from './getConfigGroups.js'
 import { getRenderer } from './getRenderer.js'
 import { getStagedFiles } from './getStagedFiles.js'
 import { GitWorkflow } from './gitWorkflow.js'
@@ -40,10 +45,11 @@ const createError = (ctx) => Object.assign(new Error('lint-staged failed'), { ct
  * Executes all tasks and either resolves or rejects the promise
  *
  * @param {object} options
- * @param {Object} [options.allowEmpty] - Allow empty commits when tasks revert all staged changes
+ * @param {boolean} [options.allowEmpty] - Allow empty commits when tasks revert all staged changes
  * @param {boolean | number} [options.concurrent] - The number of tasks to run concurrently, or false to run tasks serially
- * @param {Object} [options.config] - Task configuration
- * @param {Object} [options.cwd] - Current working directory
+ * @param {Object} [options.configObject] - Explicit config object from the js API
+ * @param {string} [options.configPath] - Explicit path to a config file
+ * @param {string} [options.cwd] - Current working directory
  * @param {boolean} [options.debug] - Enable debug mode
  * @param {number} [options.maxArgLength] - Maximum argument string length
  * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
@@ -58,7 +64,8 @@ export const runAll = async (
   {
     allowEmpty = false,
     concurrent = true,
-    config,
+    configObject,
+    configPath,
     cwd = process.cwd(),
     debug = false,
     maxArgLength,
@@ -107,9 +114,7 @@ export const runAll = async (
     return ctx
   }
 
-  const stagedFileChunks = chunkFiles({ baseDir: gitDir, files, maxArgLength, relative })
-  const chunkCount = stagedFileChunks.length
-  if (chunkCount > 1) debugLog(`Chunked staged files into ${chunkCount} part`, chunkCount)
+  const configGroups = await getConfigGroups({ configObject, configPath, files }, logger)
 
   // lint-staged 10 will automatically add modifications to index
   // Warn user when their command includes `git add`
@@ -128,62 +133,76 @@ export const runAll = async (
   // Set of all staged files that matched a task glob. Values in a set are unique.
   const matchedFiles = new Set()
 
-  for (const [index, files] of stagedFileChunks.entries()) {
-    const chunkTasks = generateTasks({ config, cwd, gitDir, files, relative })
-    const chunkListrTasks = []
-
-    for (const task of chunkTasks) {
-      const subTasks = await makeCmdTasks({
-        commands: task.commands,
-        cwd,
-        files: task.fileList,
-        gitDir,
-        renderer: listrOptions.renderer,
-        shell,
-        verbose,
-      })
+  for (const [configPath, { config, files }] of Object.entries(configGroups)) {
+    const stagedFileChunks = chunkFiles({ baseDir: gitDir, files, maxArgLength, relative })
 
-      // Add files from task to match set
-      task.fileList.forEach((file) => {
-        matchedFiles.add(file)
-      })
+    const chunkCount = stagedFileChunks.length
+    if (chunkCount > 1) {
+      debugLog('Chunked staged files from `%s` into %d part', configPath, chunkCount)
+    }
+
+    for (const [index, files] of stagedFileChunks.entries()) {
+      const relativeConfig = normalize(path.relative(cwd, configPath))
+
+      const chunkListrTasks = await Promise.all(
+        generateTasks({ config, cwd, files, relative }).map((task) =>
+          makeCmdTasks({
+            commands: task.commands,
+            cwd,
+            files: task.fileList,
+            gitDir,
+            renderer: listrOptions.renderer,
+            shell,
+            verbose,
+          }).then((subTasks) => {
+            // Add files from task to match set
+            task.fileList.forEach((file) => {
+              matchedFiles.add(file)
+            })
+
+            hasDeprecatedGitAdd =
+              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}`,
-        task: async () =>
-          new Listr(subTasks, {
-            // In sub-tasks we don't want to run concurrently
-            // and we want to abort on errors
-            ...listrOptions,
-            concurrent: false,
-            exitOnError: true,
-          }),
+            const fileCount = task.fileList.length
+
+            return {
+              title: `${task.pattern}${dim(` — ${fileCount} ${fileCount > 1 ? 'files' : 'file'}`)}`,
+              task: async () =>
+                new Listr(subTasks, {
+                  // In sub-tasks we don't want to run concurrently
+                  // and we want to abort on errors
+                  ...listrOptions,
+                  concurrent: false,
+                  exitOnError: true,
+                }),
+              skip: () => {
+                // Skip task when no files matched
+                if (fileCount === 0) {
+                  return `${task.pattern}${dim(' — no files')}`
+                }
+                return false
+              },
+            }
+          })
+        )
+      )
+
+      listrTasks.push({
+        title:
+          `${relativeConfig}${dim(` — ${files.length} ${files.length > 1 ? 'files' : 'file'}`)}` +
+          (chunkCount > 1 ? dim(` (chunk ${index + 1}/${chunkCount})...`) : ''),
+        task: () => new Listr(chunkListrTasks, { ...listrOptions, concurrent, exitOnError: true }),
         skip: () => {
-          // Skip task when no files matched
-          if (task.fileList.length === 0) {
-            return `No staged files match ${task.pattern}`
+          // Skip if the first step (backup) failed
+          if (ctx.errors.has(GitError)) return SKIPPED_GIT_ERROR
+          // Skip chunk when no every task is skipped (due to no matches)
+          if (chunkListrTasks.every((task) => task.skip())) {
+            return `${relativeConfig}${dim(' — no tasks to run')}`
           }
           return false
         },
       })
     }
-
-    listrTasks.push({
-      // No need to show number of task chunks when there's only one
-      title:
-        chunkCount > 1 ? `Running tasks (chunk ${index + 1}/${chunkCount})...` : 'Running tasks...',
-      task: () => new Listr(chunkListrTasks, { ...listrOptions, concurrent }),
-      skip: () => {
-        // Skip if the first step (backup) failed
-        if (ctx.errors.has(GitError)) return SKIPPED_GIT_ERROR
-        // Skip chunk when no every task is skipped (due to no matches)
-        if (chunkListrTasks.every((task) => task.skip())) return 'No tasks to run.'
-        return false
-      },
-    })
   }
 
   if (hasDeprecatedGitAdd) {
@@ -211,7 +230,7 @@ export const runAll = async (
   const runner = new Listr(
     [
       {
-        title: 'Preparing...',
+        title: 'Preparing lint-staged...',
         task: (ctx) => git.prepare(ctx),
       },
       {
@@ -219,9 +238,13 @@ export const runAll = async (
         task: (ctx) => git.hideUnstagedChanges(ctx),
         enabled: hasPartiallyStagedFiles,
       },
-      ...listrTasks,
       {
-        title: 'Applying modifications...',
+        title: `Running tasks for staged files...`,
+        task: () => new Listr(listrTasks, { ...listrOptions, concurrent }),
+        skip: () => listrTasks.every((task) => task.skip()),
+      },
+      {
+        title: 'Applying modifications from tasks...',
         task: (ctx) => git.applyModifications(ctx),
         skip: applyModificationsSkipped,
       },
@@ -238,7 +261,7 @@ export const runAll = async (
         skip: restoreOriginalStateSkipped,
       },
       {
-        title: 'Cleaning up...',
+        title: 'Cleaning up temporary files...',
         task: (ctx) => git.cleanup(ctx),
         enabled: cleanupEnabled,
         skip: cleanupSkipped,

package/lib/validateConfig.js

@@ -1,4 +1,7 @@
+/** @typedef {import('./index').Logger} Logger */
+
 import debug from 'debug'
+import inspect from 'object-inspect'
 
 import { configurationError } from './messages.js'
 import { ConfigEmptyError, ConfigFormatError } from './symbols.js'
@@ -21,11 +24,13 @@ const TEST_DEPRECATED_KEYS = new Map([
 
 /**
  * Runs config validation. Throws error if the config is not valid.
- * @param config {Object}
- * @returns config {Object}
+ * @param {Object} config
+ * @param {string} configPath
+ * @param {Logger} logger
+ * @returns {Object} config
  */
-export const validateConfig = (config, logger) => {
-  debugLog('Validating config')
+export const validateConfig = (config, configPath, logger) => {
+  debugLog('Validating config from `%s`...', configPath)
 
   if (!config || (typeof config !== 'object' && typeof config !== 'function')) {
     throw ConfigFormatError
@@ -103,5 +108,8 @@ See https://github.com/okonet/lint-staged#configuration.`)
     throw new Error(message)
   }
 
+  debugLog('Validated config from `%s`:', configPath)
+  debugLog(inspect(config, { indent: 2 }))
+
   return validatedConfig
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-staged",
-  "version": "12.1.7",
+  "version": "12.2.0",
   "description": "Lint files staged by git",
   "license": "MIT",
   "repository": "https://github.com/okonet/lint-staged",