lint-staged 10.1.1 → 10.1.5

package/README.md

@@ -1,4 +1,4 @@
-# 🚫💩 lint-staged [![Build Status for Linux](https://travis-ci.org/okonet/lint-staged.svg?branch=master)](https://travis-ci.org/okonet/lint-staged) [![Build Status for Windows](https://ci.appveyor.com/api/projects/status/github/okonet/lint-staged?branch=master&svg=true)](https://ci.appveyor.com/project/okonet/lint-staged) [![npm version](https://badge.fury.io/js/lint-staged.svg)](https://badge.fury.io/js/lint-staged) [![Codecov](https://codecov.io/gh/okonet/lint-staged/branch/master/graph/badge.svg)](https://codecov.io/gh/okonet/lint-staged)
+# 🚫💩 lint-staged ![GitHub Actions](https://github.com/okonet/lint-staged/workflows/CI/badge.svg) [![Build Status for Windows](https://ci.appveyor.com/api/projects/status/github/okonet/lint-staged?branch=master&svg=true)](https://ci.appveyor.com/project/okonet/lint-staged) [![npm version](https://badge.fury.io/js/lint-staged.svg)](https://badge.fury.io/js/lint-staged) [![Codecov](https://codecov.io/gh/okonet/lint-staged/branch/master/graph/badge.svg)](https://codecov.io/gh/okonet/lint-staged)
 
 Run linters against staged git files and don't let :poop: slip into your code base!
 

package/lib/chunkFiles.js

@@ -27,18 +27,20 @@ function chunkArray(arr, chunkCount) {
  * Chunk files into sub-arrays based on the length of the resulting argument string
  * @param {Object} opts
  * @param {Array<String>} opts.files
- * @param {String} opts.gitDir
+ * @param {String} [opts.baseDir] The optional base directory to resolve relative paths.
  * @param {number} [opts.maxArgLength] the maximum argument string length
  * @param {Boolean} [opts.relative] whether files are relative to `gitDir` or should be resolved as absolute
  * @returns {Array<Array<String>>}
  */
-module.exports = function chunkFiles({ files, gitDir, maxArgLength = null, relative = false }) {
+module.exports = function chunkFiles({ files, baseDir, maxArgLength = null, relative = false }) {
   if (!maxArgLength) {
     debug('Skip chunking files because of undefined maxArgLength')
     return [files]
   }
 
-  const normalizedFiles = files.map(file => normalize(relative ? file : path.resolve(gitDir, file)))
+  const normalizedFiles = files.map(file =>
+    normalize(relative || !baseDir ? file : path.resolve(baseDir, file))
+  )
   const fileListLength = normalizedFiles.join(' ').length
   debug(
     `Resolved an argument string length of ${fileListLength} characters from ${normalizedFiles.length} files`

package/lib/gitWorkflow.js

@@ -3,6 +3,7 @@
 const debug = require('debug')('lint-staged:git')
 const path = require('path')
 
+const chunkFiles = require('./chunkFiles')
 const execGit = require('./execGit')
 const { readFile, unlink, writeFile } = require('./file')
 
@@ -52,14 +53,15 @@ const handleError = (error, ctx) => {
 }
 
 class GitWorkflow {
-  constructor({ allowEmpty, gitConfigDir, gitDir, stagedFileChunks }) {
+  constructor({ allowEmpty, gitConfigDir, gitDir, matchedFiles, maxArgLength }) {
     this.execGit = (args, options = {}) => execGit(args, { ...options, cwd: gitDir })
     this.deletedFiles = []
     this.gitConfigDir = gitConfigDir
     this.gitDir = gitDir
     this.unstagedDiff = null
     this.allowEmpty = allowEmpty
-    this.stagedFileChunks = stagedFileChunks
+    this.matchedFiles = matchedFiles
+    this.maxArgLength = maxArgLength
 
     /**
      * These three files hold state about an ongoing git merge
@@ -164,7 +166,7 @@ class GitWorkflow {
   /**
    * Create a diff of partially staged files and backup stash if enabled.
    */
-  async prepare(ctx, stash) {
+  async prepare(ctx, shouldBackup) {
     try {
       debug('Backing up original state...')
 
@@ -182,7 +184,7 @@ class GitWorkflow {
       /**
        * If backup stash should be skipped, no need to continue
        */
-      if (!stash) return
+      if (!shouldBackup) 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
@@ -193,8 +195,8 @@ class GitWorkflow {
       // Manually check and backup if necessary
       await this.backupMergeStatus()
 
-      // Save stash of entire original state, including unstaged and untracked changes
-      await this.execGit(['stash', 'save', '--include-untracked', STASH])
+      // Save stash of original state
+      await this.execGit(['stash', 'save', STASH])
       await this.execGit(['stash', 'apply', '--quiet', '--index', await this.getBackupStash()])
 
       // Restore meta information about ongoing git merge, cleared by `git stash`
@@ -205,9 +207,6 @@ class GitWorkflow {
 
       debug('Done backing up original state!')
     } catch (error) {
-      if (error.message && error.message.includes('You do not have the initial commit yet')) {
-        ctx.emptyGitRepo = true
-      }
       handleError(error, ctx)
     }
   }
@@ -235,11 +234,22 @@ class GitWorkflow {
    */
   async applyModifications(ctx) {
     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]))
-    )
+    // `matchedFiles` 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.
+    const files = Array.from(this.matchedFiles)
+    // Chunk files for better Windows compatibility
+    const matchedFileChunks = chunkFiles({
+      baseDir: this.gitDir,
+      files,
+      maxArgLength: this.maxArgLength
+    })
+
+    // These additions per chunk are run "serially" to prevent race conditions.
+    // Git add creates a lockfile in the repo causing concurrent operations to fail.
+    for (const files of matchedFileChunks) {
+      await this.execGit(['add', '--', ...files])
+    }
+
     debug('Done adding task modifications to index!')
 
     const stagedFilesAfterAdd = await this.execGit(['diff', '--name-only', '--cached'])
@@ -296,7 +306,7 @@ class GitWorkflow {
       await Promise.all(this.deletedFiles.map(file => unlink(file)))
 
       // Clean out patch
-      if (this.partiallyStagedFiles) await unlink(PATCH_UNSTAGED)
+      await unlink(this.getHiddenFilepath(PATCH_UNSTAGED))
 
       debug('Done restoring original state!')
     } catch (error) {

package/lib/runAll.js

@@ -7,6 +7,7 @@ const Listr = require('listr')
 const symbols = require('log-symbols')
 
 const chunkFiles = require('./chunkFiles')
+const execGit = require('./execGit')
 const generateTasks = require('./generateTasks')
 const getStagedFiles = require('./getStagedFiles')
 const GitWorkflow = require('./gitWorkflow')
@@ -91,15 +92,22 @@ const runAll = async (
 ) => {
   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!')
 
+  // Test whether we have any commits or not.
+  // Stashing must be disabled with no initial commit.
+  const hasInitialCommit = await execGit(['log', '-1'], { cwd: gitDir })
+    .then(() => true)
+    .catch(() => false)
+
+  // Lint-staged should create a backup stash only when there's an initial commit
+  const shouldBackup = hasInitialCommit && stash
+  if (!shouldBackup) {
+    const reason = hasInitialCommit ? '`--no-stash` was used' : 'there’s no initial commit yet'
+    logger.warn(`${symbols.warning} ${chalk.yellow(`Skipping backup because ${reason}.\n`)}`)
+  }
+
   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)
@@ -109,7 +117,7 @@ const runAll = async (
     return logger.log(`${symbols.info} No staged files found.`)
   }
 
-  const stagedFileChunks = chunkFiles({ files, gitDir, maxArgLength, relative })
+  const stagedFileChunks = chunkFiles({ baseDir: gitDir, files, maxArgLength, relative })
   const chunkCount = stagedFileChunks.length
   if (chunkCount > 1) debugLog(`Chunked staged files into ${chunkCount} part`, chunkCount)
 
@@ -125,6 +133,9 @@ const runAll = async (
 
   const listrTasks = []
 
+  // Set of all staged files that matched a task glob. Values in a set are unique.
+  const matchedFiles = new Set()
+
   for (const [index, files] of stagedFileChunks.entries()) {
     const chunkTasks = generateTasks({ config, cwd, gitDir, files, relative })
     const chunkListrTasks = []
@@ -137,9 +148,12 @@ const runAll = async (
         shell
       })
 
-      if (subTasks.some(subTask => subTask.command === 'git add')) {
-        hasDeprecatedGitAdd = true
-      }
+      // Add files from task to match set
+      task.fileList.forEach(file => {
+        matchedFiles.add(file)
+      })
+
+      hasDeprecatedGitAdd = subTasks.some(subTask => subTask.command === 'git add')
 
       chunkListrTasks.push({
         title: `Running tasks for ${task.pattern}`,
@@ -190,13 +204,13 @@ const runAll = async (
     return 'No tasks to run.'
   }
 
-  const git = new GitWorkflow({ allowEmpty, gitConfigDir, gitDir, stagedFileChunks })
+  const git = new GitWorkflow({ allowEmpty, gitConfigDir, gitDir, matchedFiles, maxArgLength })
 
   const runner = new Listr(
     [
       {
         title: 'Preparing...',
-        task: ctx => git.prepare(ctx, stash)
+        task: ctx => git.prepare(ctx, shouldBackup)
       },
       {
         title: 'Hiding unstaged changes to partially staged files...',
@@ -208,7 +222,7 @@ const runAll = async (
         title: 'Applying modifications...',
         task: ctx => git.applyModifications(ctx),
         // Always apply back unstaged modifications when skipping backup
-        skip: ctx => stash && shouldSkipApplyModifications(ctx)
+        skip: ctx => shouldBackup && shouldSkipApplyModifications(ctx)
       },
       {
         title: 'Restoring unstaged changes to partially staged files...',
@@ -220,14 +234,14 @@ const runAll = async (
         title: 'Reverting to original state because of errors...',
         task: ctx => git.restoreOriginalState(ctx),
         enabled: ctx =>
-          stash &&
+          shouldBackup &&
           (ctx.taskError || ctx.gitApplyEmptyCommitError || ctx.gitRestoreUnstagedChangesError),
         skip: shouldSkipRevert
       },
       {
         title: 'Cleaning up...',
         task: ctx => git.cleanup(ctx),
-        enabled: () => stash,
+        enabled: () => shouldBackup,
         skip: shouldSkipCleanup
       }
     ],
@@ -245,18 +259,13 @@ const runAll = async (
     } else if (error.context.gitError && !error.context.gitGetBackupStashError) {
       logger.error(`\n  ${symbols.error} ${chalk.red(`lint-staged failed due to a git error.`)}`)
 
-      if (error.context.emptyGitRepo) {
-        logger.error(
-          `\n    The initial commit is needed for lint-staged to work.
-    Please use the --no-verify flag to skip running lint-staged.`
-        )
-      } else if (stash) {
+      if (shouldBackup) {
         // No sense to show this if the backup stash itself is missing.
         logger.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}\n`)
+    > git stash apply --index stash@{0}\n`)
       }
     }
 

package/package.json

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