lint-staged 10.0.8 → 10.1.1

package/README.md

@@ -60,13 +60,18 @@ Usage: lint-staged [options]
 
 Options:
   -V, --version                      output the version number
-  --allow-empty                      allow empty commits when tasks undo all staged changes (default: false)
+  --allow-empty                      allow empty commits when tasks revert all staged changes
+                                     (default: false)
   -c, --config [path]                path to configuration file
   -d, --debug                        print additional debug information (default: false)
-  -p, --concurrent <parallel tasks>  the number of tasks to run concurrently, or false to run tasks serially (default: true)
+  --no-stash                         disable the backup stash, and do not revert in case of
+                                     errors
+  -p, --concurrent <parallel tasks>  the number of tasks to run concurrently, or false to run
+                                     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: false)
+  -x, --shell                        skip parsing of tasks for better shell support (default:
+                                     false)
   -h, --help                         output usage information
 ```
 
@@ -79,6 +84,7 @@ Options:
   - `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`.
+- **`--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.
@@ -168,7 +174,7 @@ Pass arguments to your commands separated by space as you would do in the shell.
 
 ## Running multiple commands in a sequence
 
-You can run multiple commands in a sequence on every glob. To do so, pass an array of commands instead of a single one. This is useful for running autoformatting tools like `eslint --fix` or `stylefmt` but can be used for any arbitrary sequences. 
+You can run multiple commands in a sequence on every glob. To do so, pass an array of commands instead of a single one. This is useful for running autoformatting tools like `eslint --fix` or `stylefmt` but can be used for any arbitrary sequences.
 
 For example:
 

package/bin/lint-staged.js

@@ -31,6 +31,7 @@ cmdline
   .option('--allow-empty', 'allow empty commits when tasks revert all staged changes', false)
   .option('-c, --config [path]', 'path to configuration file')
   .option('-d, --debug', 'print additional debug information', false)
+  .option('--no-stash', 'disable the backup stash, and do not revert in case of errors', false)
   .option(
     '-p, --concurrent <parallel tasks>',
     'the number of tasks to run concurrently, or false to run tasks serially',
@@ -71,6 +72,7 @@ const options = {
   configPath: cmdline.config,
   debug: !!cmdline.debug,
   maxArgLength: getMaxArgLength() / 2,
+  stash: !!cmdline.stash, // commander inverts `no-<x>` flags to `!x`
   quiet: !!cmdline.quiet,
   relative: !!cmdline.relative,
   shell: !!cmdline.shell

package/lib/file.js

@@ -4,25 +4,10 @@ const debug = require('debug')('lint-staged:file')
 const fs = require('fs')
 const { promisify } = require('util')
 
-const fsAccess = promisify(fs.access)
 const fsReadFile = promisify(fs.readFile)
 const fsUnlink = promisify(fs.unlink)
 const fsWriteFile = promisify(fs.writeFile)
 
-/**
- * Check if a file exists. Returns the filename if exists.
- * @param {String} filename
- * @returns {String|Boolean}
- */
-const exists = async filename => {
-  try {
-    await fsAccess(filename)
-    return filename
-  } catch {
-    return false
-  }
-}
-
 /**
  * Read contents of a file to buffer
  * @param {String} filename
@@ -44,21 +29,19 @@ const readFile = async (filename, ignoreENOENT = true) => {
 }
 
 /**
- * Unlink a file if it exists
+ * Remove a file
  * @param {String} filename
  * @param {Boolean} [ignoreENOENT=true] — Whether to throw if the file doesn't exist
  */
 const unlink = async (filename, ignoreENOENT = true) => {
-  if (filename) {
-    debug('Unlinking file `%s`', filename)
-    try {
-      await fsUnlink(filename)
-    } catch (error) {
-      if (ignoreENOENT && error.code === 'ENOENT') {
-        debug("File `%s` doesn't exist, ignoring...", filename)
-      } else {
-        throw error
-      }
+  debug('Removing file `%s`', filename)
+  try {
+    await fsUnlink(filename)
+  } catch (error) {
+    if (ignoreENOENT && error.code === 'ENOENT') {
+      debug("File `%s` doesn't exist, ignoring...", filename)
+    } else {
+      throw error
     }
   }
 }
@@ -74,7 +57,6 @@ const writeFile = async (filename, buffer) => {
 }
 
 module.exports = {
-  exists,
   readFile,
   unlink,
   writeFile

package/lib/getStagedFiles.js

@@ -4,8 +4,15 @@ const execGit = require('./execGit')
 
 module.exports = async function getStagedFiles(options) {
   try {
-    const lines = await execGit(['diff', '--staged', '--diff-filter=ACMR', '--name-only'], options)
-    return lines ? lines.split('\n') : []
+    // 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
+    )
+    // 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/gitWorkflow.js

@@ -4,19 +4,47 @@ const debug = require('debug')('lint-staged:git')
 const path = require('path')
 
 const execGit = require('./execGit')
-const { exists, readFile, unlink, writeFile } = require('./file')
+const { readFile, unlink, writeFile } = require('./file')
 
 const MERGE_HEAD = 'MERGE_HEAD'
 const MERGE_MODE = 'MERGE_MODE'
 const MERGE_MSG = 'MERGE_MSG'
 
+// In git status, renames are presented as `from` -> `to`.
+// When diffing, both need to be taken into account, but in some cases on the `to`.
+const RENAME = / -> /
+
+/**
+ * From list of files, split renames and flatten into two files `from` -> `to`.
+ * @param {string[]} files
+ * @param {Boolean} [includeRenameFrom=true] Whether or not to include the `from` renamed file, which is no longer on disk
+ */
+const processRenames = (files, includeRenameFrom = true) =>
+  files.reduce((flattened, file) => {
+    if (RENAME.test(file)) {
+      const [from, to] = file.split(RENAME)
+      if (includeRenameFrom) flattened.push(from)
+      flattened.push(to)
+    } else {
+      flattened.push(file)
+    }
+    return flattened
+  }, [])
+
 const STASH = 'lint-staged automatic backup'
 
 const PATCH_UNSTAGED = 'lint-staged_unstaged.patch'
-const PATCH_UNTRACKED = 'lint-staged_untracked.patch'
 
-const GIT_APPLY_ARGS = ['apply', '-v', '--whitespace=nowarn', '--recount', '--unidiff-zero']
-const GIT_DIFF_ARGS = ['--binary', '--unified=0', '--no-color', '--no-ext-diff', '--patch']
+const GIT_DIFF_ARGS = [
+  '--binary', // support binary files
+  '--unified=0', // do not add lines around diff for consistent behaviour
+  '--no-color', // disable colors for consistent behaviour
+  '--no-ext-diff', // disable external diff tools for consistent behaviour
+  '--src-prefix=a/', // force prefix for consistent behaviour
+  '--dst-prefix=b/', // force prefix for consistent behaviour
+  '--patch' // output a patch that can be applied
+]
+const GIT_APPLY_ARGS = ['-v', '--whitespace=nowarn', '--recount', '--unidiff-zero']
 
 const handleError = (error, ctx) => {
   ctx.gitError = true
@@ -26,6 +54,7 @@ const handleError = (error, ctx) => {
 class GitWorkflow {
   constructor({ allowEmpty, gitConfigDir, gitDir, stagedFileChunks }) {
     this.execGit = (args, options = {}) => execGit(args, { ...options, cwd: gitDir })
+    this.deletedFiles = []
     this.gitConfigDir = gitConfigDir
     this.gitDir = gitDir
     this.unstagedDiff = null
@@ -49,19 +78,6 @@ class GitWorkflow {
     return path.resolve(this.gitConfigDir, `./${filename}`)
   }
 
-  /**
-   * Check if patch file exists and has content.
-   * @param {string} filename
-   */
-  async hasPatch(filename) {
-    const resolved = this.getHiddenFilepath(filename)
-    const pathIfExists = await exists(resolved)
-    if (!pathIfExists) return false
-    const buffer = await readFile(pathIfExists)
-    const patch = buffer.toString().trim()
-    return patch.length ? filename : false
-  }
-
   /**
    * Get name of backup stash
    */
@@ -75,6 +91,20 @@ class GitWorkflow {
     return `stash@{${index}}`
   }
 
+  /**
+   * Get a list of unstaged deleted files
+   */
+  async getDeletedFiles() {
+    debug('Getting deleted files...')
+    const lsFiles = await this.execGit(['ls-files', '--deleted'])
+    const deletedFiles = lsFiles
+      .split('\n')
+      .filter(Boolean)
+      .map(file => path.resolve(this.gitDir, file))
+    debug('Found deleted files:', deletedFiles)
+    return deletedFiles
+  }
+
   /**
    * Save meta information about ongoing git merge
    */
@@ -108,56 +138,70 @@ class GitWorkflow {
   }
 
   /**
-   * List and delete untracked files
+   * Get a list of all files with both staged and unstaged modifications.
+   * Renames have special treatment, since the single status line includes
+   * both the "from" and "to" filenames, where "from" is no longer on disk.
    */
-  async cleanUntrackedFiles() {
-    const lsFiles = await this.execGit(['ls-files', '--others', '--exclude-standard'])
-    const untrackedFiles = lsFiles
+  async getPartiallyStagedFiles() {
+    debug('Getting partially staged files...')
+    const status = await this.execGit(['status', '--porcelain'])
+    const partiallyStaged = status
       .split('\n')
-      .filter(Boolean)
-      .map(file => path.resolve(this.gitDir, file))
-    await Promise.all(untrackedFiles.map(file => unlink(file)))
+      .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 !== '?'
+      })
+      .map(line => line.substr(3)) // Remove first three letters (index, workingTree, and a whitespace)
+    debug('Found partially staged files:', partiallyStaged)
+    return partiallyStaged.length ? partiallyStaged : null
   }
 
   /**
-   * Create backup stashes, one of everything and one of only staged changes
-   * Staged files are left in the index for running tasks
+   * Create a diff of partially staged files and backup stash if enabled.
    */
-  async stashBackup(ctx) {
+  async prepare(ctx, stash) {
     try {
       debug('Backing up original state...')
 
-      // the `git stash` clears metadata about a possible git merge
-      // Manually check and backup if necessary
-      await this.backupMergeStatus()
+      // Get a list of files with bot staged and unstaged changes.
+      // Unstaged changes to these files should be hidden before the tasks run.
+      this.partiallyStagedFiles = await this.getPartiallyStagedFiles()
+
+      if (this.partiallyStagedFiles) {
+        ctx.hasPartiallyStagedFiles = true
+        const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
+        const files = processRenames(this.partiallyStagedFiles)
+        await this.execGit(['diff', ...GIT_DIFF_ARGS, '--output', unstagedPatch, '--', ...files])
+      }
+
+      /**
+       * If backup stash should be skipped, no need to continue
+       */
+      if (!stash) return
 
       // Get a list of unstaged deleted files, because certain bugs might cause them to reappear:
       // - in git versions =< 2.13.0 the `--keep-index` flag resurrects deleted files
       // - git stash can't infer RD or MD states correctly, and will lose the deletion
-      this.deletedFiles = (await this.execGit(['ls-files', '--deleted']))
-        .split('\n')
-        .filter(Boolean)
-        .map(file => path.resolve(this.gitDir, file))
+      this.deletedFiles = await this.getDeletedFiles()
 
-      // Save stash of entire original state, including unstaged and untracked changes.
-      // `--keep-index leaves only staged files on disk, for tasks.`
-      await this.execGit(['stash', 'save', '--include-untracked', '--keep-index', STASH])
+      // the `git stash` clears metadata about a possible git merge
+      // Manually check and backup if necessary
+      await this.backupMergeStatus()
 
-      // Restore meta information about ongoing git merge
+      // Save stash of entire original state, including unstaged and untracked changes
+      await this.execGit(['stash', 'save', '--include-untracked', STASH])
+      await this.execGit(['stash', 'apply', '--quiet', '--index', await this.getBackupStash()])
+
+      // Restore meta information about ongoing git merge, cleared by `git stash`
       await this.restoreMergeStatus()
 
-      // There is a bug in git =< 2.13.0 where `--keep-index` resurrects deleted files.
-      // These files should be listed and deleted before proceeding.
-      await this.cleanUntrackedFiles()
-
-      // Get a diff of unstaged changes by diffing the saved stash against what's left on disk.
-      await this.execGit([
-        'diff',
-        ...GIT_DIFF_ARGS,
-        `--output=${this.getHiddenFilepath(PATCH_UNSTAGED)}`,
-        await this.getBackupStash(ctx),
-        '-R' // Show diff in reverse
-      ])
+      // If stashing resurrected deleted files, clean them out
+      await Promise.all(this.deletedFiles.map(file => unlink(file)))
 
       debug('Done backing up original state!')
     } catch (error) {
@@ -168,83 +212,72 @@ class GitWorkflow {
     }
   }
 
+  /**
+   * Remove unstaged changes to all partially staged files, to avoid tasks from seeing them
+   */
+  async hideUnstagedChanges(ctx) {
+    try {
+      const files = processRenames(this.partiallyStagedFiles, false)
+      await this.execGit(['checkout', '--force', '--', ...files])
+    } catch (error) {
+      /**
+       * `git checkout --force` doesn't throw errors, so it shouldn't be possible to get here.
+       * If this does fail, the handleError method will set ctx.gitError and lint-staged will fail.
+       */
+      ctx.gitHideUnstagedChangesError = true
+      handleError(error, ctx)
+    }
+  }
+
   /**
    * Applies back task modifications, and unstaged changes hidden in the stash.
    * In case of a merge-conflict retry with 3-way merge.
    */
   async applyModifications(ctx) {
-    const modifiedFiles = await this.execGit(['ls-files', '--modified'])
-    if (modifiedFiles) {
-      debug('Detected files modified by tasks:')
-      debug(modifiedFiles)
-      debug('Adding files to index...')
-      await Promise.all(
-        // stagedFileChunks includes staged files that lint-staged originally detected.
-        // Add only these files so any 3rd-party edits to other files won't be included in the commit.
-        this.stagedFileChunks.map(stagedFiles => this.execGit(['add', ...stagedFiles]))
-      )
-      debug('Done adding files to index!')
-    }
-
-    const modifiedFilesAfterAdd = await this.execGit(['status', '--porcelain'])
-    if (!modifiedFilesAfterAdd && !this.allowEmpty) {
+    debug('Adding task modifications to index...')
+    await Promise.all(
+      // stagedFileChunks includes staged files that lint-staged originally detected.
+      // Add only these files so any 3rd-party edits to other files won't be included in the commit.
+      this.stagedFileChunks.map(stagedFiles => this.execGit(['add', '--', ...stagedFiles]))
+    )
+    debug('Done adding task modifications to index!')
+
+    const stagedFilesAfterAdd = await this.execGit(['diff', '--name-only', '--cached'])
+    if (!stagedFilesAfterAdd && !this.allowEmpty) {
       // Tasks reverted all staged changes and the commit would be empty
       // Throw error to stop commit unless `--allow-empty` was used
-      ctx.gitApplyEmptyCommit = true
+      ctx.gitApplyEmptyCommitError = true
       handleError(new Error('Prevented an empty git commit!'), ctx)
     }
+  }
 
-    // Restore unstaged changes by applying the diff back. If it at first fails,
-    // this is probably because of conflicts between task modifications.
-    // 3-way merge usually fixes this, and in case it doesn't we should just give up and throw.
-    if (await this.hasPatch(PATCH_UNSTAGED)) {
-      debug('Restoring unstaged changes...')
-      const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
-      try {
-        await this.execGit([...GIT_APPLY_ARGS, unstagedPatch])
-      } 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([...GIT_APPLY_ARGS, '--3way', unstagedPatch])
-        } catch (error2) {
-          debug('Error while restoring unstaged changes using 3-way merge:')
-          debug(error2)
-          ctx.gitApplyModificationsError = true
-          handleError(
-            new Error('Unstaged changes could not be restored due to a merge conflict!'),
-            ctx
-          )
-        }
-      }
-      debug('Done restoring unstaged changes!')
-    }
-
-    // Restore untracked files by reading from the third commit associated with the backup stash
-    // See https://stackoverflow.com/a/52357762
+  /**
+   * Restore unstaged changes to partially changed files. If it at first fails,
+   * this is probably because of conflicts between new task modifications.
+   * 3-way merge usually fixes this, and in case it doesn't we should just give up and throw.
+   */
+  async restoreUnstagedChanges(ctx) {
+    debug('Restoring unstaged changes...')
+    const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
     try {
-      const backupStash = await this.getBackupStash(ctx)
-      const untrackedPatch = this.getHiddenFilepath(PATCH_UNTRACKED)
-      await this.execGit([
-        'show',
-        ...GIT_DIFF_ARGS,
-        '--format=%b',
-        `--output=${untrackedPatch}`,
-        `${backupStash}^3`
-      ])
-      if (await this.hasPatch(PATCH_UNTRACKED)) {
-        await this.execGit([...GIT_APPLY_ARGS, untrackedPatch])
+      await this.execGit(['apply', ...GIT_APPLY_ARGS, unstagedPatch])
+    } catch (applyError) {
+      debug('Error while restoring changes:')
+      debug(applyError)
+      debug('Retrying with 3-way merge')
+      try {
+        // Retry with a 3-way merge if normal apply fails
+        await this.execGit(['apply', ...GIT_APPLY_ARGS, '--3way', unstagedPatch])
+      } catch (threeWayApplyError) {
+        debug('Error while restoring unstaged changes using 3-way merge:')
+        debug(threeWayApplyError)
+        ctx.gitRestoreUnstagedChangesError = true
+        handleError(
+          new Error('Unstaged changes could not be restored due to a merge conflict!'),
+          ctx
+        )
       }
-    } catch (error) {
-      ctx.gitRestoreUntrackedError = true
-      handleError(error, ctx)
     }
-
-    // If stashing resurrected deleted files, clean them out
-    await Promise.all(this.deletedFiles.map(file => unlink(file)))
   }
 
   /**
@@ -253,16 +286,19 @@ class GitWorkflow {
   async restoreOriginalState(ctx) {
     try {
       debug('Restoring original state...')
-      const backupStash = await this.getBackupStash(ctx)
       await this.execGit(['reset', '--hard', 'HEAD'])
-      await this.execGit(['stash', 'apply', '--quiet', '--index', backupStash])
-      debug('Done restoring original state!')
+      await this.execGit(['stash', 'apply', '--quiet', '--index', await this.getBackupStash(ctx)])
+
+      // Restore meta information about ongoing git merge
+      await this.restoreMergeStatus()
 
       // If stashing resurrected deleted files, clean them out
       await Promise.all(this.deletedFiles.map(file => unlink(file)))
 
-      // Restore meta information about ongoing git merge
-      await this.restoreMergeStatus()
+      // Clean out patch
+      if (this.partiallyStagedFiles) await unlink(PATCH_UNSTAGED)
+
+      debug('Done restoring original state!')
     } catch (error) {
       ctx.gitRestoreOriginalStateError = true
       handleError(error, ctx)
@@ -272,15 +308,10 @@ class GitWorkflow {
   /**
    * Drop the created stashes after everything has run
    */
-  async dropBackup(ctx) {
+  async cleanup(ctx) {
     try {
       debug('Dropping backup stash...')
-      await Promise.all([
-        exists(this.getHiddenFilepath(PATCH_UNSTAGED)).then(unlink),
-        exists(this.getHiddenFilepath(PATCH_UNTRACKED)).then(unlink)
-      ])
-      const backupStash = await this.getBackupStash(ctx)
-      await this.execGit(['stash', 'drop', '--quiet', backupStash])
+      await this.execGit(['stash', 'drop', '--quiet', await this.getBackupStash(ctx)])
       debug('Done dropping backup stash!')
     } catch (error) {
       handleError(error, ctx)

package/lib/index.js

@@ -46,12 +46,12 @@ function loadConfig(configPath) {
  * @param {boolean | number} [options.concurrent] - The number of tasks to run concurrently, or false to run tasks serially
  * @param {object}  [options.config] - Object with configuration for programmatic API
  * @param {string} [options.configPath] - Path to configuration file
+ * @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
  * @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 {boolean} [options.stash] - Enable the backup stash, and revert in case of errors
  * @param {Logger} [logger]
  *
  * @returns {Promise<boolean>} Promise of whether the linting passed or failed
@@ -62,11 +62,12 @@ module.exports = async function lintStaged(
     concurrent = true,
     config: configObject,
     configPath,
+    debug = false,
     maxArgLength,
+    quiet = false,
     relative = false,
     shell = false,
-    quiet = false,
-    debug = false
+    stash = true
   } = {},
   logger = console
 ) {
@@ -92,9 +93,13 @@ module.exports = async function lintStaged(
       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 {
       await runAll(
-        { allowEmpty, concurrent, config, debug, maxArgLength, quiet, relative, shell },
+        { allowEmpty, concurrent, config, debug, maxArgLength, stash, quiet, relative, shell },
         logger
       )
       debugLog('tasks were executed successfully!')

package/lib/resolveGitRepo.js

@@ -16,7 +16,7 @@ const fsLstat = promisify(fs.lstat)
  * submodules and worktrees
  */
 const resolveGitConfigDir = async gitDir => {
-  const defaultDir = path.resolve(gitDir, '.git')
+  const defaultDir = normalize(path.join(gitDir, '.git'))
   const stats = await fsLstat(defaultDir)
   // If .git is a directory, use it
   if (stats.isDirectory()) return defaultDir
@@ -31,9 +31,9 @@ const resolveGitConfigDir = async gitDir => {
 const resolveGitRepo = async cwd => {
   try {
     debugLog('Resolving git repo from `%s`', cwd)
-    // git cli uses GIT_DIR to fast track its response however it might be set to a different path
-    // depending on where the caller initiated this from, hence clear GIT_DIR
-    debugLog('Deleting GIT_DIR from env with value `%s`', process.env.GIT_DIR)
+
+    // Unset GIT_DIR before running any git operations in case it's pointing to an incorrect location
+    debugLog('Unset GIT_DIR (was `%s`)', process.env.GIT_DIR)
     delete process.env.GIT_DIR
 
     const gitDir = normalize(await execGit(['rev-parse', '--show-toplevel'], { cwd }))

package/lib/runAll.js

@@ -41,14 +41,14 @@ const shouldSkipApplyModifications = ctx => {
 
 const shouldSkipRevert = ctx => {
   // Should be skipped in case of unknown git errors
-  if (ctx.gitError && !ctx.gitApplyEmptyCommit && !ctx.gitApplyModificationsError) {
+  if (ctx.gitError && !ctx.gitApplyEmptyCommitError && !ctx.gitRestoreUnstagedChangesError) {
     return MESSAGES.GIT_ERROR
   }
 }
 
 const shouldSkipCleanup = ctx => {
   // Should be skipped in case of unknown git errors
-  if (ctx.gitError && !ctx.gitApplyEmptyCommit && !ctx.gitApplyModificationsError) {
+  if (ctx.gitError && !ctx.gitApplyEmptyCommitError && !ctx.gitRestoreUnstagedChangesError) {
     return MESSAGES.GIT_ERROR
   }
   // Should be skipped when reverting to original state fails
@@ -62,20 +62,22 @@ const shouldSkipCleanup = ctx => {
  *
  * @param {object} options
  * @param {Object} [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 {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
  * @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 {boolean} [options.stash] - Enable the backup stash, and revert in case of errors
  * @param {Logger} logger
  * @returns {Promise}
  */
 const runAll = async (
   {
     allowEmpty = false,
+    concurrent = true,
     config,
     cwd = process.cwd(),
     debug = false,
@@ -83,12 +85,18 @@ const runAll = async (
     quiet = false,
     relative = false,
     shell = false,
-    concurrent = true
+    stash = true
   },
   logger = console
 ) => {
   debugLog('Running all linter scripts')
 
+  if (!stash) {
+    logger.warn(
+      `${symbols.warning} ${chalk.yellow('Skipping backup because `--no-stash` was used.')}`
+    )
+  }
+
   const { gitDir, gitConfigDir } = await resolveGitRepo(cwd)
   if (!gitDir) throw new Error('Current directory is not a git directory!')
 
@@ -98,8 +106,7 @@ const runAll = async (
 
   // If there are no files avoid executing any lint-staged logic
   if (files.length === 0) {
-    logger.log('No staged files found.')
-    return 'No tasks to run.'
+    return logger.log(`${symbols.info} No staged files found.`)
   }
 
   const stagedFileChunks = chunkFiles({ files, gitDir, maxArgLength, relative })
@@ -189,23 +196,38 @@ const runAll = async (
     [
       {
         title: 'Preparing...',
-        task: ctx => git.stashBackup(ctx)
+        task: ctx => git.prepare(ctx, stash)
+      },
+      {
+        title: 'Hiding unstaged changes to partially staged files...',
+        task: ctx => git.hideUnstagedChanges(ctx),
+        enabled: ctx => ctx.hasPartiallyStagedFiles
       },
       ...listrTasks,
       {
         title: 'Applying modifications...',
         task: ctx => git.applyModifications(ctx),
+        // Always apply back unstaged modifications when skipping backup
+        skip: ctx => stash && shouldSkipApplyModifications(ctx)
+      },
+      {
+        title: 'Restoring unstaged changes to partially staged files...',
+        task: ctx => git.restoreUnstagedChanges(ctx),
+        enabled: ctx => ctx.hasPartiallyStagedFiles,
         skip: shouldSkipApplyModifications
       },
       {
-        title: 'Reverting to original state...',
+        title: 'Reverting to original state because of errors...',
         task: ctx => git.restoreOriginalState(ctx),
-        enabled: ctx => ctx.taskError || ctx.gitApplyEmptyCommit || ctx.gitApplyModificationsError,
+        enabled: ctx =>
+          stash &&
+          (ctx.taskError || ctx.gitApplyEmptyCommitError || ctx.gitRestoreUnstagedChangesError),
         skip: shouldSkipRevert
       },
       {
         title: 'Cleaning up...',
-        task: ctx => git.dropBackup(ctx),
+        task: ctx => git.cleanup(ctx),
+        enabled: () => stash,
         skip: shouldSkipCleanup
       }
     ],
@@ -215,7 +237,7 @@ const runAll = async (
   try {
     await runner.run({})
   } catch (error) {
-    if (error.context.gitApplyEmptyCommit) {
+    if (error.context.gitApplyEmptyCommitError) {
       logger.warn(`
   ${symbols.warning} ${chalk.yellow(`lint-staged prevented an empty git commit.
     Use the --allow-empty option to continue, or check your task configuration`)}
@@ -228,7 +250,7 @@ const runAll = async (
           `\n    The initial commit is needed for lint-staged to work.
     Please use the --no-verify flag to skip running lint-staged.`
         )
-      } else {
+      } else if (stash) {
         // No sense to show this if the backup stash itself is missing.
         logger.error(`  Any lost modifications can be restored from a git stash:
 

package/package.json

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