Git workflow

.travis.yml

@@ -7,7 +7,6 @@ node_js:
   - '10'
   - '9'
   - '8'
-  - '6'
 
 before_install: yarn global add greenkeeper-lockfile@1
 install: yarn install

README.md

@@ -133,15 +133,10 @@ To extend and customise lint-staged, advanced options are available. To use thes
 {
   "lint-staged": {
     "linters": {
-      "*.{js,scss}": [
-        "some command",
-        "git add"
-      ]
+      "*.{js,scss}": ["some command", "git add"]
     },
-    "ignore": [
-      "**/dist/*.min.js"
-    ]
-  },
+    "ignore": ["**/dist/*.min.js"]
+  }
 }
 ```
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-staged",
-  "version": "0.0.0-development",
+  "version": "8.0.0-beta.2",
   "description": "Lint files staged by git",
   "license": "MIT",
   "repository": "https://github.com/okonet/lint-staged",
@@ -10,12 +10,12 @@
     "Suhas Karanth <sudo.suhas@gmail.com>"
   ],
   "engines": {
-    "node": ">=6"
+    "node": ">=8.0.0"
   },
   "bin": "index.js",
   "files": ["index.js", "src"],
   "scripts": {
-    "precommit": "node index.js",
+    "precommit": "node index.js --debug",
     "cz": "git-cz",
     "lint:base": "eslint --rule \"prettier/prettier: 2\"",
     "lint": "npm run lint:base -- .",
@@ -25,17 +25,22 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
+    "async-exit-hook": "^2.0.1",
     "chalk": "^2.3.1",
     "commander": "^2.14.1",
     "cosmiconfig": "^5.0.2",
     "debug": "^3.1.0",
     "dedent": "^0.7.0",
-    "execa": "^0.9.0",
+    "execa": "^1.0.0",
     "find-parent-dir": "^0.3.0",
+    "fs-promise": "^2.0.3",
+    "g-status": "^2.0.2",
     "is-glob": "^4.0.0",
     "is-windows": "^1.0.2",
     "jest-validate": "^23.5.0",
-    "listr": "^0.14.1",
+    "listr": "^0.14.2",
+    "listr-update-renderer":
+      "https://github.com/okonet/listr-update-renderer/tarball/upgrade-log-update",
     "lodash": "^4.17.5",
     "log-symbols": "^2.2.0",
     "micromatch": "^3.1.8",
@@ -58,9 +63,10 @@
     "eslint-config-okonet": "^5.0.1",
     "eslint-plugin-node": "^6.0.0",
     "husky": "^0.14.3",
-    "jest": "^22.4.0",
+    "jest": "^22.4.3",
     "jsonlint": "^1.6.2",
-    "prettier": "1.11.1"
+    "prettier": "1.11.1",
+    "tmp": "0.0.33"
   },
   "config": {
     "commitizen": {

src/gitWorkflow.js

@@ -0,0 +1,174 @@
+'use strict'
+
+const path = require('path')
+const execa = require('execa')
+const gStatus = require('g-status')
+const fsp = require('fs-promise')
+const debug = require('debug')('lint-staged:git')
+
+let workingCopyTree = null
+let indexTree = null
+let formattedIndexTree = null
+
+function getAbsolutePath(dir) {
+  return path.isAbsolute(dir) ? dir : path.resolve(dir)
+}
+
+async function execGit(cmd, options) {
+  const cwd = options && options.cwd ? options.cwd : process.cwd()
+  debug('Running git command', cmd)
+  try {
+    const { stdout } = await execa('git', [].concat(cmd), {
+      cwd: getAbsolutePath(cwd)
+    })
+    return stdout
+  } catch (err) {
+    throw new Error(err)
+  }
+}
+
+async function writeTree(options) {
+  return execGit(['write-tree'], options)
+}
+
+async function getDiffForTrees(tree1, tree2, options) {
+  return execGit(
+    [
+      'diff-tree',
+      '--ignore-submodules',
+      '--binary',
+      '--no-color',
+      '--no-ext-diff',
+      '--unified=0',
+      tree1,
+      tree2
+    ],
+    options
+  )
+}
+
+async function hasPartiallyStagedFiles(options) {
+  const files = await gStatus(options)
+  const partiallyStaged = files.filter(file => file.index !== ' ' && file.workingTree !== ' ')
+  return partiallyStaged.length > 0
+}
+
+async function generatePatchForTrees(tree1, tree2, options) {
+  // TODO: Use stdin instead of the file for patches
+  const cwd = options && options.cwd ? options.cwd : process.cwd()
+  const patch = await getDiffForTrees(tree1, tree2, options)
+  if (patch.length) {
+    const filePath = path.join(cwd, '.lint-staged.patch')
+    debug(`Stashing unstaged files to ${filePath}...`)
+    await fsp.writeFile(filePath, `${patch}\n`) // The new line is somehow required for patch to not be corrupted
+    return filePath // Resolve with filePath
+  }
+  debug('Nothing to do...')
+  return null
+}
+
+// eslint-disable-next-line
+async function gitStash(options) {
+  debug('Stashing files...')
+  // Save ref to the current index
+  indexTree = await writeTree(options)
+  // Add working copy changes to index
+  await execGit(['add', '.'], options)
+  // Save ref to the working copy index
+  workingCopyTree = await writeTree(options)
+  // Restore the current index
+  await execGit(['read-tree', indexTree], options)
+  // Remove all modifications
+  await execGit(['checkout-index', '-af'], options)
+  // await execGit(['clean', '-dfx'], options)
+  debug('Done stashing files!')
+  return [workingCopyTree, indexTree]
+}
+
+async function updateStash(options) {
+  formattedIndexTree = await writeTree(options)
+  return formattedIndexTree
+}
+
+async function applyPathFor(tree1, tree2, options) {
+  const patchPath = await generatePatchForTrees(tree1, tree2, options)
+  if (patchPath) {
+    try {
+      /**
+       * Apply patch to index. We will apply it with --reject so it it will try apply hunk by hunk
+       * We're not interested in failied hunks since this mean that formatting conflicts with user changes
+       * and we prioritize user changes over formatter's
+       */
+      await execGit(
+        [
+          'apply',
+          '-v',
+          '--whitespace=nowarn',
+          '--reject',
+          '--recount',
+          '--unidiff-zero',
+          patchPath
+        ],
+        options
+      )
+    } catch (err) {
+      debug('Could not apply patch to the stashed files cleanly')
+      debug(err)
+      debug('Patch content:')
+      debug(await fsp.readFile(patchPath, { encoding: 'utf-8' }))
+      throw new Error('Could not apply patch to the stashed files cleanly.', err)
+    } finally {
+      // Delete patch file
+      await fsp.unlink(patchPath)
+    }
+  }
+}
+
+async function gitPop(options) {
+  if (workingCopyTree === null) {
+    throw new Error('Trying to restore from stash but could not find working copy stash.')
+  }
+
+  debug('Restoring working copy')
+  // Restore the stashed files in the index
+  await execGit(['read-tree', workingCopyTree], options)
+  // and sync it to the working copy (i.e. update files on fs)
+  await execGit(['checkout-index', '-af'], options)
+
+  // Then, restore the index after working copy is restored
+  if (indexTree !== null && formattedIndexTree === null) {
+    // Restore changes that were in index if there are no formatting changes
+    debug('Restoring index')
+    await execGit(['read-tree', indexTree], options)
+  } else {
+    /**
+     * There are formatting changes we want to restore in the index
+     * and in the working copy. So we start by restoring the index
+     * and after that we'll try to carry as many as possible changes
+     * to the working copy by applying the patch with --reject option.
+     */
+    debug('Restoring index with formatting changes')
+    await execGit(['read-tree', formattedIndexTree], options)
+    try {
+      await applyPathFor(indexTree, formattedIndexTree, options)
+    } catch (err) {
+      debug(
+        'Found conflicts between formatters and local changes. Formatters changes will be ignored for conflicted hunks.'
+      )
+    }
+  }
+  // Clean up references
+  workingCopyTree = null
+  indexTree = null
+  formattedIndexTree = null
+
+  return null
+}
+
+module.exports = {
+  execGit,
+  gitStashSave: gitStash,
+  gitStashPop: gitPop,
+  hasPartiallyStagedFiles,
+  updateStash
+}

src/index.js

@@ -66,7 +66,7 @@ module.exports = function lintStaged(logger = console, configPath, debugMode) {
         debug('Normalized config:\n%O', config)
       }
 
-      runAll(config)
+      return runAll(config)
         .then(() => {
           debug('linters were executed successfully!')
           // No errors, exiting with 0

src/resolveTaskFn.js

@@ -4,6 +4,7 @@ const chunk = require('lodash/chunk')
 const dedent = require('dedent')
 const isWindows = require('is-windows')
 const execa = require('execa')
+const chalk = require('chalk')
 const symbols = require('log-symbols')
 const pMap = require('p-map')
 const calcChunkSize = require('./calcChunkSize')
@@ -19,7 +20,7 @@ const debug = require('debug')('lint-staged:task')
  * @param {Array<string>} args
  * @param {Object} execaOptions
  * @param {Array<string>} pathsToLint
- * @return {Promise}
+ * @return {Promise} child_process
  */
 function execLinter(bin, args, execaOptions, pathsToLint) {
   const binArgs = args.concat(pathsToLint)
@@ -40,16 +41,33 @@ const successMsg = linter => `${symbols.success} ${linter} passed!`
  * log only once.
  *
  * @param {string} linter
- * @param {string} errStdout
- * @param {string} errStderr
+ * @param {Object} result
+ * @param {string} result.stdout
+ * @param {string} result.stderr
+ * @param {boolean} result.failed
+ * @param {boolean} result.killed
+ * @param {string} result.signal
+ * @param {Object} context (see https://github.com/SamVerschueren/listr#context)
  * @returns {Error}
  */
-function makeErr(linter, errStdout, errStderr) {
+function makeErr(linter, result, context = {}) {
+  // Indicate that some linter will fail so we don't update the index with formatting changes
+  context.hasErrors = true // eslint-disable-line no-param-reassign
+  const { stdout, stderr, failed, killed, signal } = result
+  let message = ''
+  if (failed) {
+    message = `${symbols.error} ${chalk.redBright(
+      `${linter} found some errors. Please fix them and try committing again.`
+    )}`
+  }
+  if (killed || signal != null) {
+    message = `${symbols.warning} ${chalk.yellow(`${linter} was terminated with ${signal}`)}`
+  }
   const err = new Error()
   err.privateMsg = dedent`
-    ${symbols.error} "${linter}" found some errors. Please fix them and try committing again.
-    ${errStdout}
-    ${errStderr}
+    \n\n\n${message}
+    ${stdout}
+    ${stderr}
   `
   return err
 }
@@ -79,11 +97,13 @@ module.exports = function resolveTaskFn(options) {
 
   if (!isWindows()) {
     debug('%s  OS: %s; File path chunking unnecessary', symbols.success, process.platform)
-    return () =>
+    return ctx =>
       execLinter(bin, args, execaOptions, pathsToLint).then(result => {
-        if (!result.failed) return successMsg(linter)
+        if (result.failed || result.killed || result.signal != null) {
+          throw makeErr(linter, result, ctx)
+        }
 
-        throw makeErr(linter, result.stdout, result.stderr)
+        return successMsg(linter)
       })
   }
 
@@ -97,7 +117,7 @@ module.exports = function resolveTaskFn(options) {
     process.platform,
     filePathChunks.length
   )
-  return () =>
+  return ctx =>
     pMap(filePathChunks, mapper, { concurrency })
       .catch(err => {
         /* This will probably never be called. But just in case.. */
@@ -107,12 +127,23 @@ module.exports = function resolveTaskFn(options) {
       `)
       })
       .then(results => {
-        const errors = results.filter(res => res.failed)
-        if (errors.length === 0) return successMsg(linter)
-
-        const errStdout = errors.map(err => err.stdout).join('')
-        const errStderr = errors.map(err => err.stderr).join('')
-
-        throw makeErr(linter, errStdout, errStderr)
+        const errors = results.filter(res => res.failed || res.killed)
+        const failed = results.some(res => res.failed)
+        const killed = results.some(res => res.killed)
+        const signals = results.map(res => res.signal).filter(Boolean)
+
+        if (failed || killed || signals.length > 0) {
+          const finalResult = {
+            stdout: errors.map(err => err.stdout).join(''),
+            stderr: errors.map(err => err.stderr).join(''),
+            failed,
+            killed,
+            signal: signals.join(', ')
+          }
+
+          throw makeErr(linter, finalResult, ctx)
+        }
+
+        return successMsg(linter)
       })
 }