lint-staged 16.2.1 → 16.2.3

package/bin/lint-staged.js

@@ -6,7 +6,7 @@ import { Option, program } from 'commander'
 
 import { createDebug, enableDebug } from '../lib/debug.js'
 import lintStaged from '../lib/index.js'
-import { CONFIG_STDIN_ERROR, RESTORE_STASH_EXAMPLE } from '../lib/messages.js'
+import { CONFIG_STDIN_ERROR, restoreStashExample } from '../lib/messages.js'
 import { readStdin } from '../lib/readStdin.js'
 import { getVersion } from '../lib/version.js'
 
@@ -120,7 +120,7 @@ program
     ).default(false)
   )
 
-  .addHelpText('afterAll', '\n' + RESTORE_STASH_EXAMPLE)
+  .addHelpText('afterAll', '\n' + restoreStashExample())
 
 const cliOptions = program.parse(process.argv).opts()
 

package/lib/gitWorkflow.js

@@ -9,7 +9,7 @@ import { getDiffCommand } from './getDiffCommand.js'
 import { parseGitZOutput } from './parseGitZOutput.js'
 import {
   ApplyEmptyCommitError,
-  ExitCodeError,
+  FailOnChangesError,
   GetBackupStashError,
   GitError,
   HideUnstagedChangesError,
@@ -277,15 +277,6 @@ export class GitWorkflow {
         task.title = `Backed up original state in git stash (${ctx.backupHash})`
         debugLog(task.title)
       }
-
-      if (this.failOnChanges) {
-        debugLog(
-          'Calculating SHA-256 hash of unstaged changes because "--fail-on-changes" was used...'
-        )
-        const diff = await this.execGit(['diff', '--patch', '--unified=0'])
-        this.unstagedDiffSha256 = calculateSha256(diff)
-        debugLog('SHA-256 hash of unstaged changes is %S', this.unstagedDiffSha256)
-      }
     } catch (error) {
       handleError(error, ctx)
     }
@@ -304,20 +295,33 @@ export class GitWorkflow {
     }
   }
 
+  async runTasks(ctx, task, { listrTasks, concurrent }) {
+    if (ctx.shouldFailOnChanges) {
+      debugLog(
+        'Calculating SHA-256 hash of unstaged changes because "--fail-on-changes" was used...'
+      )
+      const diff = await this.execGit(['diff', '--patch', '--unified=0'])
+      ctx.unstagedDiffSha256 = calculateSha256(diff)
+      debugLog('SHA-256 hash of unstaged changes is %s', ctx.unstagedDiffSha256)
+    }
+
+    return task.newListr(listrTasks, { concurrent })
+  }
+
   /**
    * 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) {
-    if (this.failOnChanges) {
+    if (ctx.shouldFailOnChanges) {
       debugLog(
         'Calculating SHA-256 hash of changes after tasks because "--fail-on-changes" was used...'
       )
       const diff = await this.execGit(['diff', '--patch', '--unified=0'])
       const diffSha256 = calculateSha256(diff)
-      debugLog('SHA-256 hash of changes after tasks is %S', this.diffSha256)
-      if (this.unstagedDiffSha256 !== diffSha256) {
-        ctx.errors.add(ExitCodeError)
+      debugLog('SHA-256 hash of changes after tasks is %s', diffSha256)
+      if (ctx.unstagedDiffSha256 !== diffSha256) {
+        ctx.errors.add(FailOnChangesError)
         throw new Error('Tasks modified files and --fail-on-changes was used!')
       }
     }

package/lib/index.js

@@ -6,7 +6,7 @@ import {
   NO_CONFIGURATION,
   PREVENTED_EMPTY_COMMIT,
   PREVENTED_TASK_MODIFICATIONS,
-  RESTORE_STASH_EXAMPLE,
+  restoreStashExample,
   UNSTAGED_CHANGES_BACKUP_STASH_LOCATION,
 } from './messages.js'
 import { printTaskOutput } from './printTaskOutput.js'
@@ -15,7 +15,7 @@ import { cleanupSkipped } from './state.js'
 import {
   ApplyEmptyCommitError,
   ConfigNotFoundError,
-  ExitCodeError,
+  FailOnChangesError,
   GetBackupStashError,
   GitError,
   RestoreUnstagedChangesError,
@@ -155,8 +155,9 @@ const lintStaged = async (
         logger.error(NO_CONFIGURATION)
       } else if (ctx.errors.has(ApplyEmptyCommitError)) {
         logger.warn(PREVENTED_EMPTY_COMMIT)
-      } else if (ctx.errors.has(ExitCodeError)) {
-        logger.warn(PREVENTED_TASK_MODIFICATIONS)
+      } else if (ctx.errors.has(FailOnChangesError)) {
+        logger.warn(PREVENTED_TASK_MODIFICATIONS + '\n')
+        logger.warn(restoreStashExample(ctx.backupHash))
       } else if (ctx.errors.has(RestoreUnstagedChangesError)) {
         logger.warn(UNSTAGED_CHANGES_BACKUP_STASH_LOCATION)
         logger.warn(ctx.unstagedPatch)
@@ -167,7 +168,7 @@ const lintStaged = async (
         logger.error(GIT_ERROR)
         if (ctx.shouldBackup) {
           // No sense to show this if the backup stash itself is missing.
-          logger.error(RESTORE_STASH_EXAMPLE + '\n')
+          logger.error(restoreStashExample(ctx.backupHash) + '\n')
         }
       }
 

package/lib/messages.js

@@ -20,11 +20,11 @@ export const incorrectBraces = (before, after) =>
 `
   )
 
-export const NO_CONFIGURATION = `${error} No valid configuration found.`
+export const NO_CONFIGURATION = `${error} lint-staged could not find any valid configuration.`
 
-export const NO_STAGED_FILES = `${info} No staged files found.`
+export const NO_STAGED_FILES = `${info} lint-staged could not find any staged files.`
 
-export const NO_TASKS = `${info} No staged files match any configured task.`
+export const NO_TASKS = `${info} lint-staged could not find any staged files matching configured tasks.`
 
 export const skippingBackup = (hasInitialCommit, diff) => {
   const reason =
@@ -66,11 +66,13 @@ export const PREVENTED_EMPTY_COMMIT = `
   Use the --allow-empty option to continue, or check your task configuration`)}
 `
 
-export const RESTORE_STASH_EXAMPLE = `Any lost modifications can be restored from a git stash:
+export const restoreStashExample = (
+  hash = 'h0a0s0h0'
+) => `Any lost modifications can be restored from a git stash:
 
   > git stash list --format="%h %s"
-  h0a0s0h0 On main: lint-staged automatic backup
-  > git apply --index h0a0s0h0`
+  ${hash} On main: lint-staged automatic backup
+  > git apply --index ${hash}`
 
 export const CONFIG_STDIN_ERROR = red(`${error} Failed to read config from stdin.`)
 

package/lib/runAll.js

@@ -110,6 +110,7 @@ export const runAll = async (
   debugLog('Using working directory `%s`', cwd)
 
   const ctx = getInitialState({
+    failOnChanges,
     hidePartiallyStaged,
     hideUnstaged,
     quiet,
@@ -336,7 +337,7 @@ export const runAll = async (
       },
       {
         title: `Running tasks for ${diff ? 'changed' : 'staged'} files...`,
-        task: (ctx, task) => task.newListr(listrTasks, { concurrent }),
+        task: (ctx, task) => git.runTasks(ctx, task, { listrTasks, concurrent }),
         skip: () => listrTasks.every((task) => task.skip()),
       },
       {

package/lib/state.js

@@ -2,7 +2,7 @@ import EventEmitter from 'events'
 
 import { GIT_ERROR, TASK_ERROR } from './messages.js'
 import {
-  ExitCodeError,
+  FailOnChangesError,
   GitError,
   RestoreOriginalStateError,
   RestoreUnstagedChangesError,
@@ -10,6 +10,7 @@ import {
 } from './symbols.js'
 
 export const getInitialState = ({
+  failOnChanges = false,
   hideUnstaged = false,
   hidePartiallyStaged = !hideUnstaged,
   quiet = false,
@@ -18,6 +19,7 @@ export const getInitialState = ({
   backupHash: null,
   errors: new Set([]),
   events: new EventEmitter(),
+  shouldFailOnChanges: failOnChanges,
   hasFilesToHide: null,
   output: [],
   quiet,
@@ -25,6 +27,7 @@ export const getInitialState = ({
   shouldHidePartiallyStaged: hidePartiallyStaged,
   shouldHideUnstaged: hideUnstaged,
   shouldRevert: revert,
+  unstagedDiffSha256: null,
   unstagedPatch: null,
 })
 
@@ -37,10 +40,12 @@ export const shouldRestoreUnstagedChanges = (ctx) =>
 export const applyModificationsSkipped = (ctx) => {
   // Always apply back unstaged modifications when skipping revert or backup
   if (!ctx.shouldRevert || !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
@@ -53,6 +58,13 @@ export const restoreUnstagedChangesSkipped = (ctx) => {
     return GIT_ERROR
   }
 
+  // When complete reverting to original state is skipped,
+  // we can still restore unstaged changes to make it easier
+  // to do manually.
+  if (!ctx.shouldRevert) {
+    false
+  }
+
   // Should be skipped when tasks fail
   if (ctx.errors.has(TaskError)) {
     return TASK_ERROR
@@ -62,17 +74,13 @@ export const restoreUnstagedChangesSkipped = (ctx) => {
 export const restoreOriginalStateEnabled = (ctx) =>
   !!ctx.shouldRevert &&
   !!ctx.shouldBackup &&
-  (ctx.errors.has(ExitCodeError) ||
+  (ctx.errors.has(FailOnChangesError) ||
     ctx.errors.has(TaskError) ||
     ctx.errors.has(RestoreUnstagedChangesError))
 
 export const restoreOriginalStateSkipped = (ctx) => {
   // Should be skipped in case of unknown git errors
-  if (
-    ctx.errors.has(GitError) &&
-    !ctx.errors.has(RestoreUnstagedChangesError) &&
-    !ctx.errors.has(ExitCodeError)
-  ) {
+  if (ctx.errors.has(GitError) && !ctx.errors.has(RestoreUnstagedChangesError)) {
     return GIT_ERROR
   }
 }
@@ -80,6 +88,11 @@ export const restoreOriginalStateSkipped = (ctx) => {
 export const cleanupEnabled = (ctx) => ctx.shouldBackup
 
 export const cleanupSkipped = (ctx) => {
+  // "--fail-on-changes" was used, so we shouldn't drop the backup stash
+  if (ctx.errors.has(FailOnChangesError) && !ctx.shouldRevert) {
+    return true
+  }
+
   // Should be skipped in case of unknown git errors
   if (restoreOriginalStateSkipped(ctx)) {
     return GIT_ERROR

package/lib/symbols.js

@@ -26,4 +26,4 @@ export const RestoreUnstagedChangesError = Symbol('RestoreUnstagedChangesError')
 
 export const TaskError = Symbol('TaskError')
 
-export const ExitCodeError = Symbol('ExitCodeError')
+export const FailOnChangesError = Symbol('FailOnChangesError')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-staged",
-  "version": "16.2.1",
+  "version": "16.2.3",
   "description": "Lint files staged by git",
   "license": "MIT",
   "repository": {