lint-staged 10.0.4 → 10.0.8

package/lib/file.js

@@ -2,67 +2,80 @@
 
 const debug = require('debug')('lint-staged:file')
 const fs = require('fs')
+const { promisify } = require('util')
 
-const fsPromises = fs.promises
+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 filepath if exists.
- * @param {string} filepath
+ * Check if a file exists. Returns the filename if exists.
+ * @param {String} filename
+ * @returns {String|Boolean}
  */
-const exists = async filepath => {
+const exists = async filename => {
   try {
-    await fsPromises.access(filepath)
-    return filepath
+    await fsAccess(filename)
+    return filename
   } catch {
     return false
   }
 }
 
 /**
+ * Read contents of a file to buffer
  * @param {String} filename
- * @returns {Promise<Buffer|Null>}
+ * @param {Boolean} [ignoreENOENT=true] — Whether to throw if the file doesn't exist
+ * @returns {Promise<Buffer>}
  */
-const readBufferFromFile = (filename, rejectENOENT = false) =>
-  new Promise(resolve => {
-    debug('Reading buffer from file `%s`', filename)
-    fs.readFile(filename, (error, buffer) => {
-      if (!rejectENOENT && error && error.code === 'ENOENT') {
-        debug("File `%s` doesn't exist, ignoring...", filename)
-        return resolve(null) // no-op file doesn't exist
-      }
-      debug('Done reading buffer from file `%s`!', filename)
-      resolve(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
+    }
+  }
+}
 
 /**
  * Unlink a file if it exists
- * @param {*} filepath
+ * @param {String} filename
+ * @param {Boolean} [ignoreENOENT=true] — Whether to throw if the file doesn't exist
  */
-const unlink = async filepath => {
-  if (filepath) {
-    await fsPromises.access(filepath)
-    await fsPromises.unlink(filepath)
+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
+      }
+    }
   }
 }
 
 /**
+ * Write buffer to file
  * @param {String} filename
  * @param {Buffer} buffer
- * @returns {Promise<Void>}
  */
-const 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()
-    })
-  })
+const writeFile = async (filename, buffer) => {
+  debug('Writing file `%s`', filename)
+  await fsWriteFile(filename, buffer)
+}
 
 module.exports = {
   exists,
-  readBufferFromFile,
+  readFile,
   unlink,
-  writeBufferToFile
+  writeFile
 }

package/lib/getStagedFiles.js

@@ -6,7 +6,7 @@ module.exports = async function getStagedFiles(options) {
   try {
     const lines = await execGit(['diff', '--staged', '--diff-filter=ACMR', '--name-only'], options)
     return lines ? lines.split('\n') : []
-  } catch (error) {
+  } catch {
     return null
   }
 }

package/lib/gitWorkflow.js

@@ -4,7 +4,7 @@ const debug = require('debug')('lint-staged:git')
 const path = require('path')
 
 const execGit = require('./execGit')
-const { exists, readBufferFromFile, unlink, writeBufferToFile } = require('./file')
+const { exists, readFile, unlink, writeFile } = require('./file')
 
 const MERGE_HEAD = 'MERGE_HEAD'
 const MERGE_MODE = 'MERGE_MODE'
@@ -18,23 +18,6 @@ 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']
 
-/**
- * Delete untracked files using `git clean`
- * @param {Function} execGit function for executing git commands using execa
- * @returns {Promise<void>}
- */
-const cleanUntrackedFiles = async execGit => {
-  const untrackedFiles = await execGit(['ls-files', '--others', '--exclude-standard'])
-  if (untrackedFiles) {
-    debug('Detected unstaged, untracked files: ', untrackedFiles)
-    debug(
-      'This is probably due to a bug in git =< 2.13.0 where `git stash --keep-index` resurrects deleted files.'
-    )
-    debug('Deleting the files using `git clean`...')
-    await execGit(['clean', '--force', ...untrackedFiles.split('\n')])
-  }
-}
-
 const handleError = (error, ctx) => {
   ctx.gitError = true
   throw error
@@ -44,6 +27,7 @@ class GitWorkflow {
   constructor({ allowEmpty, gitConfigDir, gitDir, stagedFileChunks }) {
     this.execGit = (args, options = {}) => execGit(args, { ...options, cwd: gitDir })
     this.gitConfigDir = gitConfigDir
+    this.gitDir = gitDir
     this.unstagedDiff = null
     this.allowEmpty = allowEmpty
     this.stagedFileChunks = stagedFileChunks
@@ -73,7 +57,7 @@ class GitWorkflow {
     const resolved = this.getHiddenFilepath(filename)
     const pathIfExists = await exists(resolved)
     if (!pathIfExists) return false
-    const buffer = await readBufferFromFile(pathIfExists)
+    const buffer = await readFile(pathIfExists)
     const patch = buffer.toString().trim()
     return patch.length ? filename : false
   }
@@ -97,9 +81,9 @@ class GitWorkflow {
   async backupMergeStatus() {
     debug('Backing up merge state...')
     await Promise.all([
-      readBufferFromFile(this.mergeHeadFilename).then(buffer => (this.mergeHeadBuffer = buffer)),
-      readBufferFromFile(this.mergeModeFilename).then(buffer => (this.mergeModeBuffer = buffer)),
-      readBufferFromFile(this.mergeMsgFilename).then(buffer => (this.mergeMsgBuffer = buffer))
+      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!')
   }
@@ -111,9 +95,9 @@ class GitWorkflow {
     debug('Restoring merge state...')
     try {
       await Promise.all([
-        this.mergeHeadBuffer && writeBufferToFile(this.mergeHeadFilename, this.mergeHeadBuffer),
-        this.mergeModeBuffer && writeBufferToFile(this.mergeModeFilename, this.mergeModeBuffer),
-        this.mergeMsgBuffer && writeBufferToFile(this.mergeMsgFilename, this.mergeMsgBuffer)
+        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) {
@@ -123,6 +107,18 @@ class GitWorkflow {
     }
   }
 
+  /**
+   * List and delete untracked files
+   */
+  async cleanUntrackedFiles() {
+    const lsFiles = await this.execGit(['ls-files', '--others', '--exclude-standard'])
+    const untrackedFiles = lsFiles
+      .split('\n')
+      .filter(Boolean)
+      .map(file => path.resolve(this.gitDir, file))
+    await Promise.all(untrackedFiles.map(file => unlink(file)))
+  }
+
   /**
    * Create backup stashes, one of everything and one of only staged changes
    * Staged files are left in the index for running tasks
@@ -135,6 +131,14 @@ class GitWorkflow {
       // Manually check and backup if necessary
       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 `--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))
+
       // 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])
@@ -144,7 +148,7 @@ class GitWorkflow {
 
       // 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 cleanUntrackedFiles(this.execGit)
+      await this.cleanUntrackedFiles()
 
       // Get a diff of unstaged changes by diffing the saved stash against what's left on disk.
       await this.execGit([
@@ -238,6 +242,9 @@ class GitWorkflow {
       ctx.gitRestoreUntrackedError = true
       handleError(error, ctx)
     }
+
+    // If stashing resurrected deleted files, clean them out
+    await Promise.all(this.deletedFiles.map(file => unlink(file)))
   }
 
   /**
@@ -251,9 +258,13 @@ class GitWorkflow {
       await this.execGit(['stash', 'apply', '--quiet', '--index', backupStash])
       debug('Done restoring original state!')
 
+      // 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()
     } catch (error) {
+      ctx.gitRestoreOriginalStateError = true
       handleError(error, ctx)
     }
   }
@@ -278,4 +289,3 @@ class GitWorkflow {
 }
 
 module.exports = GitWorkflow
-module.exports.cleanUntrackedFiles = cleanUntrackedFiles

package/lib/index.js

@@ -14,7 +14,7 @@ const errConfigNotFound = new Error('Config could not be found')
 function resolveConfig(configPath) {
   try {
     return require.resolve(configPath)
-  } catch (ignore) {
+  } catch {
     return configPath
   }
 }

package/lib/makeCmdTasks.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const resolveTaskFn = require('./resolveTaskFn')
+const { createError } = require('./validateConfig')
 
 const debug = require('debug')('lint-staged:make-cmd-tasks')
 
@@ -15,32 +16,34 @@ const debug = require('debug')('lint-staged:make-cmd-tasks')
  */
 module.exports = async function makeCmdTasks({ commands, files, gitDir, shell }) {
   debug('Creating listr tasks for commands %o', commands)
-  const commandsArray = Array.isArray(commands) ? commands : [commands]
+  const commandArray = Array.isArray(commands) ? commands : [commands]
   const cmdTasks = []
 
-  for (const cmd of commandsArray) {
+  for (const cmd of commandArray) {
     // command function may return array of commands that already include `stagedFiles`
     const isFn = typeof cmd === 'function'
     const resolved = isFn ? await cmd(files) : cmd
 
     const resolvedArray = Array.isArray(resolved) ? resolved : [resolved] // Wrap non-array command as array
 
-    // Function command should not be used as the task title as-is
-    // because the resolved string it might be very long
-    // Create a matching command array with [file] in place of file names
-    let mockCmdTasks
-    if (isFn) {
-      const mockFileList = Array(files.length).fill('[file]')
-      const resolved = await cmd(mockFileList)
-      mockCmdTasks = Array.isArray(resolved) ? resolved : [resolved]
-    }
-
-    for (const [i, command] of resolvedArray.entries()) {
+    for (const command of resolvedArray) {
       let title = isFn ? '[Function]' : command
-      if (isFn && mockCmdTasks[i]) {
-        // If command is a function, use the matching mock command as title,
-        // but since might include multiple [file] arguments, shorten to one
-        title = mockCmdTasks[i].replace(/\[file\].*\[file\]/, '[file]')
+
+      if (isFn) {
+        // If the function linter didn't return string | string[]  it won't work
+        // Do the validation here instead of `validateConfig` to skip evaluating the function multiple times
+        if (typeof command !== 'string') {
+          throw new Error(
+            createError(
+              title,
+              'Function task should return a string or an array of strings',
+              resolved
+            )
+          )
+        }
+
+        const [startOfFn] = command.split(' ')
+        title += ` ${startOfFn} ...` // Append function name, like `[Function] eslint ...`
       }
 
       cmdTasks.push({

package/lib/resolveGitRepo.js

@@ -1,48 +1,52 @@
 'use strict'
 
 const normalize = require('normalize-path')
+const debugLog = require('debug')('lint-staged:resolveGitRepo')
+const fs = require('fs')
 const path = require('path')
+const { promisify } = require('util')
 
 const execGit = require('./execGit')
-const { readBufferFromFile } = require('./file')
+const { readFile } = require('./file')
+
+const fsLstat = promisify(fs.lstat)
 
 /**
  * Resolve path to the .git directory, with special handling for
- * submodules
+ * submodules and worktrees
  */
-const resolveGitConfigDir = async ({ gitDir, isSubmodule }) => {
+const resolveGitConfigDir = async gitDir => {
   const defaultDir = path.resolve(gitDir, '.git')
-  if (!isSubmodule) return normalize(defaultDir)
-
-  const buffer = await readBufferFromFile(defaultDir)
-  const dotGit = buffer.toString()
-  const gitConfigDir = path.resolve(gitDir, dotGit.replace(/^gitdir: /, '').trim())
-  return normalize(gitConfigDir)
+  const stats = await fsLstat(defaultDir)
+  // 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 readFile(defaultDir)).toString()
+  return path.resolve(gitDir, file.replace(/^gitdir: /, '')).trim()
 }
 
 /**
  * Resolve git directory and possible submodule paths
  */
-module.exports = async function resolveGitRepo(options = {}) {
+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)
     delete process.env.GIT_DIR
 
-    // The git repo root directory; this points to the root of a submodule instead of the parent
-    const gitDir = await execGit(['rev-parse', '--show-toplevel'], options)
+    const gitDir = normalize(await execGit(['rev-parse', '--show-toplevel'], { cwd }))
+    const gitConfigDir = normalize(await resolveGitConfigDir(gitDir))
 
-    // A super-project working tree exists only in submodules; poinst to the parent root
-    const superprojectWorkingTree = await execGit(
-      ['rev-parse', '--show-superproject-working-tree'],
-      options
-    )
+    debugLog('Resolved git directory to be `%s`', gitDir)
+    debugLog('Resolved git config directory to be `%s`', gitConfigDir)
 
-    const isSubmodule = !!superprojectWorkingTree
-    const gitConfigDir = await resolveGitConfigDir({ gitDir, isSubmodule })
-
-    return { gitDir: normalize(gitDir), gitConfigDir, isSubmodule }
+    return { gitDir, gitConfigDir }
   } catch (error) {
-    return { error, gitDir: null }
+    debugLog('Failed to resolve git repo with error:', error)
+    return { error, gitDir: null, gitConfigDir: null }
   }
 }
+
+module.exports = resolveGitRepo

package/lib/runAll.js

@@ -23,6 +23,40 @@ const getRenderer = ({ debug, quiet }) => {
   return 'update'
 }
 
+const MESSAGES = {
+  TASK_ERROR: 'Skipped because of errors from tasks.',
+  GIT_ERROR: 'Skipped because of previous git error.'
+}
+
+const shouldSkipApplyModifications = ctx => {
+  // Should be skipped in case of git errors
+  if (ctx.gitError) {
+    return MESSAGES.GIT_ERROR
+  }
+  // Should be skipped when tasks fail
+  if (ctx.taskError) {
+    return MESSAGES.TASK_ERROR
+  }
+}
+
+const shouldSkipRevert = ctx => {
+  // Should be skipped in case of unknown git errors
+  if (ctx.gitError && !ctx.gitApplyEmptyCommit && !ctx.gitApplyModificationsError) {
+    return MESSAGES.GIT_ERROR
+  }
+}
+
+const shouldSkipCleanup = ctx => {
+  // Should be skipped in case of unknown git errors
+  if (ctx.gitError && !ctx.gitApplyEmptyCommit && !ctx.gitApplyModificationsError) {
+    return MESSAGES.GIT_ERROR
+  }
+  // Should be skipped when reverting to original state fails
+  if (ctx.gitRestoreOriginalStateError) {
+    return MESSAGES.GIT_ERROR
+  }
+}
+
 /**
  * Executes all tasks and either resolves or rejects the promise
  *
@@ -39,7 +73,7 @@ const getRenderer = ({ debug, quiet }) => {
  * @param {Logger} logger
  * @returns {Promise}
  */
-module.exports = async function runAll(
+const runAll = async (
   {
     allowEmpty = false,
     config,
@@ -52,14 +86,11 @@ module.exports = async function runAll(
     concurrent = true
   },
   logger = console
-) {
+) => {
   debugLog('Running all linter scripts')
 
-  const { gitDir, gitConfigDir, isSubmodule } = await resolveGitRepo({ cwd })
+  const { gitDir, gitConfigDir } = await resolveGitRepo(cwd)
   if (!gitDir) throw new Error('Current directory is not a git directory!')
-  debugLog('Resolved git directory to be `%s`', gitDir)
-  debugLog('Resolved git config directory to be `%s`', gitConfigDir)
-  if (isSubmodule) debugLog('Current git directory is a submodule')
 
   const files = await getStagedFiles({ cwd: gitDir })
   if (!files) throw new Error('Unable to get staged files!')
@@ -130,7 +161,7 @@ module.exports = async function runAll(
       task: () => new Listr(chunkListrTasks, { ...listrOptions, concurrent }),
       skip: (ctx = {}) => {
         // Skip if the first step (backup) failed
-        if (ctx.gitError) return 'Skipped because of previous git error.'
+        if (ctx.gitError) return MESSAGES.GIT_ERROR
         // Skip chunk when no every task is skipped (due to no matches)
         if (chunkListrTasks.every(task => task.skip())) return 'No tasks to run.'
         return false
@@ -154,15 +185,6 @@ module.exports = async function runAll(
 
   const git = new GitWorkflow({ allowEmpty, gitConfigDir, gitDir, stagedFileChunks })
 
-  // Running git reset or dropping the backup stash should be skipped
-  // when there are git errors NOT related to applying unstaged modifications.
-  // In the latter case, the original state is restored.
-  const cleanupNotSafe = ctx =>
-    ctx.gitError &&
-    !ctx.gitApplyEmptyCommit &&
-    !ctx.gitApplyModificationsError &&
-    'Skipped because of previous git error.'
-
   const runner = new Listr(
     [
       {
@@ -172,22 +194,19 @@ module.exports = async function runAll(
       ...listrTasks,
       {
         title: 'Applying modifications...',
-        skip: ctx => {
-          if (ctx.gitError) return 'Skipped because of previous git error.'
-          if (ctx.taskError) return 'Skipped because of errors from tasks.'
-        },
-        task: ctx => git.applyModifications(ctx)
+        task: ctx => git.applyModifications(ctx),
+        skip: shouldSkipApplyModifications
       },
       {
         title: 'Reverting to original state...',
+        task: ctx => git.restoreOriginalState(ctx),
         enabled: ctx => ctx.taskError || ctx.gitApplyEmptyCommit || ctx.gitApplyModificationsError,
-        skip: cleanupNotSafe,
-        task: ctx => git.restoreOriginalState(ctx)
+        skip: shouldSkipRevert
       },
       {
         title: 'Cleaning up...',
-        skip: cleanupNotSafe,
-        task: ctx => git.dropBackup(ctx)
+        task: ctx => git.dropBackup(ctx),
+        skip: shouldSkipCleanup
       }
     ],
     listrOptions
@@ -222,3 +241,11 @@ module.exports = async function runAll(
     throw error
   }
 }
+
+module.exports = runAll
+
+module.exports.shouldSkip = {
+  shouldSkipApplyModifications,
+  shouldSkipRevert,
+  shouldSkipCleanup
+}

package/lib/validateConfig.js

@@ -80,21 +80,6 @@ module.exports = function validateConfig(config) {
           )
         )
       }
-
-      entries.forEach(([, task]) => {
-        if (typeof task !== 'function') return
-        const resolved = task(['[filename]'])
-        if (typeof resolved === 'string') return
-        if (!Array.isArray(resolved) || resolved.some(subtask => typeof subtask !== 'string')) {
-          errors.push(
-            createError(
-              task,
-              'Function task should return a string or an array of strings',
-              resolved
-            )
-          )
-        }
-      })
     })
   }
 
@@ -104,3 +89,5 @@ module.exports = function validateConfig(config) {
 
   return config
 }
+
+module.exports.createError = createError

package/package.json

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