lint-staged 12.3.7 → 12.4.1

package/bin/lint-staged.js

@@ -34,6 +34,7 @@ cmdline
   .option('-c, --config [path]', 'path to configuration file, or - to read from stdin')
   .option('--cwd [path]', 'run all tasks in specific directory, instead of the current')
   .option('-d, --debug', 'print additional debug information', false)
+  .option('--max-arg-length', 'maximum length of the command-line argument string')
   .option('--no-stash', 'disable the backup stash, and do not revert in case of errors', false)
   .option('-q, --quiet', 'disable lint-staged’s own console output', false)
   .option('-r, --relative', 'pass relative filepaths to tasks', false)
@@ -54,31 +55,13 @@ if (cmdlineOptions.debug) {
 const debugLog = debug('lint-staged:bin')
 debugLog('Running `lint-staged@%s`', version)
 
-/**
- * Get the maximum length of a command-line argument string based on current platform
- *
- * https://serverfault.com/questions/69430/what-is-the-maximum-length-of-a-command-line-in-mac-os-x
- * https://support.microsoft.com/en-us/help/830473/command-prompt-cmd-exe-command-line-string-limitation
- * https://unix.stackexchange.com/a/120652
- */
-const getMaxArgLength = () => {
-  switch (process.platform) {
-    case 'darwin':
-      return 262144
-    case 'win32':
-      return 8191
-    default:
-      return 131072
-  }
-}
-
 const options = {
   allowEmpty: !!cmdlineOptions.allowEmpty,
   concurrent: JSON.parse(cmdlineOptions.concurrent),
   configPath: cmdlineOptions.config,
   cwd: cmdlineOptions.cwd,
   debug: !!cmdlineOptions.debug,
-  maxArgLength: getMaxArgLength() / 2,
+  maxArgLength: JSON.parse(cmdlineOptions.maxArgLength || null),
   quiet: !!cmdlineOptions.quiet,
   relative: !!cmdlineOptions.relative,
   shell: cmdlineOptions.shell /* Either a boolean or a string pointing to the shell */,

package/lib/generateTasks.js

@@ -21,9 +21,7 @@ export const generateTasks = ({ config, cwd = process.cwd(), files, relative = f
 
   const relativeFiles = files.map((file) => normalize(path.relative(cwd, file)))
 
-  return Object.entries(config).map(([rawPattern, commands]) => {
-    let pattern = rawPattern
-
+  return Object.entries(config).map(([pattern, commands]) => {
     const isParentDirPattern = pattern.startsWith('../')
 
     // Only worry about children of the CWD unless the pattern explicitly
@@ -40,6 +38,7 @@ export const generateTasks = ({ config, cwd = process.cwd(), files, relative = f
       // match against filenames in every directory. This makes `*.js`
       // match both `test.js` and `subdirectory/test.js`.
       matchBase: !pattern.includes('/'),
+      posixSlashes: true,
       strictBrackets: true,
     })
 

package/lib/groupFilesByConfig.js

@@ -0,0 +1,59 @@
+import path from 'path'
+
+import debug from 'debug'
+
+import { ConfigObjectSymbol } from './searchConfigs.js'
+
+const debugLog = debug('lint-staged:groupFilesByConfig')
+
+export const groupFilesByConfig = async ({ configs, files }) => {
+  debugLog('Grouping %d files by %d configurations', files.length, Object.keys(configs).length)
+
+  const filesSet = new Set(files)
+  const filesByConfig = {}
+
+  /** Configs are sorted deepest first by `searchConfigs` */
+  for (const filepath of Reflect.ownKeys(configs)) {
+    const config = configs[filepath]
+
+    /** When passed an explicit config object via the Node.js API, skip logic */
+    if (filepath === ConfigObjectSymbol) {
+      filesByConfig[filepath] = { config, files }
+      break
+    }
+
+    const dir = path.normalize(path.dirname(filepath))
+
+    /** Check if file is inside directory of the configuration file */
+    const isInsideDir = (file) => {
+      const relative = path.relative(dir, file)
+      return relative && !relative.startsWith('..') && !path.isAbsolute(relative)
+    }
+
+    /** This config should match all files since it has a parent glob */
+    const includeAllFiles = Object.keys(config).some((glob) => glob.startsWith('..'))
+
+    const scopedFiles = new Set(includeAllFiles ? filesSet : undefined)
+
+    /**
+     * Without a parent glob, if file is inside the config file's directory,
+     * assign it to that configuration.
+     */
+    if (!includeAllFiles) {
+      filesSet.forEach((file) => {
+        if (isInsideDir(file)) {
+          scopedFiles.add(file)
+        }
+      })
+    }
+
+    /** Files should only match a single config */
+    scopedFiles.forEach((file) => {
+      filesSet.delete(file)
+    })
+
+    filesByConfig[filepath] = { config, files: Array.from(scopedFiles) }
+  }
+
+  return filesByConfig
+}

package/lib/index.js

@@ -1,13 +1,41 @@
 import debug from 'debug'
 
-import { PREVENTED_EMPTY_COMMIT, GIT_ERROR, RESTORE_STASH_EXAMPLE } from './messages.js'
+import {
+  PREVENTED_EMPTY_COMMIT,
+  GIT_ERROR,
+  RESTORE_STASH_EXAMPLE,
+  NO_CONFIGURATION,
+} from './messages.js'
 import { printTaskOutput } from './printTaskOutput.js'
 import { runAll } from './runAll.js'
-import { ApplyEmptyCommitError, GetBackupStashError, GitError } from './symbols.js'
+import {
+  ApplyEmptyCommitError,
+  ConfigNotFoundError,
+  GetBackupStashError,
+  GitError,
+} from './symbols.js'
 import { validateOptions } from './validateOptions.js'
 
 const debugLog = debug('lint-staged')
 
+/**
+ * Get the maximum length of a command-line argument string based on current platform
+ *
+ * https://serverfault.com/questions/69430/what-is-the-maximum-length-of-a-command-line-in-mac-os-x
+ * https://support.microsoft.com/en-us/help/830473/command-prompt-cmd-exe-command-line-string-limitation
+ * https://unix.stackexchange.com/a/120652
+ */
+const getMaxArgLength = () => {
+  switch (process.platform) {
+    case 'darwin':
+      return 262144
+    case 'win32':
+      return 8191
+    default:
+      return 131072
+  }
+}
+
 /**
  * @typedef {(...any) => void} LogFunction
  * @typedef {{ error: LogFunction, log: LogFunction, warn: LogFunction }} Logger
@@ -39,7 +67,7 @@ const lintStaged = async (
     configPath,
     cwd,
     debug = false,
-    maxArgLength,
+    maxArgLength = getMaxArgLength() / 2,
     quiet = false,
     relative = false,
     shell = false,
@@ -78,7 +106,10 @@ const lintStaged = async (
   } catch (runAllError) {
     if (runAllError && runAllError.ctx && runAllError.ctx.errors) {
       const { ctx } = runAllError
-      if (ctx.errors.has(ApplyEmptyCommitError)) {
+
+      if (ctx.errors.has(ConfigNotFoundError)) {
+        logger.error(NO_CONFIGURATION)
+      } else if (ctx.errors.has(ApplyEmptyCommitError)) {
         logger.warn(PREVENTED_EMPTY_COMMIT)
       } else if (ctx.errors.has(GitError) && !ctx.errors.has(GetBackupStashError)) {
         logger.error(GIT_ERROR)

package/lib/messages.js

@@ -22,6 +22,8 @@ export const incorrectBraces = (before, after) =>
 `
   )
 
+export const NO_CONFIGURATION = `${error} No valid configuration found.`
+
 export const NO_STAGED_FILES = `${info} No staged files found.`
 
 export const NO_TASKS = `${info} No staged files match any configured task.`

package/lib/parseGitZOutput.js

@@ -5,5 +5,7 @@
  */
 export const parseGitZOutput = (input) =>
   input
-    .replace(/\u0000$/, '') // eslint-disable-line no-control-regex
-    .split('\u0000')
+    ? input
+        .replace(/\u0000$/, '') // eslint-disable-line no-control-regex
+        .split('\u0000')
+    : []

package/lib/resolveTaskFn.js

@@ -56,10 +56,16 @@ const handleOutput = (command, result, ctx, isError = false) => {
  * checks the context.
  */
 const interruptExecutionOnError = (ctx, execaChildProcess) => {
+  let loopIntervalId
+
   async function loop() {
     if (ctx.errors.size > 0) {
-      const ids = await pidTree(execaChildProcess.pid)
-      ids.forEach(process.kill)
+      clearInterval(loopIntervalId)
+
+      const childPids = await pidTree(execaChildProcess.pid)
+      for (const pid of childPids) {
+        process.kill(pid)
+      }
 
       // The execa process is killed separately in order
       // to get the `KILLED` status.
@@ -67,7 +73,7 @@ const interruptExecutionOnError = (ctx, execaChildProcess) => {
     }
   }
 
-  const loopIntervalId = setInterval(loop, ERROR_CHECK_INTERVAL)
+  loopIntervalId = setInterval(loop, ERROR_CHECK_INTERVAL)
 
   return () => {
     clearInterval(loopIntervalId)

package/lib/runAll.js

@@ -10,10 +10,10 @@ 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'
+import { groupFilesByConfig } from './groupFilesByConfig.js'
 import { makeCmdTasks } from './makeCmdTasks.js'
 import {
   DEPRECATED_GIT_ADD,
@@ -36,7 +36,7 @@ import {
   restoreUnstagedChangesSkipped,
 } from './state.js'
 import { GitRepoError, GetStagedFilesError, GitError, ConfigNotFoundError } from './symbols.js'
-import { searchConfigs } from './searchConfigs.js'
+import { ConfigObjectSymbol, searchConfigs } from './searchConfigs.js'
 
 const debugLog = debug('lint-staged:runAll')
 
@@ -120,11 +120,8 @@ export const runAll = async (
     return ctx
   }
 
-  const configGroups = await getConfigGroups({ configObject, configPath, cwd, files }, logger)
-
-  const hasExplicitConfig = configObject || configPath
-  const foundConfigs = hasExplicitConfig ? null : await searchConfigs(gitDir, logger)
-  const numberOfConfigs = hasExplicitConfig ? 1 : Object.keys(foundConfigs).length
+  const foundConfigs = await searchConfigs({ configObject, configPath, cwd, gitDir }, logger)
+  const numberOfConfigs = Reflect.ownKeys(foundConfigs).length
 
   // Throw if no configurations were found
   if (numberOfConfigs === 0) {
@@ -132,7 +129,7 @@ export const runAll = async (
     throw createError(ctx, ConfigNotFoundError)
   }
 
-  debugLog('Found %d configs:\n%O', numberOfConfigs, foundConfigs)
+  const filesByConfig = await groupFilesByConfig({ configs: foundConfigs, files })
 
   const hasMultipleConfigs = numberOfConfigs > 1
 
@@ -152,8 +149,14 @@ 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 [configPath, { config, files }] of Object.entries(configGroups)) {
-    const relativeConfig = normalize(path.relative(cwd, configPath))
+  for (const configPath of Reflect.ownKeys(filesByConfig)) {
+    const { config, files } = filesByConfig[configPath]
+
+    const configName =
+      configPath === ConfigObjectSymbol
+        ? 'Config object'
+        : normalize(path.relative(cwd, configPath))
+
     const stagedFileChunks = chunkFiles({ baseDir: gitDir, files, maxArgLength, relative })
 
     // Use actual cwd if it's specified, or there's only a single config file.
@@ -219,7 +222,7 @@ export const runAll = async (
 
       listrTasks.push({
         title:
-          `${relativeConfig}${dim(` — ${files.length} ${files.length > 1 ? 'files' : 'file'}`)}` +
+          `${configName}${dim(` — ${files.length} ${files.length > 1 ? 'files' : 'file'}`)}` +
           (chunkCount > 1 ? dim(` (chunk ${index + 1}/${chunkCount})...`) : ''),
         task: () => new Listr(chunkListrTasks, { ...listrOptions, concurrent, exitOnError: true }),
         skip: () => {
@@ -227,7 +230,7 @@ export const runAll = async (
           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 `${configName}${dim(' — no tasks to run')}`
           }
           return false
         },

package/lib/searchConfigs.js

@@ -2,6 +2,7 @@
 
 import { basename, join } from 'path'
 
+import debug from 'debug'
 import normalize from 'normalize-path'
 
 import { execGit } from './execGit.js'
@@ -9,38 +10,72 @@ import { loadConfig, searchPlaces } from './loadConfig.js'
 import { parseGitZOutput } from './parseGitZOutput.js'
 import { validateConfig } from './validateConfig.js'
 
+const debugLog = debug('lint-staged:searchConfigs')
+
 const EXEC_GIT = ['ls-files', '-z', '--full-name']
 
-const filterPossibleConfigFiles = (file) => searchPlaces.includes(basename(file))
+const filterPossibleConfigFiles = (files) =>
+  files.filter((file) => searchPlaces.includes(basename(file)))
 
 const numberOfLevels = (file) => file.split('/').length
 
 const sortDeepestParth = (a, b) => (numberOfLevels(a) > numberOfLevels(b) ? -1 : 1)
 
+const isInsideDirectory = (dir) => (file) => file.startsWith(normalize(dir))
+
+export const ConfigObjectSymbol = Symbol()
+
 /**
- * Search all config files from the git repository
+ * Search all config files from the git repository, preferring those inside `cwd`.
  *
- * @param {string} gitDir
+ * @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
- * @returns {Promise<{ [key: string]: * }>} found configs with filepath as key, and config as value
+ *
+ * @returns {Promise<{ [key: string]: { config: *, files: string[] } }>} found configs with filepath as key, and config as value
  */
-export const searchConfigs = async (gitDir = process.cwd(), logger) => {
-  /** Get all possible config files known to git */
-  const cachedFiles = parseGitZOutput(await execGit(EXEC_GIT, { cwd: gitDir })).filter(
-    filterPossibleConfigFiles
-  )
+export const searchConfigs = async (
+  { configObject, configPath, cwd = process.cwd(), gitDir = cwd },
+  logger
+) => {
+  debugLog('Searching for configuration files...')
+
+  // Return explicit config object from js API
+  if (configObject) {
+    debugLog('Using single direct configuration object...')
+
+    return { [ConfigObjectSymbol]: validateConfig(configObject, 'config object', logger) }
+  }
+
+  // Use only explicit config path instead of discovering multiple
+  if (configPath) {
+    debugLog('Using single configuration path...')
 
-  /** Get all possible config files from uncommitted files */
-  const otherFiles = parseGitZOutput(
-    await execGit([...EXEC_GIT, '--others', '--exclude-standard'], { cwd: gitDir })
-  ).filter(filterPossibleConfigFiles)
+    const { config, filepath } = await loadConfig({ configPath }, logger)
+
+    if (!config) return {}
+    return { [configPath]: validateConfig(config, filepath, logger) }
+  }
+
+  const [cachedFiles, otherFiles] = await Promise.all([
+    /** Get all possible config files known to git */
+    execGit(EXEC_GIT, { cwd: gitDir }).then(parseGitZOutput).then(filterPossibleConfigFiles),
+    /** Get all possible config files from uncommitted files */
+    execGit([...EXEC_GIT, '--others', '--exclude-standard'], { cwd: gitDir })
+      .then(parseGitZOutput)
+      .then(filterPossibleConfigFiles),
+  ])
 
   /** Sort possible config files so that deepest is first */
   const possibleConfigFiles = [...cachedFiles, ...otherFiles]
-    .map((file) => join(gitDir, file))
-    .map((file) => normalize(file))
+    .map((file) => normalize(join(gitDir, file)))
+    .filter(isInsideDirectory(cwd))
     .sort(sortDeepestParth)
 
+  debugLog('Found possible config files:', possibleConfigFiles)
+
   /** Create object with key as config file, and value as null */
   const configs = possibleConfigFiles.reduce(
     (acc, configPath) => Object.assign(acc, { [configPath]: null }),
@@ -49,15 +84,17 @@ export const searchConfigs = async (gitDir = process.cwd(), logger) => {
 
   /** Load and validate all configs to the above object */
   await Promise.all(
-    possibleConfigFiles
-      .map((configPath) => loadConfig({ configPath }, logger))
-      .map((promise) =>
-        promise.then(({ config, filepath }) => {
-          if (config) {
-            configs[filepath] = validateConfig(config, filepath, logger)
+    Object.keys(configs).map((configPath) =>
+      loadConfig({ configPath }, logger).then(({ config, filepath }) => {
+        if (config) {
+          if (configPath !== filepath) {
+            debugLog('Config file "%s" resolved to "%s"', configPath, filepath)
           }
-        })
-      )
+
+          configs[configPath] = validateConfig(config, filepath, logger)
+        }
+      })
+    )
   )
 
   /** Get validated configs from the above object, without any `null` values (not found) */
@@ -65,5 +102,24 @@ export const searchConfigs = async (gitDir = process.cwd(), logger) => {
     .filter(([, value]) => !!value)
     .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {})
 
+  /**
+   * Try to find a single config from parent directories
+   * to match old behavior before monorepo support
+   */
+  if (!Object.keys(foundConfigs).length) {
+    debugLog('Could not find config files inside "%s"', cwd)
+
+    const { config, filepath } = await loadConfig({ cwd }, logger)
+    if (config) {
+      debugLog('Found parent configuration file from "%s"', filepath)
+
+      foundConfigs[filepath] = validateConfig(config, filepath, logger)
+    } else {
+      debugLog('Could not find parent configuration files from "%s"', cwd)
+    }
+  }
+
+  debugLog('Found %d config files', Object.keys(foundConfigs).length)
+
   return foundConfigs
 }

package/package.json

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

package/lib/getConfigGroups.js

@@ -1,105 +0,0 @@
-/** @typedef {import('./index').Logger} Logger */
-
-import path from 'path'
-
-import debug from 'debug'
-import objectInspect from 'object-inspect'
-
-import { loadConfig } from './loadConfig.js'
-import { ConfigNotFoundError } from './symbols.js'
-import { validateConfig } from './validateConfig.js'
-
-const debugLog = debug('lint-staged:getConfigGroups')
-
-/**
- * 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 {string} [options.files] - List of staged files
- * @param {Logger} logger
- */
-export const getConfigGroups = async (
-  { configObject, configPath, cwd, files },
-  logger = console
-) => {
-  debugLog('Grouping configuration files...')
-
-  // Return explicit config object from js API
-  if (configObject) {
-    debugLog('Using single direct configuration object...')
-
-    const config = validateConfig(configObject, 'config object', logger)
-    return { '': { config, files } }
-  }
-
-  // Use only explicit config path instead of discovering multiple
-  if (configPath) {
-    debugLog('Using single configuration path...')
-
-    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 } }
-  }
-
-  debugLog('Grouping staged files by their directories...')
-
-  // 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
-  }, {})
-
-  debugLog('Grouped staged files into %d directories:', Object.keys(filesByDir).length)
-  debugLog(objectInspect(filesByDir, { indent: 2 }))
-
-  // Group files by their discovered config
-  // { '.lintstagedrc.json': { config: {...}, files: [...] } }
-  const configGroups = {}
-
-  debugLog('Searching config files...')
-
-  const searchConfig = async (cwd, files = []) => {
-    const { config, filepath } = await loadConfig({ cwd }, logger)
-    if (!config) {
-      debugLog('Found no config from "%s"!', cwd)
-      return
-    }
-
-    if (filepath in configGroups) {
-      debugLog('Found existing config "%s" from "%s"!', filepath, cwd)
-      // Re-use cached config and skip validation
-      configGroups[filepath].files.push(...files)
-    } else {
-      debugLog('Found new config "%s" from "%s"!', filepath, cwd)
-
-      const validatedConfig = validateConfig(config, filepath, logger)
-      configGroups[filepath] = { config: validatedConfig, files }
-    }
-  }
-
-  // Start by searching from cwd
-  await searchConfig(cwd)
-
-  // Discover configs from the base directory of each file
-  await Promise.all(Object.entries(filesByDir).map(([dir, files]) => searchConfig(dir, files)))
-
-  debugLog('Grouped staged files into %d groups!', Object.keys(configGroups).length)
-
-  return configGroups
-}