lint-staged 11.2.0-beta.1 → 11.2.3

package/README.md

@@ -65,7 +65,8 @@ Options:
                                      (default: false)
   -c, --config [path]                path to configuration file, or - to read from stdin
   -d, --debug                        print additional debug information (default: false)
-  --no-reset                         do not reset changes in case of errors
+  --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)
@@ -86,7 +87,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-reset`**: 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.
+- **`--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. To use a specific shell, use a path like `--shell "/bin/bash"`.
@@ -564,8 +565,8 @@ const success = await lintStaged({
   maxArgLength: null,
   quiet: false,
   relative: false,
-  reset: true,
   shell: false
+  stash: true,
   verbose: false
 })
 ```
@@ -582,8 +583,8 @@ const success = await lintStaged({
   maxArgLength: null,
   quiet: false,
   relative: false,
-  reset: true,
   shell: false,
+  stash: true,
   verbose: false,
 })
 ```

package/bin/lint-staged.js

@@ -22,22 +22,19 @@ require('please-upgrade-node')(
   })
 )
 
-const { Command, Option } = require('commander')
+const cmdline = require('commander')
 const debugLib = require('debug')
 const lintStaged = require('../lib')
 const { CONFIG_STDIN_ERROR } = require('../lib/messages')
 
 const debug = debugLib('lint-staged:bin')
 
-const program = new Command('lint-staged')
-
-program.version(pkg.version)
-
-program
+cmdline
+  .version(pkg.version)
   .option('--allow-empty', 'allow empty commits when tasks revert all staged changes', false)
   .option('-c, --config [path]', 'path to configuration file, or - to read from stdin')
   .option('-d, --debug', 'print additional debug information', false)
-  .option('--no-reset', 'do not reset changes in case of errors', 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',
@@ -51,13 +48,9 @@ program
     'show task output even when tasks succeed; by default only failed output is shown',
     false
   )
+  .parse(process.argv)
 
-// Added for backwards-compatibility
-program.addOption(new Option('--no-stash').hideHelp())
-
-program.parse(process.argv)
-
-if (program.debug) {
+if (cmdline.debug) {
   debugLib.enable('lint-staged*')
 }
 
@@ -81,20 +74,19 @@ const getMaxArgLength = () => {
   }
 }
 
-const programOpts = program.opts()
+const cmdlineOptions = cmdline.opts()
 
 const options = {
-  allowEmpty: !!programOpts.allowEmpty,
-  concurrent: JSON.parse(programOpts.concurrent),
-  configPath: programOpts.config,
-  debug: !!programOpts.debug,
+  allowEmpty: !!cmdlineOptions.allowEmpty,
+  concurrent: JSON.parse(cmdlineOptions.concurrent),
+  configPath: cmdlineOptions.config,
+  debug: !!cmdlineOptions.debug,
   maxArgLength: getMaxArgLength() / 2,
-  quiet: !!programOpts.quiet,
-  relative: !!programOpts.relative,
-  reset: !!programOpts.reset, // commander inverts `no-<x>` flags to `!x`
-  shell: programOpts.shell /* Either a boolean or a string pointing to the shell */,
-  stash: programOpts.stash /** kept for backwards-compatibility */,
-  verbose: !!programOpts.verbose,
+  stash: !!cmdlineOptions.stash, // commander inverts `no-<x>` flags to `!x`
+  quiet: !!cmdlineOptions.quiet,
+  relative: !!cmdlineOptions.relative,
+  shell: cmdlineOptions.shell /* Either a boolean or a string pointing to the shell */,
+  verbose: !!cmdlineOptions.verbose,
 }
 
 debug('Options parsed from command-line:', options)

package/lib/file.js

@@ -0,0 +1,63 @@
+'use strict'
+
+const debug = require('debug')('lint-staged:file')
+const fs = require('fs')
+const { promisify } = require('util')
+
+const fsReadFile = promisify(fs.readFile)
+const fsUnlink = promisify(fs.unlink)
+const fsWriteFile = promisify(fs.writeFile)
+
+/**
+ * Read contents of a file to buffer
+ * @param {String} filename
+ * @param {Boolean} [ignoreENOENT=true] — Whether to throw if the file doesn't exist
+ * @returns {Promise<Buffer>}
+ */
+const readFile = async (filename, ignoreENOENT = true) => {
+  debug('Reading file `%s`', filename)
+  try {
+    return await fsReadFile(filename)
+  } catch (error) {
+    if (ignoreENOENT && error.code === 'ENOENT') {
+      debug("File `%s` doesn't exist, ignoring...", filename)
+      return null // no-op file doesn't exist
+    } else {
+      throw error
+    }
+  }
+}
+
+/**
+ * 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) => {
+  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
+    }
+  }
+}
+
+/**
+ * Write buffer to file
+ * @param {String} filename
+ * @param {Buffer} buffer
+ */
+const writeFile = async (filename, buffer) => {
+  debug('Writing file `%s`', filename)
+  await fsWriteFile(filename, buffer)
+}
+
+module.exports = {
+  readFile,
+  unlink,
+  writeFile,
+}

package/lib/gitWorkflow.js

@@ -1,21 +1,19 @@
 'use strict'
 
 const debug = require('debug')('lint-staged:git')
-const fs = require('fs')
 const path = require('path')
-const { promisify } = require('util')
 
 const execGit = require('./execGit')
+const { readFile, unlink, writeFile } = require('./file')
 const {
   GitError,
+  RestoreOriginalStateError,
   ApplyEmptyCommitError,
+  GetBackupStashError,
   HideUnstagedChangesError,
-  RestoreOriginalStateError,
+  RestoreMergeStatusError,
   RestoreUnstagedChangesError,
 } = require('./symbols')
-const unlink = require('./unlink')
-
-const fsReadFile = promisify(fs.readFile)
 
 const MERGE_HEAD = 'MERGE_HEAD'
 const MERGE_MODE = 'MERGE_MODE'
@@ -43,8 +41,9 @@ const processRenames = (files, includeRenameFrom = true) =>
     return flattened
   }, [])
 
+const STASH = 'lint-staged automatic backup'
+
 const PATCH_UNSTAGED = 'lint-staged_unstaged.patch'
-const PATCH_PARTIAL = 'lint-staged_partial.patch'
 
 const GIT_DIFF_ARGS = [
   '--binary', // support binary files
@@ -91,6 +90,69 @@ class GitWorkflow {
     return path.resolve(this.gitConfigDir, `./${filename}`)
   }
 
+  /**
+   * Get name of backup stash
+   */
+  async getBackupStash(ctx) {
+    const stashes = await this.execGit(['stash', 'list'])
+    const index = stashes.split('\n').findIndex((line) => line.includes(STASH))
+    if (index === -1) {
+      ctx.errors.add(GetBackupStashError)
+      throw new Error('lint-staged automatic backup is missing!')
+    }
+    return `refs/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
+   */
+  async backupMergeStatus() {
+    debug('Backing up merge state...')
+    await Promise.all([
+      readFile(this.mergeHeadFilename).then((buffer) => (this.mergeHeadBuffer = buffer)),
+      readFile(this.mergeModeFilename).then((buffer) => (this.mergeModeBuffer = buffer)),
+      readFile(this.mergeMsgFilename).then((buffer) => (this.mergeMsgBuffer = buffer)),
+    ])
+    debug('Done backing up merge state!')
+  }
+
+  /**
+   * Restore meta information about ongoing git merge
+   */
+  async restoreMergeStatus(ctx) {
+    debug('Restoring merge state...')
+    try {
+      await Promise.all([
+        this.mergeHeadBuffer && writeFile(this.mergeHeadFilename, this.mergeHeadBuffer),
+        this.mergeModeBuffer && writeFile(this.mergeModeFilename, this.mergeModeBuffer),
+        this.mergeMsgBuffer && writeFile(this.mergeMsgFilename, this.mergeMsgBuffer),
+      ])
+      debug('Done restoring merge state!')
+    } catch (error) {
+      debug('Failed restoring merge state with error:')
+      debug(error)
+      handleError(
+        new Error('Merge state could not be restored due to an error!'),
+        ctx,
+        RestoreMergeStatusError
+      )
+    }
+  }
+
   /**
    * Get a list of all files with both staged and unstaged modifications.
    * Renames have special treatment, since the single status line includes
@@ -122,28 +184,44 @@ class GitWorkflow {
   }
 
   /**
-   * Create a diff of partially staged files.
+   * Create a diff of partially staged files and backup stash if enabled.
    */
   async prepare(ctx) {
     try {
       debug('Backing up original state...')
 
-      const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
-      await this.execGit(['diff', ...GIT_DIFF_ARGS, '--output', unstagedPatch])
-
       // 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 partialPatch = this.getHiddenFilepath(PATCH_PARTIAL)
+        const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
         const files = processRenames(this.partiallyStagedFiles)
-        await this.execGit(['diff', ...GIT_DIFF_ARGS, '--output', partialPatch, '--', ...files])
+        await this.execGit(['diff', ...GIT_DIFF_ARGS, '--output', unstagedPatch, '--', ...files])
       } else {
         ctx.hasPartiallyStagedFiles = false
       }
 
+      /**
+       * If backup stash should be skipped, no need to continue
+       */
+      if (!ctx.shouldBackup) return
+
+      // When backup is enabled, the revert will clear ongoing merge status.
+      await this.backupMergeStatus()
+
+      // Get a list of unstaged deleted files, because certain bugs might cause them to reappear:
+      // - in git versions =< 2.13.0 the `git stash --keep-index` option resurrects deleted files
+      // - git stash can't infer RD or MD states correctly, and will lose the deletion
+      this.deletedFiles = await this.getDeletedFiles()
+
+      // Save stash of all staged files.
+      // The `stash create` command creates a dangling commit without removing any files,
+      // and `stash store` saves it as an actual stash.
+      const hash = await this.execGit(['stash', 'create'])
+      await this.execGit(['stash', 'store', '--quiet', '--message', STASH, hash])
+
       debug('Done backing up original state!')
     } catch (error) {
       handleError(error, ctx)
@@ -166,19 +244,13 @@ class GitWorkflow {
     }
   }
 
-  /** Add all task modifications to index for files that were staged before running. */
+  /**
+   * 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) {
     debug('Adding task modifications to index...')
 
-    if (ctx.hasInitialCommit) {
-      const stagedFilesAfterAdd = await this.execGit(['diff', 'HEAD'])
-      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
-        handleError(new Error('Prevented an empty git commit!'), ctx, ApplyEmptyCommitError)
-      }
-    }
-
     // `matchedFileChunks` includes staged files that lint-staged originally detected and matched against a task.
     // Add only these files so any 3rd-party edits to other files won't be included in the commit.
     // These additions per chunk are run "serially" to prevent race conditions.
@@ -188,25 +260,12 @@ class GitWorkflow {
     }
 
     debug('Done adding task modifications to index!')
-  }
-
-  /**
-   * Restore original HEAD state in case of errors
-   */
-  async restoreOriginalState(ctx) {
-    try {
-      debug('Restoring original state...')
-      await this.execGit(['checkout', '--force', '--', '.'])
 
-      const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
-      const hasContents = !!(await fsReadFile(unstagedPatch)).toString()
-      if (hasContents) {
-        await this.execGit(['apply', ...GIT_APPLY_ARGS, unstagedPatch])
-      }
-
-      debug('Done restoring original state!')
-    } catch (error) {
-      handleError(error, ctx, RestoreOriginalStateError)
+    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
+      handleError(new Error('Prevented an empty git commit!'), ctx, ApplyEmptyCommitError)
     }
   }
 
@@ -215,18 +274,18 @@ class GitWorkflow {
    * 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 restorePartialChanges(ctx) {
+  async restoreUnstagedChanges(ctx) {
     debug('Restoring unstaged changes...')
-    const partialPatch = this.getHiddenFilepath(PATCH_PARTIAL)
+    const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
     try {
-      await this.execGit(['apply', ...GIT_APPLY_ARGS, partialPatch])
+      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', partialPatch])
+        await this.execGit(['apply', ...GIT_APPLY_ARGS, '--3way', unstagedPatch])
       } catch (threeWayApplyError) {
         debug('Error while restoring unstaged changes using 3-way merge:')
         debug(threeWayApplyError)
@@ -240,14 +299,40 @@ class GitWorkflow {
   }
 
   /**
-   * Drop the created diff file after everything has run.
-   * Won't throw if the file has already been deleted (theoretically).
+   * Restore original HEAD state in case of errors
+   */
+  async restoreOriginalState(ctx) {
+    try {
+      debug('Restoring original state...')
+      await this.execGit(['reset', '--hard', 'HEAD'])
+      await this.execGit(['stash', 'apply', '--quiet', '--index', await this.getBackupStash(ctx)])
+
+      // Restore meta information about ongoing git merge
+      await this.restoreMergeStatus(ctx)
+
+      // If stashing resurrected deleted files, clean them out
+      await Promise.all(this.deletedFiles.map((file) => unlink(file)))
+
+      // Clean out patch
+      await unlink(this.getHiddenFilepath(PATCH_UNSTAGED))
+
+      debug('Done restoring original state!')
+    } catch (error) {
+      handleError(error, ctx, RestoreOriginalStateError)
+    }
+  }
+
+  /**
+   * Drop the created stashes after everything has run
    */
-  async cleanup() {
-    debug('Removing temp files...')
-    await unlink(this.getHiddenFilepath(PATCH_UNSTAGED))
-    await unlink(this.getHiddenFilepath(PATCH_PARTIAL))
-    debug('Done removing temp files!')
+  async cleanup(ctx) {
+    try {
+      debug('Dropping backup stash...')
+      await this.execGit(['stash', 'drop', '--quiet', await this.getBackupStash(ctx)])
+      debug('Done dropping backup stash!')
+    } catch (error) {
+      handleError(error, ctx)
+    }
   }
 }
 

package/lib/index.js

@@ -4,10 +4,15 @@ const { cosmiconfig } = require('cosmiconfig')
 const debugLog = require('debug')('lint-staged')
 const stringifyObject = require('stringify-object')
 
-const { PREVENTED_EMPTY_COMMIT, GIT_ERROR } = require('./messages')
+const { PREVENTED_EMPTY_COMMIT, GIT_ERROR, RESTORE_STASH_EXAMPLE } = require('./messages')
 const printTaskOutput = require('./printTaskOutput')
 const runAll = require('./runAll')
-const { ApplyEmptyCommitError, ConfigNotFoundError, GitError } = require('./symbols')
+const {
+  ApplyEmptyCommitError,
+  ConfigNotFoundError,
+  GetBackupStashError,
+  GitError,
+} = require('./symbols')
 const validateConfig = require('./validateConfig')
 const validateOptions = require('./validateOptions')
 
@@ -53,8 +58,8 @@ const loadConfig = (configPath) => {
  * @param {number} [options.maxArgLength] - Maximum argument string length
  * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
  * @param {boolean} [options.relative] - Pass relative filepaths to tasks
- * @param {boolean} [options.reset] - Reset changes in case of errors
  * @param {boolean|string} [options.shell] - Skip parsing of tasks for better shell support
+ * @param {boolean} [options.stash] - Enable the backup stash, and revert in case of errors
  * @param {boolean} [options.verbose] - Show task output even when tasks succeed; by default only failed output is shown
  * @param {Logger} [logger]
  *
@@ -71,14 +76,13 @@ const lintStaged = async (
     maxArgLength,
     quiet = false,
     relative = false,
-    reset = true,
     shell = false,
-    stash, // kept for backwards-compatibility
+    stash = true,
     verbose = false,
   } = {},
   logger = console
 ) => {
-  await validateOptions({ shell, stash }, logger)
+  await validateOptions({ shell }, logger)
 
   debugLog('Loading config using `cosmiconfig`')
 
@@ -122,8 +126,8 @@ const lintStaged = async (
         maxArgLength,
         quiet,
         relative,
-        reset: reset || !!stash,
         shell,
+        stash,
         verbose,
       },
       logger
@@ -136,8 +140,12 @@ const lintStaged = async (
       const { ctx } = runAllError
       if (ctx.errors.has(ApplyEmptyCommitError)) {
         logger.warn(PREVENTED_EMPTY_COMMIT)
-      } else if (ctx.errors.has(GitError)) {
+      } else if (ctx.errors.has(GitError) && !ctx.errors.has(GetBackupStashError)) {
         logger.error(GIT_ERROR)
+        if (ctx.shouldBackup) {
+          // No sense to show this if the backup stash itself is missing.
+          logger.error(RESTORE_STASH_EXAMPLE)
+        }
       }
 
       printTaskOutput(ctx, logger)

package/lib/messages.js

@@ -28,9 +28,9 @@ const NO_STAGED_FILES = `${info} No staged files found.`
 
 const NO_TASKS = `${info} No staged files match any configured task.`
 
-const skippingReset = (hasInitialCommit) => {
-  const reason = hasInitialCommit ? '`--no-reset` was used' : 'there’s no initial commit yet'
-  return yellow(`${warning} Changes won't be reset because ${reason}.\n`)
+const skippingBackup = (hasInitialCommit) => {
+  const reason = hasInitialCommit ? '`--no-stash` was used' : 'there’s no initial commit yet'
+  return yellow(`${warning} Skipping backup because ${reason}.\n`)
 }
 
 const DEPRECATED_GIT_ADD = yellow(
@@ -38,11 +38,6 @@ const DEPRECATED_GIT_ADD = yellow(
 `
 )
 
-const DEPRECATED_NO_STASH = yellow(
-  `${warning} The \`--no-stash\` option has been renamed to \`--no-reset\`.
-`
-)
-
 const TASK_ERROR = 'Skipped because of errors from tasks.'
 
 const SKIPPED_GIT_ERROR = 'Skipped because of previous git error.'
@@ -62,13 +57,19 @@ const PREVENTED_EMPTY_COMMIT = `
   Use the --allow-empty option to continue, or check your task configuration`)}
 `
 
+const RESTORE_STASH_EXAMPLE = `  Any lost modifications can be restored from a git stash:
+
+    > git stash list
+    stash@{0}: automatic lint-staged backup
+    > git stash apply --index stash@{0}
+`
+
 const CONFIG_STDIN_ERROR = 'Error: Could not read config from stdin.'
 
 module.exports = {
   CONFIG_STDIN_ERROR,
   configurationError,
   DEPRECATED_GIT_ADD,
-  DEPRECATED_NO_STASH,
   FAILED_GET_STAGED_FILES,
   GIT_ERROR,
   incorrectBraces,
@@ -77,7 +78,8 @@ module.exports = {
   NO_TASKS,
   NOT_GIT_REPO,
   PREVENTED_EMPTY_COMMIT,
+  RESTORE_STASH_EXAMPLE,
   SKIPPED_GIT_ERROR,
-  skippingReset,
+  skippingBackup,
   TASK_ERROR,
 }

package/lib/resolveGitRepo.js

@@ -7,9 +7,9 @@ const path = require('path')
 const { promisify } = require('util')
 
 const execGit = require('./execGit')
+const { readFile } = require('./file')
 
 const fsLstat = promisify(fs.lstat)
-const fsReadFile = promisify(fs.readFile)
 
 /**
  * Resolve path to the .git directory, with special handling for
@@ -21,14 +21,29 @@ const resolveGitConfigDir = async (gitDir) => {
   // If .git is a directory, use it
   if (stats.isDirectory()) return defaultDir
   // Otherwise .git is a file containing path to real location
-  const file = (await fsReadFile(defaultDir)).toString()
+  const file = (await readFile(defaultDir)).toString()
   return path.resolve(gitDir, file.replace(/^gitdir: /, '')).trim()
 }
 
+const determineGitDir = (cwd, relativeDir) => {
+  // if relative dir and cwd have different endings normalize it
+  // this happens under windows, where normalize is unable to normalize git's output
+  if (relativeDir && relativeDir.endsWith(path.sep)) {
+    relativeDir = relativeDir.slice(0, -1)
+  }
+  if (relativeDir) {
+    // the current working dir is inside the git top-level directory
+    return normalize(cwd.substring(0, cwd.lastIndexOf(relativeDir)))
+  } else {
+    // the current working dir is the top-level git directory
+    return normalize(cwd)
+  }
+}
+
 /**
  * Resolve git directory and possible submodule paths
  */
-const resolveGitRepo = async (cwd) => {
+const resolveGitRepo = async (cwd = process.cwd()) => {
   try {
     debugLog('Resolving git repo from `%s`', cwd)
 
@@ -38,7 +53,10 @@ const resolveGitRepo = async (cwd) => {
     debugLog('Unset GIT_WORK_TREE (was `%s`)', process.env.GIT_WORK_TREE)
     delete process.env.GIT_WORK_TREE
 
-    const gitDir = normalize(await execGit(['rev-parse', '--show-toplevel'], { cwd }))
+    // read the path of the current directory relative to the top-level directory
+    // don't read the toplevel directly, it will lead to an posix conform path on non posix systems (cygwin)
+    const gitRel = normalize(await execGit(['rev-parse', '--show-prefix']))
+    const gitDir = determineGitDir(normalize(cwd), gitRel)
     const gitConfigDir = normalize(await resolveGitConfigDir(gitDir))
 
     debugLog('Resolved git directory to be `%s`', gitDir)
@@ -52,3 +70,6 @@ const resolveGitRepo = async (cwd) => {
 }
 
 module.exports = resolveGitRepo
+
+// exported for test
+module.exports.determineGitDir = determineGitDir

package/lib/runAll.js

@@ -19,7 +19,7 @@ const {
   NO_STAGED_FILES,
   NO_TASKS,
   SKIPPED_GIT_ERROR,
-  skippingReset,
+  skippingBackup,
 } = require('./messages')
 const resolveGitRepo = require('./resolveGitRepo')
 const {
@@ -30,7 +30,7 @@ const {
   hasPartiallyStagedFiles,
   restoreOriginalStateEnabled,
   restoreOriginalStateSkipped,
-  restorePartialChangesSkipped,
+  restoreUnstagedChangesSkipped,
 } = require('./state')
 const { GitRepoError, GetStagedFilesError, GitError } = require('./symbols')
 
@@ -48,8 +48,8 @@ const createError = (ctx) => Object.assign(new Error('lint-staged failed'), { ct
  * @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.reset] - Reset changes in case of errors
  * @param {boolean} [options.shell] - Skip parsing of tasks for better shell support
+ * @param {boolean} [options.stash] - Enable the backup stash, and revert in case of errors
  * @param {boolean} [options.verbose] - Show task output even when tasks succeed; by default only failed output is shown
  * @param {Logger} logger
  * @returns {Promise}
@@ -64,8 +64,8 @@ const runAll = async (
     maxArgLength,
     quiet = false,
     relative = false,
-    reset = true,
     shell = false,
+    stash = true,
     verbose = false,
   },
   logger = console
@@ -87,11 +87,10 @@ const runAll = async (
     .then(() => true)
     .catch(() => false)
 
-  // Lint-staged should reset changes when errors happen only when there's an initial commit
-  ctx.hasInitialCommit = hasInitialCommit
-  ctx.shouldReset = hasInitialCommit && reset
-  if (!ctx.shouldReset) {
-    logger.warn(skippingReset(hasInitialCommit))
+  // Lint-staged should create a backup stash only when there's an initial commit
+  ctx.shouldBackup = hasInitialCommit && stash
+  if (!ctx.shouldBackup) {
+    logger.warn(skippingBackup(hasInitialCommit))
   }
 
   const files = await getStagedFiles({ cwd: gitDir })
@@ -226,20 +225,20 @@ const runAll = async (
         skip: applyModificationsSkipped,
       },
       {
-        title: 'Reverting because of errors...',
+        title: 'Restoring unstaged changes to partially staged files...',
+        task: (ctx) => git.restoreUnstagedChanges(ctx),
+        enabled: hasPartiallyStagedFiles,
+        skip: restoreUnstagedChangesSkipped,
+      },
+      {
+        title: 'Reverting to original state because of errors...',
         task: (ctx) => git.restoreOriginalState(ctx),
         enabled: restoreOriginalStateEnabled,
         skip: restoreOriginalStateSkipped,
       },
-      {
-        title: 'Restoring partial changes...',
-        task: (ctx) => git.restorePartialChanges(ctx),
-        enabled: hasPartiallyStagedFiles,
-        skip: restorePartialChangesSkipped,
-      },
       {
         title: 'Cleaning up...',
-        task: () => git.cleanup(),
+        task: (ctx) => git.cleanup(ctx),
         enabled: cleanupEnabled,
         skip: cleanupSkipped,
       },

package/lib/state.js

@@ -4,13 +4,14 @@ const { GIT_ERROR, TASK_ERROR } = require('./messages')
 const {
   ApplyEmptyCommitError,
   TaskError,
+  RestoreOriginalStateError,
   GitError,
   RestoreUnstagedChangesError,
 } = require('./symbols')
 
 const getInitialState = ({ quiet = false } = {}) => ({
   hasPartiallyStagedFiles: null,
-  shouldReset: null,
+  shouldBackup: null,
   errors: new Set([]),
   output: [],
   quiet,
@@ -20,41 +21,34 @@ const hasPartiallyStagedFiles = (ctx) => ctx.hasPartiallyStagedFiles
 
 const applyModificationsSkipped = (ctx) => {
   // Always apply back unstaged modifications when skipping backup
-  if (!ctx.shouldReset) return false
-
+  if (!ctx.shouldBackup) return false
   // Should be skipped in case of git errors
   if (ctx.errors.has(GitError)) {
     return GIT_ERROR
   }
-
   // Should be skipped when tasks fail
   if (ctx.errors.has(TaskError)) {
     return TASK_ERROR
   }
 }
 
-const restorePartialChangesSkipped = (ctx) => {
-  // Should be skipped when entire state has already been restored
-  if (restoreOriginalStateEnabled(ctx)) {
-    return TASK_ERROR
-  }
-
+const restoreUnstagedChangesSkipped = (ctx) => {
   // Should be skipped in case of git errors
   if (ctx.errors.has(GitError)) {
     return GIT_ERROR
   }
-}
-
-const restoreOriginalStateEnabled = (ctx) => {
-  if (ctx.shouldReset && ctx.errors.has(TaskError)) {
+  // Should be skipped when tasks fail
+  if (ctx.errors.has(TaskError)) {
     return TASK_ERROR
   }
-
-  if (ctx.errors.has(ApplyEmptyCommitError)) {
-    return true
-  }
 }
 
+const restoreOriginalStateEnabled = (ctx) =>
+  ctx.shouldBackup &&
+  (ctx.errors.has(TaskError) ||
+    ctx.errors.has(ApplyEmptyCommitError) ||
+    ctx.errors.has(RestoreUnstagedChangesError))
+
 const restoreOriginalStateSkipped = (ctx) => {
   // Should be skipped in case of unknown git errors
   if (
@@ -66,7 +60,7 @@ const restoreOriginalStateSkipped = (ctx) => {
   }
 }
 
-const cleanupEnabled = (ctx) => ctx.shouldReset
+const cleanupEnabled = (ctx) => ctx.shouldBackup
 
 const cleanupSkipped = (ctx) => {
   // Should be skipped in case of unknown git errors
@@ -77,13 +71,17 @@ const cleanupSkipped = (ctx) => {
   ) {
     return GIT_ERROR
   }
+  // Should be skipped when reverting to original state fails
+  if (ctx.errors.has(RestoreOriginalStateError)) {
+    return GIT_ERROR
+  }
 }
 
 module.exports = {
   getInitialState,
   hasPartiallyStagedFiles,
   applyModificationsSkipped,
-  restorePartialChangesSkipped,
+  restoreUnstagedChangesSkipped,
   restoreOriginalStateEnabled,
   restoreOriginalStateSkipped,
   cleanupEnabled,

package/lib/symbols.js

@@ -2,24 +2,28 @@
 
 const ApplyEmptyCommitError = Symbol('ApplyEmptyCommitError')
 const ConfigNotFoundError = new Error('Config could not be found')
+const GetBackupStashError = Symbol('GetBackupStashError')
 const GetStagedFilesError = Symbol('GetStagedFilesError')
 const GitError = Symbol('GitError')
 const GitRepoError = Symbol('GitRepoError')
 const HideUnstagedChangesError = Symbol('HideUnstagedChangesError')
 const InvalidOptionsError = new Error('Invalid Options')
 const RestoreMergeStatusError = Symbol('RestoreMergeStatusError')
+const RestoreOriginalStateError = Symbol('RestoreOriginalStateError')
 const RestoreUnstagedChangesError = Symbol('RestoreUnstagedChangesError')
 const TaskError = Symbol('TaskError')
 
 module.exports = {
   ApplyEmptyCommitError,
   ConfigNotFoundError,
+  GetBackupStashError,
   GetStagedFilesError,
   GitError,
   GitRepoError,
   InvalidOptionsError,
   HideUnstagedChangesError,
   RestoreMergeStatusError,
+  RestoreOriginalStateError,
   RestoreUnstagedChangesError,
   TaskError,
 }

package/lib/validateOptions.js

@@ -1,6 +1,6 @@
 const { promises: fs, constants } = require('fs')
 
-const { DEPRECATED_NO_STASH, invalidOption } = require('./messages')
+const { invalidOption } = require('./messages')
 const { InvalidOptionsError } = require('./symbols')
 
 const debug = require('debug')('lint-staged:options')
@@ -25,10 +25,6 @@ const validateOptions = async (options = {}, logger) => {
     }
   }
 
-  if (typeof options.stash === 'boolean') {
-    logger.warn(DEPRECATED_NO_STASH)
-  }
-
   debug('Validated options!')
 }
 

package/package.json

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

package/lib/unlink.js

@@ -1,22 +0,0 @@
-'use strict'
-
-const debug = require('debug')('lint-staged:file')
-const fs = require('fs')
-const { promisify } = require('util')
-
-const fsUnlink = promisify(fs.unlink)
-
-/**
- * Remove a file if it exists
- * @param {String} filename
- */
-const unlink = async (filename) => {
-  debug('Removing file `%s`', filename)
-  try {
-    await fsUnlink(filename)
-  } catch (error) {
-    debug("File `%s` doesn't exist, ignoring...", filename)
-  }
-}
-
-module.exports = unlink