lint-staged 9.5.0-beta.2 → 9.5.0

package/README.md

@@ -2,6 +2,30 @@
 
 Run linters against staged git files and don't let :poop: slip into your code base!
 
+---
+
+## 🚧 Help test `lint-staged@beta`!
+
+Version 10 of `lint-staged` is coming with changes that help it run faster on large git repositories and prevent loss of data during errors. Please help test the `beta` version and report any inconsistencies in our [GitHub Issues](https://github.com/okonet/lint-staged/issues):
+
+**Using npm**
+
+    npm install --save-dev lint-staged@beta
+
+**Using yarn**
+
+    yarn add -D lint-staged@beta
+
+### Notable changes
+
+- A git stash is created before running any tasks, so in case of errors any lost changes can be restored easily (and automatically unless lint-staged itself crashes)
+- Instead of write-tree/read-tree, `lint-staged@beta` uses git stashes to hide unstaged changes while running tasks against staged files
+  - This results in a performance increase of up to 45x on very large repositories
+- The behaviour of committing modifications during tasks (eg. `prettier --write && git add`) is different. The current version creates a diff of these modifications, and applies it against the original state, silently ignoring any errors. The `beta` version leaves modifications of staged files as-is, and then restores all hidden unstaged changes as patch. If applying the patch fails due to a merge conflict (because tasks have modified the same lines), a 3-way merge will be retried. If this also fails, the entire commit will fail and the original state will be restored.
+  - **TL;DR** the `beta` version will never skip committing any changes by tasks (due to a merge conflict), but might fail in very complex situations where unstaged changes cannot be restored cleanly. If this happens to you, we are very interested in a repeatable test scenario.
+
+---
+
 [![asciicast](https://asciinema.org/a/199934.svg)](https://asciinema.org/a/199934)
 
 ## Why
@@ -46,13 +70,14 @@ $ npx lint-staged --help
 Usage: lint-staged [options]
 
 Options:
-  -V, --version        output the version number
-  -c, --config [path]  Path to configuration file
-  -r, --relative       Pass relative filepaths to tasks
-  -x, --shell          Skip parsing of tasks for better shell support
-  -q, --quiet          Disable lint-staged’s own console output
-  -d, --debug          Enable debug mode
-  -h, --help           output usage information
+  -V, --version                     output the version number
+  -c, --config [path]               Path to configuration file
+  -r, --relative                    Pass relative filepaths to tasks
+  -x, --shell                       Skip parsing of tasks for better shell support
+  -q, --quiet                       Disable lint-staged’s own console output
+  -d, --debug                       Enable debug mode
+  -p, --concurrent [parallel tasks] The number of tasks to run concurrently, or false to run tasks sequentially
+  -h, --help                        output usage information
 ```
 
 - **`--config [path]`**: This can be used to manually specify the `lint-staged` config file location. However, if the specified file cannot be found, it will error out instead of performing the usual search. You may pass a npm package name for configuration also.
@@ -62,6 +87,10 @@ Options:
 - **`--debug`**: Enabling the debug mode does the following:
   - `lint-staged` uses the [debug](https://github.com/visionmedia/debug) module internally to log information about staged files, commands being executed, location of binaries, etc. Debug logs, which are automatically enabled by passing the flag, can also be enabled by setting the environment variable `$DEBUG` to `lint-staged*`.
   - Use the [`verbose` renderer](https://github.com/SamVerschueren/listr-verbose-renderer) for `listr`.
+- **`--concurrent [number | (true/false)]`**: Controls the concurrency of tasks being run by lint-staged. **NOTE**: This does NOT affect the concurrency of subtasks (they will always be run sequentially). Possible values are:
+  - `false`: Run all tasks serially
+  - `true` (default) : _Infinite_ concurrency. Runs as many tasks in parallel as possible.
+  - `{number}`: Run the specified number of tasks in parallel, where `1` is equivalent to `false`.
 
 ## Configuration
 
@@ -108,7 +137,7 @@ Linter commands work on a subset of all staged files, defined by a _glob pattern
   - **`"*.js"`** will match all JS files, like `/test.js` and `/foo/bar/test.js`
   - **`"!(*test).js"`**. will match all JS files, except those ending in `test.js`, so `foo.js` but not `foo.test.js`
 - If the glob pattern does contain a slash (`/`), it will match for paths as well:
-  - **`"/*.js"`** will match all JS files in the git repo root, so `/test.js` but not `/foo/bar/test.js`
+  - **`"./*.js"`** will match all JS files in the git repo root, so `/test.js` but not `/foo/bar/test.js`
   - **`"foo/**/\*.js"`** will match all JS files inside the`/foo`directory, so`/foo/bar/test.js`but not`/test.js`
 
 When matching, `lint-staged` will do the following
@@ -229,15 +258,15 @@ module.exports = {
 
 ## Reformatting the code
 
-Tools like [Prettier](https://prettier.io), ESLint/TSLint, or stylelint can reformat your code according to an appropriate config by running `prettier --write`/`eslint --fix`/`tslint --fix`/`stylelint --fix`. Lint-staged will automatically add any modifications to the commit as long as there are no errors.
+Tools like [Prettier](https://prettier.io), ESLint/TSLint, or stylelint can reformat your code according to an appropriate config by running `prettier --write`/`eslint --fix`/`tslint --fix`/`stylelint --fix`. After the code is reformatted, we want it to be added to the same commit. This can be done using following config:
 
 ```json
 {
-  "*.js": "prettier --write"
+  "*.js": ["prettier --write", "git add"]
 }
 ```
 
-Prior to version 10, tasks had to manually include `git add` as the final step. This behavior has been integrated into lint-staged itself in order to prevent race conditions with multiple tasks editing the same files. If lint-staged detects `git add` in task configurations, it will show a warning in the console. Please remove `git add` from your configuration after upgrading.
+Starting from v8, lint-staged will stash your remaining changes (not added to the index) and restore them from stash afterwards if there are partially staged files detected. This allows you to create partial commits with hunks using `git add --patch`. See the [blog post](https://medium.com/@okonetchnikov/announcing-lint-staged-with-support-for-partially-staged-files-abc24a40d3ff)
 
 ## Examples
 
@@ -273,7 +302,7 @@ _Note we don’t pass a path as an argument for the runners. This is important s
 
 ```json
 {
-  "*.js": "eslint --fix"
+  "*.js": ["eslint --fix", "git add"]
 }
 ```
 
@@ -285,7 +314,7 @@ If you wish to reuse a npm script defined in your package.json:
 
 ```json
 {
-  "*.js": "npm run my-custom-script --"
+  "*.js": ["npm run my-custom-script --", "git add"]
 }
 ```
 
@@ -293,7 +322,7 @@ The following is equivalent:
 
 ```json
 {
-  "*.js": "linter --arg1 --arg2"
+  "*.js": ["linter --arg1 --arg2", "git add"]
 }
 ```
 
@@ -313,19 +342,19 @@ For example, here is `jest` running on all `.js` files with the `NODE_ENV` varia
 
 ```json
 {
-  "*.{js,jsx}": "prettier --write"
+  "*.{js,jsx}": ["prettier --write", "git add"]
 }
 ```
 
 ```json
 {
-  "*.{ts,tsx}": "prettier --write"
+  "*.{ts,tsx}": ["prettier --write", "git add"]
 }
 ```
 
 ```json
 {
-  "*.{md,html}": "prettier --write"
+  "*.{md,html}": ["prettier --write", "git add"]
 }
 ```
 
@@ -338,19 +367,19 @@ For example, here is `jest` running on all `.js` files with the `NODE_ENV` varia
 }
 ```
 
-### Run PostCSS sorting and Stylelint to check
+### Run PostCSS sorting, add files to commit and run Stylelint to check
 
 ```json
 {
-  "*.scss": "postcss --config path/to/your/config --replace", "stylelint"
+  "*.scss": ["postcss --config path/to/your/config --replace", "stylelint", "git add"]
 }
 ```
 
-### Minify the images
+### Minify the images and add files to commit
 
 ```json
 {
-  "*.{png,jpeg,jpg,gif,svg}": "imagemin-lint-staged"
+  "*.{png,jpeg,jpg,gif,svg}": ["imagemin-lint-staged", "git add"]
 }
 ```
 
@@ -367,7 +396,7 @@ See more on [this blog post](https://medium.com/@tomchentw/imagemin-lint-staged-
 
 ```json
 {
-  "*.{js,jsx}": "flow focus-check"
+  "*.{js,jsx}": ["flow focus-check", "git add"]
 }
 ```
 

package/bin/lint-staged

@@ -23,7 +23,7 @@ require('please-upgrade-node')(
 
 const cmdline = require('commander')
 const debugLib = require('debug')
-const lintStaged = require('../lib')
+const lintStaged = require('../src')
 
 const debug = debugLib('lint-staged:bin')
 
@@ -34,6 +34,11 @@ cmdline
   .option('-x, --shell', 'Skip parsing of tasks for better shell support')
   .option('-q, --quiet', 'Disable lint-staged’s own console output')
   .option('-d, --debug', 'Enable debug mode')
+  .option(
+    '-p, --concurrent <parallel tasks>',
+    'The number of tasks to run concurrently, or false to run tasks serially',
+    true
+  )
   .parse(process.argv)
 
 if (cmdline.debug) {
@@ -47,7 +52,8 @@ lintStaged({
   relative: !!cmdline.relative,
   shell: !!cmdline.shell,
   quiet: !!cmdline.quiet,
-  debug: !!cmdline.debug
+  debug: !!cmdline.debug,
+  concurrent: cmdline.concurrent
 })
   .then(passed => {
     process.exitCode = passed ? 0 : 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-staged",
-  "version": "9.5.0-beta.2",
+  "version": "9.5.0",
   "description": "Lint files staged by git",
   "license": "MIT",
   "repository": "https://github.com/okonet/lint-staged",
@@ -10,11 +10,11 @@
     "Suhas Karanth <sudo.suhas@gmail.com>",
     "Iiro Jäppinen <iiro@jappinen.fi> (https://iiro.fi)"
   ],
+  "main": "./src/index.js",
   "bin": "./bin/lint-staged",
-  "main": "./lib/index.js",
   "files": [
-    "bin",
-    "lib"
+    "src",
+    "bin"
   ],
   "scripts": {
     "cz": "git-cz",
@@ -43,6 +43,7 @@
     "micromatch": "^4.0.2",
     "normalize-path": "^3.0.0",
     "please-upgrade-node": "^3.1.1",
+    "string-argv": "^0.3.0",
     "stringify-object": "^3.3.0"
   },
   "devDependencies": {
@@ -68,8 +69,8 @@
     "jest": "^24.8.0",
     "jest-snapshot-serializer-ansi": "^1.0.0",
     "jsonlint": "^1.6.3",
-    "nanoid": "^2.1.1",
-    "prettier": "1.18.2"
+    "prettier": "1.18.2",
+    "tmp": "0.1.0"
   },
   "config": {
     "commitizen": {
@@ -79,7 +80,7 @@
   "jest": {
     "collectCoverage": true,
     "collectCoverageFrom": [
-      "lib/**/*.js"
+      "src/**/*.js"
     ],
     "setupFiles": [
       "./testSetup.js"

package/src/execGit.js

@@ -0,0 +1,13 @@
+'use strict'
+
+const debug = require('debug')('lint-staged:git')
+const execa = require('execa')
+
+module.exports = async function execGit(cmd, options = {}) {
+  debug('Running git command', cmd)
+  const { stdout } = await execa('git', [].concat(cmd), {
+    ...options,
+    cwd: options.cwd || process.cwd()
+  })
+  return stdout
+}

package/{lib → src}/generateTasks.js

@@ -15,6 +15,7 @@ const debug = require('debug')('lint-staged:gen-tasks')
  * @param {boolean} [options.gitDir] - Git root directory
  * @param {boolean} [options.files] - Staged filepaths
  * @param {boolean} [options.relative] - Whether filepaths to should be relative to gitDir
+ * @returns {Promise}
  */
 module.exports = function generateTasks({
   config,

package/src/gitWorkflow.js

@@ -0,0 +1,164 @@
+'use strict'
+
+const del = require('del')
+const debug = require('debug')('lint-staged:git')
+
+const execGit = require('./execGit')
+
+let workingCopyTree = null
+let indexTree = null
+let formattedIndexTree = null
+
+async function writeTree(options) {
+  return execGit(['write-tree'], options)
+}
+
+async function getDiffForTrees(tree1, tree2, options) {
+  debug(`Generating diff between trees ${tree1} and ${tree2}...`)
+  return execGit(
+    [
+      'diff-tree',
+      '--ignore-submodules',
+      '--binary',
+      '--no-color',
+      '--no-ext-diff',
+      '--unified=0',
+      tree1,
+      tree2
+    ],
+    options
+  )
+}
+
+async function hasPartiallyStagedFiles(options) {
+  const stdout = await execGit(['status', '--porcelain'], options)
+  if (!stdout) return false
+
+  const changedFiles = stdout.split('\n')
+  const partiallyStaged = changedFiles.filter(line => {
+    /**
+     * See https://git-scm.com/docs/git-status#_short_format
+     * The first letter of the line represents current index status,
+     * and second the working tree
+     */
+    const [index, workingTree] = line
+    return index !== ' ' && workingTree !== ' ' && index !== '?' && workingTree !== '?'
+  })
+
+  return partiallyStaged.length > 0
+}
+
+// eslint-disable-next-line
+async function gitStashSave(options) {
+  debug('Stashing files...')
+  // Save ref to the current index
+  indexTree = await writeTree(options)
+  // Add working copy changes to index
+  await execGit(['add', '.'], options)
+  // Save ref to the working copy index
+  workingCopyTree = await writeTree(options)
+  // Restore the current index
+  await execGit(['read-tree', indexTree], options)
+  // Remove all modifications
+  await execGit(['checkout-index', '-af'], options)
+  // await execGit(['clean', '-dfx'], options)
+  debug('Done stashing files!')
+  return [workingCopyTree, indexTree]
+}
+
+async function updateStash(options) {
+  formattedIndexTree = await writeTree(options)
+  return formattedIndexTree
+}
+
+async function applyPatchFor(tree1, tree2, options) {
+  const diff = await getDiffForTrees(tree1, tree2, options)
+  /**
+   * This is crucial for patch to work
+   * For some reason, git-apply requires that the patch ends with the newline symbol
+   * See http://git.661346.n2.nabble.com/Bug-in-Git-Gui-Creates-corrupt-patch-td2384251.html
+   * and https://stackoverflow.com/questions/13223868/how-to-stage-line-by-line-in-git-gui-although-no-newline-at-end-of-file-warnin
+   */
+  // TODO: Figure out how to test this. For some reason tests were working but in the real env it was failing
+  if (diff) {
+    try {
+      /**
+       * Apply patch to index. We will apply it with --reject so it it will try apply hunk by hunk
+       * We're not interested in failied hunks since this mean that formatting conflicts with user changes
+       * and we prioritize user changes over formatter's
+       */
+      await execGit(
+        ['apply', '-v', '--whitespace=nowarn', '--reject', '--recount', '--unidiff-zero'],
+        {
+          ...options,
+          input: `${diff}\n` // TODO: This should also work on Windows but test would be good
+        }
+      )
+    } catch (err) {
+      debug('Could not apply patch to the stashed files cleanly')
+      debug(err)
+      debug('Patch content:')
+      debug(diff)
+      throw new Error('Could not apply patch to the stashed files cleanly.', err)
+    }
+  }
+}
+
+async function gitStashPop(options) {
+  if (workingCopyTree === null) {
+    throw new Error('Trying to restore from stash but could not find working copy stash.')
+  }
+
+  debug('Restoring working copy')
+  // Restore the stashed files in the index
+  await execGit(['read-tree', workingCopyTree], options)
+  // and sync it to the working copy (i.e. update files on fs)
+  await execGit(['checkout-index', '-af'], options)
+
+  // Then, restore the index after working copy is restored
+  if (indexTree !== null && formattedIndexTree === null) {
+    // Restore changes that were in index if there are no formatting changes
+    debug('Restoring index')
+    await execGit(['read-tree', indexTree], options)
+  } else {
+    /**
+     * There are formatting changes we want to restore in the index
+     * and in the working copy. So we start by restoring the index
+     * and after that we'll try to carry as many as possible changes
+     * to the working copy by applying the patch with --reject option.
+     */
+    debug('Restoring index with formatting changes')
+    await execGit(['read-tree', formattedIndexTree], options)
+    try {
+      await applyPatchFor(indexTree, formattedIndexTree, options)
+    } catch (err) {
+      debug(
+        'Found conflicts between formatters and local changes. Formatters changes will be ignored for conflicted hunks.'
+      )
+      /**
+       * Clean up working directory from *.rej files that contain conflicted hanks.
+       * These hunks are coming from formatters so we'll just delete them since they are irrelevant.
+       */
+      try {
+        const rejFiles = await del(['*.rej'], options)
+        debug('Deleted files and folders:\n', rejFiles.join('\n'))
+      } catch (delErr) {
+        debug('Error deleting *.rej files', delErr)
+      }
+    }
+  }
+  // Clean up references
+  workingCopyTree = null
+  indexTree = null
+  formattedIndexTree = null
+
+  return null
+}
+
+module.exports = {
+  execGit,
+  gitStashSave,
+  gitStashPop,
+  hasPartiallyStagedFiles,
+  updateStash
+}

package/{lib → src}/index.js

@@ -48,12 +48,21 @@ function loadConfig(configPath) {
  * @param {boolean} [options.shell] - Skip parsing of tasks for better shell support
  * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
  * @param {boolean} [options.debug] - Enable debug mode
+ * @param {boolean | number} [options.concurrent] - The number of tasks to run concurrently, or false to run tasks serially
  * @param {Logger} [logger]
  *
  * @returns {Promise<boolean>} Promise of whether the linting passed or failed
  */
 module.exports = function lintStaged(
-  { configPath, config, relative = false, shell = false, quiet = false, debug = false } = {},
+  {
+    configPath,
+    config,
+    relative = false,
+    shell = false,
+    quiet = false,
+    debug = false,
+    concurrent = true
+  } = {},
   logger = console
 ) {
   debugLog('Loading config using `cosmiconfig`')
@@ -76,7 +85,7 @@ module.exports = function lintStaged(
         debugLog('lint-staged config:\n%O', config)
       }
 
-      return runAll({ config, relative, shell, quiet, debug }, logger)
+      return runAll({ config, relative, shell, quiet, debug, concurrent }, logger)
         .then(() => {
           debugLog('tasks were executed successfully!')
           return Promise.resolve(true)

package/{lib → src}/makeCmdTasks.js

@@ -13,7 +13,7 @@ const debug = require('debug')('lint-staged:make-cmd-tasks')
  * @param {string} options.gitDir
  * @param {Boolean} shell
  */
-module.exports = function makeCmdTasks({ commands, files, gitDir, shell }) {
+module.exports = async function makeCmdTasks({ commands, files, gitDir, shell }) {
   debug('Creating listr tasks for commands %o', commands)
   const commandsArray = Array.isArray(commands) ? commands : [commands]
 
@@ -41,11 +41,8 @@ module.exports = function makeCmdTasks({ commands, files, gitDir, shell }) {
         title = mockCommands[i].replace(/\[file\].*\[file\]/, '[file]')
       }
 
-      tasks.push({
-        title,
-        command,
-        task: resolveTaskFn({ command, files, gitDir, isFn, shell })
-      })
+      const task = { title, task: resolveTaskFn({ gitDir, isFn, command, files, shell }) }
+      tasks.push(task)
     })
 
     return tasks

package/{lib → src}/resolveTaskFn.js

@@ -4,9 +4,27 @@ const chalk = require('chalk')
 const dedent = require('dedent')
 const execa = require('execa')
 const symbols = require('log-symbols')
+const stringArgv = require('string-argv')
 
 const debug = require('debug')('lint-staged:task')
 
+/**
+ * Execute the given linter cmd using execa and
+ * return the promise.
+ *
+ * @param {string} cmd
+ * @param {Array<string>} args
+ * @param {Object} execaOptions
+ * @return {Promise} child_process
+ */
+const execLinter = (cmd, args, execaOptions) => {
+  debug('cmd:', cmd)
+  if (args) debug('args:', args)
+  debug('execaOptions:', execaOptions)
+
+  return args ? execa(cmd, args, execaOptions) : execa(cmd, execaOptions)
+}
+
 const successMsg = linter => `${symbols.success} ${linter} passed!`
 
 /**
@@ -55,22 +73,21 @@ function makeErr(linter, result, context = {}) {
 }
 
 /**
- * Returns the task function for the linter.
+ * Returns the task function for the linter. It handles chunking for file paths
+ * if the OS is Windows.
  *
  * @param {Object} options
  * @param {string} options.command — Linter task
  * @param {String} options.gitDir - Current git repo path
  * @param {Boolean} options.isFn - Whether the linter task is a function
- * @param {Array<string>} options.files — Filepaths to run the linter task against
+ * @param {Array<string>} options.pathsToLint — Filepaths to run the linter task against
  * @param {Boolean} [options.relative] — Whether the filepaths should be relative
  * @param {Boolean} [options.shell] — Whether to skip parsing linter task for better shell support
  * @returns {function(): Promise<Array<string>>}
  */
 module.exports = function resolveTaskFn({ command, files, gitDir, isFn, relative, shell = false }) {
-  const cmd = isFn ? command : `${command} ${files.join(' ')}`
-  debug('cmd:', cmd)
-
   const execaOptions = { preferLocal: true, reject: false, shell }
+
   if (relative) {
     execaOptions.cwd = process.cwd()
   } else if (/^git(\.exe)?/i.test(command) && gitDir !== process.cwd()) {
@@ -78,15 +95,27 @@ module.exports = function resolveTaskFn({ command, files, gitDir, isFn, relative
     // e.g `npm` should run tasks in the actual CWD
     execaOptions.cwd = gitDir
   }
-  debug('execaOptions:', execaOptions)
 
-  return async ctx => {
-    const result = await execa.command(cmd, execaOptions)
+  let cmd
+  let args
 
-    if (result.failed || result.killed || result.signal != null) {
-      throw makeErr(command, result, ctx)
-    }
-
-    return successMsg(command)
+  if (shell) {
+    execaOptions.shell = true
+    // If `shell`, passed command shouldn't be parsed
+    // If `linter` is a function, command already includes `files`.
+    cmd = isFn ? command : `${command} ${files.join(' ')}`
+  } else {
+    const [parsedCmd, ...parsedArgs] = stringArgv.parseArgsStringToArgv(command)
+    cmd = parsedCmd
+    args = isFn ? parsedArgs : parsedArgs.concat(files)
   }
+
+  return ctx =>
+    execLinter(cmd, args, execaOptions).then(result => {
+      if (result.failed || result.killed || result.signal != null) {
+        throw makeErr(command, result, ctx)
+      }
+
+      return successMsg(command)
+    })
 }

package/src/runAll.js

@@ -0,0 +1,147 @@
+'use strict'
+
+/** @typedef {import('./index').Logger} Logger */
+
+const chalk = require('chalk')
+const dedent = require('dedent')
+const Listr = require('listr')
+const symbols = require('log-symbols')
+
+const generateTasks = require('./generateTasks')
+const getStagedFiles = require('./getStagedFiles')
+const git = require('./gitWorkflow')
+const makeCmdTasks = require('./makeCmdTasks')
+const resolveGitDir = require('./resolveGitDir')
+
+const debugLog = require('debug')('lint-staged:run')
+
+/**
+ * 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 MAX_ARG_LENGTH =
+  (process.platform === 'darwin' && 262144) || (process.platform === 'win32' && 8191) || 131072
+
+/**
+ * Executes all tasks and either resolves or rejects the promise
+ *
+ * @param {object} options
+ * @param {Object} [options.config] - Task configuration
+ * @param {Object} [options.cwd] - Current working directory
+ * @param {boolean} [options.relative] - Pass relative filepaths to tasks
+ * @param {boolean} [options.shell] - Skip parsing of tasks for better shell support
+ * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
+ * @param {boolean} [options.debug] - Enable debug mode
+ * @param {boolean | number} [options.concurrent] - The number of tasks to run concurrently, or false to run tasks serially
+ * @param {Logger} logger
+ * @returns {Promise}
+ */
+module.exports = async function runAll(
+  {
+    config,
+    cwd = process.cwd(),
+    debug = false,
+    quiet = false,
+    relative = false,
+    shell = false,
+    concurrent = true
+  },
+  logger = console
+) {
+  debugLog('Running all linter scripts')
+  const gitDir = await resolveGitDir({ cwd })
+
+  if (!gitDir) {
+    throw new Error('Current directory is not a git directory!')
+  }
+
+  debugLog('Resolved git directory to be `%s`', gitDir)
+
+  const files = await getStagedFiles({ cwd: gitDir })
+
+  if (!files) {
+    throw new Error('Unable to get staged files!')
+  }
+
+  debugLog('Loaded list of staged files in git:\n%O', files)
+
+  const argLength = files.join(' ').length
+  if (argLength > MAX_ARG_LENGTH) {
+    logger.warn(
+      dedent`${symbols.warning}  ${chalk.yellow(
+        `lint-staged generated an argument string of ${argLength} characters, and commands might not run correctly on your platform.
+It is recommended to use functions as linters and split your command based on the number of staged files. For more info, please visit:
+https://github.com/okonet/lint-staged#using-js-functions-to-customize-linter-commands`
+      )}`
+    )
+  }
+
+  const tasks = generateTasks({ config, cwd, gitDir, files, relative }).map(task => ({
+    title: `Running tasks for ${task.pattern}`,
+    task: async () =>
+      new Listr(
+        await makeCmdTasks({ commands: task.commands, files: task.fileList, gitDir, shell }),
+        {
+          // In sub-tasks we don't want to run concurrently
+          // and we want to abort on errors
+          dateFormat: false,
+          concurrent: false,
+          exitOnError: true
+        }
+      ),
+    skip: () => {
+      if (task.fileList.length === 0) {
+        return `No staged files match ${task.pattern}`
+      }
+      return false
+    }
+  }))
+
+  const listrOptions = {
+    dateFormat: false,
+    renderer: (quiet && 'silent') || (debug && 'verbose') || 'update'
+  }
+
+  // If all of the configured "linters" should be skipped
+  // avoid executing any lint-staged logic
+  if (tasks.every(task => task.skip())) {
+    logger.log('No staged files match any of provided globs.')
+    return 'No tasks to run.'
+  }
+
+  return new Listr(
+    [
+      {
+        title: 'Stashing changes...',
+        skip: async () => {
+          const hasPSF = await git.hasPartiallyStagedFiles({ cwd: gitDir })
+          if (!hasPSF) {
+            return 'No partially staged files found...'
+          }
+          return false
+        },
+        task: ctx => {
+          ctx.hasStash = true
+          return git.gitStashSave({ cwd: gitDir })
+        }
+      },
+      {
+        title: 'Running tasks...',
+        task: () => new Listr(tasks, { ...listrOptions, concurrent, exitOnError: false })
+      },
+      {
+        title: 'Updating stash...',
+        enabled: ctx => ctx.hasStash,
+        skip: ctx => ctx.hasErrors && 'Skipping stash update since some tasks exited with errors',
+        task: () => git.updateStash({ cwd: gitDir })
+      },
+      {
+        title: 'Restoring local changes...',
+        enabled: ctx => ctx.hasStash,
+        task: () => git.gitStashPop({ cwd: gitDir })
+      }
+    ],
+    listrOptions
+  ).run()
+}

package/lib/execGit.js

@@ -1,17 +0,0 @@
-'use strict'
-
-const debug = require('debug')('lint-staged:git')
-const execa = require('execa')
-
-module.exports = async function execGit(cmd, options = {}) {
-  debug('Running git command', cmd)
-  try {
-    const { stdout } = await execa('git', [].concat(cmd), {
-      ...options,
-      cwd: options.cwd || process.cwd()
-    })
-    return stdout
-  } catch ({ all }) {
-    throw new Error(all)
-  }
-}

package/lib/file.js

@@ -1,51 +0,0 @@
-'use strict'
-
-const debug = require('debug')('lint-staged:file')
-const fs = require('fs')
-
-/**
- * Check if file exists and is accessible
- * @param {String} filename
- * @returns {Promise<Boolean>}
- */
-module.exports.checkFile = filename =>
-  new Promise(resolve => {
-    debug('Trying to access `%s`', filename)
-    fs.access(filename, fs.constants.R_OK, error => {
-      if (error) {
-        debug('Unable to access file `%s` with error:', filename)
-        debug(error)
-      } else {
-        debug('Successfully accesses file `%s`', filename)
-      }
-
-      resolve(!error)
-    })
-  })
-
-/**
- * @param {String} filename
- * @returns {Promise<Buffer|Null>}
- */
-module.exports.readBufferFromFile = filename =>
-  new Promise(resolve => {
-    debug('Reading buffer from file `%s`', filename)
-    fs.readFile(filename, (error, file) => {
-      debug('Done reading buffer from file `%s`!', filename)
-      resolve(file)
-    })
-  })
-
-/**
- * @param {String} filename
- * @param {Buffer} buffer
- * @returns {Promise<Void>}
- */
-module.exports.writeBufferToFile = (filename, buffer) =>
-  new Promise(resolve => {
-    debug('Writing buffer to file `%s`', filename)
-    fs.writeFile(filename, buffer, () => {
-      debug('Done writing buffer to file `%s`!', filename)
-      resolve()
-    })
-  })

package/lib/gitWorkflow.js

@@ -1,184 +0,0 @@
-'use strict'
-
-const debug = require('debug')('lint-staged:git')
-const path = require('path')
-
-const execGit = require('./execGit')
-const { checkFile, readBufferFromFile, writeBufferToFile } = require('./file')
-
-const MERGE_HEAD = 'MERGE_HEAD'
-const MERGE_MODE = 'MERGE_MODE'
-const MERGE_MSG = 'MERGE_MSG'
-
-const STASH = 'lint-staged automatic backup'
-
-const gitApplyArgs = ['apply', '-v', '--whitespace=nowarn', '--recount', '--unidiff-zero']
-
-class GitWorkflow {
-  constructor(cwd) {
-    this.execGit = (args, options = {}) => execGit(args, { ...options, cwd })
-    this.unstagedDiff = null
-    this.cwd = cwd
-
-    /**
-     * These three files hold state about an ongoing git merge
-     * Resolve paths during constructor
-     */
-    this.mergeHeadFile = path.resolve(this.cwd, '.git', MERGE_HEAD)
-    this.mergeModeFile = path.resolve(this.cwd, '.git', MERGE_MODE)
-    this.mergeMsgFile = path.resolve(this.cwd, '.git', MERGE_MSG)
-  }
-
-  /**
-   * Get name of backup stash
-   *
-   * @param {Object} [options]
-   * @returns {Promise<Object>}
-   */
-  async getBackupStash() {
-    const stashes = await this.execGit(['stash', 'list'])
-    const index = stashes.split('\n').findIndex(line => line.includes(STASH))
-    return `stash@{${index}}`
-  }
-
-  /**
-   * Create backup stashes, one of everything and one of only staged changes
-   * Staged files are left in the index for running tasks
-   *
-   * @param {Object} [options]
-   * @returns {Promise<void>}
-   */
-  async stashBackup() {
-    debug('Backing up original state...')
-
-    // Git stash loses metadata about a possible merge mode
-    // Manually check and backup if necessary
-    if (await checkFile(this.mergeHeadFile)) {
-      debug('Detected current merge mode!')
-      debug('Backing up merge state...')
-      await Promise.all([
-        readBufferFromFile(this.mergeHeadFile).then(
-          mergeHead => (this.mergeHeadBuffer = mergeHead)
-        ),
-        readBufferFromFile(this.mergeModeFile).then(
-          mergeMode => (this.mergeModeBuffer = mergeMode)
-        ),
-        readBufferFromFile(this.mergeMsgFile).then(mergeMsg => (this.mergeMsgBuffer = mergeMsg))
-      ])
-      debug('Done backing up merge state!')
-    }
-
-    // Save stash of entire original state, including unstaged and untracked changes.
-    // This should remove all changes from the index.
-    // The `--keep-index` option cannot be used since it resurrects deleted files on
-    // git versions before v2.23.0 (https://github.com/git/git/blob/master/Documentation/RelNotes/2.23.0.txt#L322)
-    await this.execGit(['stash', 'save', '--quiet', '--include-untracked', STASH])
-    // Apply only the staged changes back to index
-    await this.execGit(['stash', 'apply', '--index', await this.getBackupStash()])
-    // Checkout everything just in case there are unstaged files left behind.
-    await this.execGit(['checkout', '.'])
-    // Since only staged files are now present, get a diff of unstaged changes
-    // by comparing current index against original stash, but in reverse
-    this.unstagedDiff = await this.execGit([
-      'diff',
-      '--unified=0',
-      '--no-color',
-      '--no-ext-diff',
-      '--patch',
-      await this.getBackupStash(),
-      '-R' // Show diff in reverse
-    ])
-    debug('Done backing up original state!')
-  }
-
-  /**
-   * Applies back task modifications, and unstaged changes hidden in the stash.
-   * In case of a merge-conflict retry with 3-way merge.
-   *
-   * @param {Object} [options]
-   * @returns {Promise<void>}
-   */
-  async applyModifications() {
-    let modifiedFiles = await this.execGit(['ls-files', '--modified'])
-    if (modifiedFiles) {
-      modifiedFiles = modifiedFiles.split('\n')
-      debug('Detected files modified by tasks:')
-      debug(modifiedFiles)
-      debug('Adding files to index...')
-      await this.execGit(['add', modifiedFiles])
-      debug('Done adding files to index!')
-    }
-
-    if (this.unstagedDiff) {
-      debug('Restoring unstaged changes...')
-      try {
-        await this.execGit(gitApplyArgs, { input: `${this.unstagedDiff}\n` })
-      } catch (error) {
-        debug('Error while restoring changes:')
-        debug(error)
-        debug('Retrying with 3-way merge')
-
-        try {
-          // Retry with `--3way` if normal apply fails
-          await this.execGit([...gitApplyArgs, '--3way'], { input: `${this.unstagedDiff}\n` })
-        } catch (error2) {
-          debug('Error while restoring unstaged changes using 3-way merge:')
-          debug(error2)
-          throw new Error('Unstaged changes could not be restored due to a merge conflict!')
-        }
-      }
-      debug('Done restoring unstaged changes!')
-    }
-
-    // Restore untracked files by reading from the third commit associated with the backup stash
-    // Git will return with error code if the commit doesn't exist
-    // See https://stackoverflow.com/a/52357762
-    try {
-      const backupStash = await this.getBackupStash()
-      const output = await this.execGit(['show', '--format=%b', `${backupStash}^3`])
-      const untrackedDiff = output.replace(/^\n*/, '') // remove empty lines from start of output
-      if (!untrackedDiff) return
-      await this.execGit([...gitApplyArgs], { input: `${untrackedDiff}\n` })
-    } catch (err) {} // eslint-disable-line no-empty
-  }
-
-  /**
-   * Restore original HEAD state in case of errors
-   *
-   * @param {Object} [options]
-   * @returns {Promise<void>}
-   */
-  async restoreOriginalState() {
-    debug('Restoring original state...')
-    const original = await this.getBackupStash()
-    await this.execGit(['reset', '--hard', 'HEAD'])
-    await this.execGit(['stash', 'apply', '--quiet', '--index', original])
-    debug('Done restoring original state!')
-  }
-
-  /**
-   * Drop the created stashes after everything has run
-   *
-   * @param {Object} [options]
-   * @returns {Promise<void>}
-   */
-  async dropBackup() {
-    debug('Dropping backup stash...')
-    const original = await this.getBackupStash()
-    await this.execGit(['stash', 'drop', '--quiet', original])
-    debug('Done dropping backup stash!')
-
-    if (this.mergeHeadBuffer) {
-      debug('Detected backup merge state!')
-      debug('Restoring merge state...')
-      await Promise.all([
-        writeBufferToFile(this.mergeHeadFile, this.mergeHeadBuffer),
-        writeBufferToFile(this.mergeModeFile, this.mergeModeBuffer),
-        writeBufferToFile(this.mergeMsgFile, this.mergeMsgBuffer)
-      ])
-      debug('Done restoring merge state!')
-    }
-  }
-}
-
-module.exports = GitWorkflow

package/lib/runAll.js

@@ -1,168 +0,0 @@
-'use strict'
-
-/** @typedef {import('./index').Logger} Logger */
-
-const chalk = require('chalk')
-const Listr = require('listr')
-const symbols = require('log-symbols')
-
-const generateTasks = require('./generateTasks')
-const getStagedFiles = require('./getStagedFiles')
-const GitWorkflow = require('./gitWorkflow')
-const makeCmdTasks = require('./makeCmdTasks')
-const resolveGitDir = require('./resolveGitDir')
-
-const debugLog = require('debug')('lint-staged:run')
-
-/**
- * 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 MAX_ARG_LENGTH =
-  (process.platform === 'darwin' && 262144) || (process.platform === 'win32' && 8191) || 131072
-
-/**
- * Executes all tasks and either resolves or rejects the promise
- *
- * @param {object} options
- * @param {Object} [options.config] - Task configuration
- * @param {Object} [options.cwd] - Current working directory
- * @param {boolean} [options.relative] - Pass relative filepaths to tasks
- * @param {boolean} [options.shell] - Skip parsing of tasks for better shell support
- * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
- * @param {boolean} [options.debug] - Enable debug mode
- * @param {Logger} logger
- * @returns {Promise}
- */
-module.exports = async function runAll(
-  { config, cwd = process.cwd(), debug = false, quiet = false, relative = false, shell = false },
-  logger = console
-) {
-  debugLog('Running all linter scripts')
-
-  const gitDir = await resolveGitDir({ cwd })
-
-  if (!gitDir) {
-    throw new Error('Current directory is not a git directory!')
-  }
-
-  debugLog('Resolved git directory to be `%s`', gitDir)
-
-  const files = await getStagedFiles({ cwd: gitDir })
-
-  if (!files) {
-    throw new Error('Unable to get staged files!')
-  }
-
-  debugLog('Loaded list of staged files in git:\n%O', files)
-
-  const argLength = files.join(' ').length
-  if (argLength > MAX_ARG_LENGTH) {
-    logger.warn(`
- ${symbols.warning}  ${chalk.yellow(
-      `lint-staged generated an argument string of ${argLength} characters, and commands might not run correctly on your platform.
-    It is recommended to use functions as linters and split your command based on the number of staged files. For more info, please visit:
-    https://github.com/okonet/lint-staged#using-js-functions-to-customize-linter-commands`
-    )}
-`)
-  }
-
-  const tasks = generateTasks({ config, cwd, gitDir, files, relative })
-
-  // lint-staged 10 will automatically add modifications to index
-  // Warn user when their command includes `git add`
-  let hasDeprecatedGitAdd = false
-
-  const listrTasks = tasks.map(task => {
-    const subTasks = makeCmdTasks({ commands: task.commands, files: task.fileList, gitDir, shell })
-
-    if (subTasks.some(subTask => subTask.command.includes('git add'))) {
-      hasDeprecatedGitAdd = true
-    }
-
-    return {
-      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
-          dateFormat: false,
-          concurrent: false,
-          exitOnError: true
-        }),
-      skip: () => {
-        if (task.fileList.length === 0) {
-          return `No staged files match ${task.pattern}`
-        }
-        return false
-      }
-    }
-  })
-
-  if (hasDeprecatedGitAdd) {
-    logger.warn(`${symbols.warning} ${chalk.yellow(
-      `Some of your tasks use \`git add\` command. Please remove it from the config since all modifications made by tasks will be automatically added to the git commit index.`
-    )}
-`)
-  }
-
-  // If all of the configured tasks should be skipped
-  // avoid executing any lint-staged logic
-  if (listrTasks.every(task => task.skip())) {
-    logger.log('No staged files match any of provided globs.')
-    return 'No tasks to run.'
-  }
-
-  const listrOptions = {
-    dateFormat: false,
-    renderer: (quiet && 'silent') || (debug && 'verbose') || 'update'
-  }
-
-  const git = new GitWorkflow(gitDir)
-
-  const runner = new Listr(
-    [
-      {
-        title: 'Preparing...',
-        task: () => git.stashBackup()
-      },
-      {
-        title: 'Running tasks...',
-        task: () => new Listr(listrTasks, { ...listrOptions, concurrent: true, exitOnError: false })
-      },
-      {
-        title: 'Applying modifications...',
-        skip: ctx => ctx.hasErrors && 'Skipped because of errors from tasks',
-        task: () => git.applyModifications()
-      },
-      {
-        title: 'Reverting to original state...',
-        enabled: ctx => ctx.hasErrors,
-        task: () => git.restoreOriginalState()
-      },
-      {
-        title: 'Cleaning up...',
-        task: () => git.dropBackup()
-      }
-    ],
-    listrOptions
-  )
-
-  try {
-    await runner.run()
-  } catch (error) {
-    if (error.message.includes('Another git process seems to be running in this repository')) {
-      logger.error(`
-  ${symbols.error} ${chalk.red(`lint-staged failed due to a git error.
-    Any lost modifications can be restored from a git stash:
-
-    > git stash list
-    stash@{0}: On master: automatic lint-staged backup
-    > git stash pop stash@{0}`)}
-`)
-    }
-
-    throw error
-  }
-}