lint-staged 9.2.5 → 9.4.2

package/README.md

@@ -2,6 +2,30 @@
 
 Run linters against staged git files and don't let :poop: slip into your code base!
 
+---
+
+## 🚧 Help test `lint-staged@next`!
+
+Version 10 of `lint-staged` is coming with changes that help it run faster on large git repositories and prevent loss of data during errors. Please help test the `next` version and report any inconsistencies in our [GitHub Issues](https://github.com/okonet/lint-staged/issues):
+
+**Using npm**
+
+    npm install --save-dev lint-staged@next
+
+**Using yarn**
+
+    yarn add -D lint-staged@next
+
+### Notable changes
+
+- A git stash is created before running any tasks, so in case of errors any lost changes can be restored easily (and automatically unless lint-staged itself crashes)
+- Instead of write-tree/read-tree, `lint-staged@next` uses git stashes to hide unstaged changes while running tasks against staged files
+  - This results in a performance increase of up to 45x on very large repositories
+- The behaviour of committing modifications during tasks (eg. `prettier --write && git add`) is different. The current version creates a diff of these modifications, and applies it against the original state, silently ignoring any errors. The `next` version leaves modifications of staged files as-is, and then restores all hidden unstaged changes as patch. If applying the patch fails due to a merge conflict (because tasks have modified the same lines), a 3-way merge will be retried. If this also fails, the entire commit will fail and the original state will be restored.
+  - **TL;DR** the `next` version will never skip committing any changes by tasks (due to a merge conflict), but might fail in very complex situations where unstaged changes cannot be restored cleanly. If this happens to you, we are very interested in a repeatable test scenario.
+
+---
+
 [![asciicast](https://asciinema.org/a/199934.svg)](https://asciinema.org/a/199934)
 
 ## Why
@@ -109,7 +133,7 @@ Linter commands work on a subset of all staged files, defined by a _glob pattern
   * **`"!(*test).js"`**. will match all JS files, except those ending in `test.js`, so `foo.js` but not `foo.test.js`
 * If the glob pattern does contain a slash (`/`), it will match for paths as well:
   * **`"/*.js"`** will match all JS files in the git repo root, so `/test.js` but not `/foo/bar/test.js`
-  * **`"foo/**/\*.js"`** will match all JS files inside the`/foo`directory, so`/foo/bar/test.js`but not`/test.js`
+  * **`"foo/**/*.js"`** will match all JS files inside the`/foo`directory, so`/foo/bar/test.js`but not`/test.js`
 
 When matching, `lint-staged` will do the following
 
@@ -400,6 +424,20 @@ const success = await lintStaged({
 })
 ```
 
+You can also pass config directly with `config` option:
+
+
+```js
+const success = await lintStaged({
+  config: {
+    '*.js': 'eslint --fix'
+  },
+  shell: false,
+  quiet: false,
+  debug: false
+})
+```
+
 ### Using with JetBrains IDEs _(WebStorm, PyCharm, IntelliJ IDEA, RubyMine, etc.)_
 
 _**Update**_: The latest version of JetBrains IDEs now support running hooks as you would expect.

package/package.json

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

package/src/index.js

@@ -43,6 +43,7 @@ function loadConfig(configPath) {
  *
  * @param {object} options
  * @param {string} [options.configPath] - Path to configuration file
+ * @param {object}  [options.config] - Object with configuration for programmatic API
  * @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
@@ -52,12 +53,12 @@ function loadConfig(configPath) {
  * @returns {Promise<boolean>} Promise of whether the linting passed or failed
  */
 module.exports = function lintStaged(
-  { configPath, relative = false, shell = false, quiet = false, debug = false } = {},
+  { configPath, config, relative = false, shell = false, quiet = false, debug = false } = {},
   logger = console
 ) {
   debugLog('Loading config using `cosmiconfig`')
 
-  return loadConfig(configPath)
+  return (config ? Promise.resolve({ config, filepath: '(input)' }) : loadConfig(configPath))
     .then(result => {
       if (result == null) throw errConfigNotFound
 

package/src/makeCmdTasks.js

@@ -8,27 +8,40 @@ const debug = require('debug')('lint-staged:make-cmd-tasks')
  * Creates and returns an array of listr tasks which map to the given commands.
  *
  * @param {object} options
- * @param {Array<string|Function>|string|Function} [options.commands]
- * @param {string} [options.gitDir]
- * @param {Array<string>} [options.pathsToLint]
+ * @param {Array<string|Function>|string|Function} options.commands
+ * @param {Array<string>} options.files
+ * @param {string} options.gitDir
  * @param {Boolean} shell
  */
-module.exports = async function makeCmdTasks({ commands, gitDir, pathsToLint, shell }) {
+module.exports = async function makeCmdTasks({ commands, files, gitDir, shell }) {
   debug('Creating listr tasks for commands %o', commands)
   const commandsArray = Array.isArray(commands) ? commands : [commands]
 
   return commandsArray.reduce((tasks, command) => {
-    // linter function may return array of commands that already include `pathsToLit`
+    // command function may return array of commands that already include `stagedFiles`
     const isFn = typeof command === 'function'
-    const resolved = isFn ? command(pathsToLint) : command
-    const linters = Array.isArray(resolved) ? resolved : [resolved] // Wrap non-array linter as array
+    const resolved = isFn ? command(files) : command
+    const commands = Array.isArray(resolved) ? resolved : [resolved] // Wrap non-array command as array
 
-    linters.forEach(linter => {
-      const task = {
-        title: linter,
-        task: resolveTaskFn({ gitDir, isFn, linter, pathsToLint, shell })
+    // 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 mockCommands
+    if (isFn) {
+      const mockFileList = Array(files.length).fill('[file]')
+      const resolved = command(mockFileList)
+      mockCommands = Array.isArray(resolved) ? resolved : [resolved]
+    }
+
+    commands.forEach((command, i) => {
+      let title = isFn ? '[Function]' : command
+      if (isFn && mockCommands[i]) {
+        // If command is a function, use the matching mock command as title,
+        // but since might include multiple [file] arguments, shorten to one
+        title = mockCommands[i].replace(/\[file\].*\[file\]/, '[file]')
       }
 
+      const task = { title, task: resolveTaskFn({ gitDir, isFn, command, files, shell }) }
       tasks.push(task)
     })
 

package/src/resolveTaskFn.js

@@ -77,27 +77,20 @@ function makeErr(linter, result, context = {}) {
  * if the OS is Windows.
  *
  * @param {Object} options
- * @param {String} [options.gitDir] - Current git repo path
- * @param {Boolean} [options.isFn] - Whether the linter task is a function
- * @param {string} [options.linter] — Linter task
- * @param {Array<string>} [options.pathsToLint] — Filepaths to run the linter task against
+ * @param {string} options.command — Linter task
+ * @param {String} options.gitDir - Current git repo path
+ * @param {Boolean} options.isFn - Whether the linter task is a function
+ * @param {Array<string>} options.pathsToLint — Filepaths to run the linter task against
  * @param {Boolean} [options.relative] — Whether the filepaths should be relative
  * @param {Boolean} [options.shell] — Whether to skip parsing linter task for better shell support
  * @returns {function(): Promise<Array<string>>}
  */
-module.exports = function resolveTaskFn({
-  gitDir,
-  isFn,
-  linter,
-  pathsToLint,
-  relative,
-  shell = false
-}) {
+module.exports = function resolveTaskFn({ command, files, gitDir, isFn, relative, shell = false }) {
   const execaOptions = { preferLocal: true, reject: false, shell }
 
   if (relative) {
     execaOptions.cwd = process.cwd()
-  } else if (/^git(\.exe)?/i.test(linter) && gitDir !== process.cwd()) {
+  } else if (/^git(\.exe)?/i.test(command) && gitDir !== process.cwd()) {
     // Only use gitDir as CWD if we are using the git binary
     // e.g `npm` should run tasks in the actual CWD
     execaOptions.cwd = gitDir
@@ -109,20 +102,20 @@ module.exports = function resolveTaskFn({
   if (shell) {
     execaOptions.shell = true
     // If `shell`, passed command shouldn't be parsed
-    // If `linter` is a function, command already includes `pathsToLint`.
-    cmd = isFn ? linter : `${linter} ${pathsToLint.join(' ')}`
+    // If `linter` is a function, command already includes `files`.
+    cmd = isFn ? command : `${command} ${files.join(' ')}`
   } else {
-    const [parsedCmd, ...parsedArgs] = stringArgv.parseArgsStringToArgv(linter)
+    const [parsedCmd, ...parsedArgs] = stringArgv.parseArgsStringToArgv(command)
     cmd = parsedCmd
-    args = isFn ? parsedArgs : parsedArgs.concat(pathsToLint)
+    args = isFn ? parsedArgs : parsedArgs.concat(files)
   }
 
   return ctx =>
     execLinter(cmd, args, execaOptions).then(result => {
       if (result.failed || result.killed || result.signal != null) {
-        throw makeErr(linter, result, ctx)
+        throw makeErr(command, result, ctx)
       }
 
-      return successMsg(linter)
+      return successMsg(command)
     })
 }

package/src/runAll.js

@@ -73,7 +73,7 @@ https://github.com/okonet/lint-staged#using-js-functions-to-customize-linter-com
     title: `Running tasks for ${task.pattern}`,
     task: async () =>
       new Listr(
-        await makeCmdTasks({ commands: task.commands, gitDir, shell, pathsToLint: task.fileList }),
+        await makeCmdTasks({ commands: task.commands, files: task.fileList, gitDir, shell }),
         {
           // In sub-tasks we don't want to run concurrently
           // and we want to abort on errors