lint-staged 11.3.0-beta.2 → 12.0.3

package/lib/gitWorkflow.js

@@ -1,21 +1,20 @@
-'use strict'
+import path from 'path'
 
-const debug = require('debug')('lint-staged:git')
-const fs = require('fs')
-const path = require('path')
-const { promisify } = require('util')
+import debug from 'debug'
 
-const execGit = require('./execGit')
-const {
+import { execGit } from './execGit.js'
+import { readFile, unlink, writeFile } from './file.js'
+import {
   GitError,
+  RestoreOriginalStateError,
   ApplyEmptyCommitError,
+  GetBackupStashError,
   HideUnstagedChangesError,
-  RestoreOriginalStateError,
+  RestoreMergeStatusError,
   RestoreUnstagedChangesError,
-} = require('./symbols')
-const unlink = require('./unlink')
+} from './symbols.js'
 
-const fsReadFile = promisify(fs.readFile)
+const debugLog = debug('lint-staged:GitWorkflow')
 
 const MERGE_HEAD = 'MERGE_HEAD'
 const MERGE_MODE = 'MERGE_MODE'
@@ -43,8 +42,9 @@ const processRenames = (files, includeRenameFrom = true) =>
     return flattened
   }, [])
 
+const STASH = 'lint-staged automatic backup'
+
 const PATCH_UNSTAGED = 'lint-staged_unstaged.patch'
-const PATCH_PARTIAL = 'lint-staged_partial.patch'
 
 const GIT_DIFF_ARGS = [
   '--binary', // support binary files
@@ -64,7 +64,7 @@ const handleError = (error, ctx, symbol) => {
   throw error
 }
 
-class GitWorkflow {
+export class GitWorkflow {
   constructor({ allowEmpty, gitConfigDir, gitDir, matchedFileChunks }) {
     this.execGit = (args, options = {}) => execGit(args, { ...options, cwd: gitDir })
     this.deletedFiles = []
@@ -91,13 +91,76 @@ class GitWorkflow {
     return path.resolve(this.gitConfigDir, `./${filename}`)
   }
 
+  /**
+   * Get name of backup stash
+   */
+  async getBackupStash(ctx) {
+    const stashes = await this.execGit(['stash', 'list'])
+    const index = stashes.split('\n').findIndex((line) => line.includes(STASH))
+    if (index === -1) {
+      ctx.errors.add(GetBackupStashError)
+      throw new Error('lint-staged automatic backup is missing!')
+    }
+    return `refs/stash@{${index}}`
+  }
+
+  /**
+   * Get a list of unstaged deleted files
+   */
+  async getDeletedFiles() {
+    debugLog('Getting deleted files...')
+    const lsFiles = await this.execGit(['ls-files', '--deleted'])
+    const deletedFiles = lsFiles
+      .split('\n')
+      .filter(Boolean)
+      .map((file) => path.resolve(this.gitDir, file))
+    debugLog('Found deleted files:', deletedFiles)
+    return deletedFiles
+  }
+
+  /**
+   * Save meta information about ongoing git merge
+   */
+  async backupMergeStatus() {
+    debugLog('Backing up merge state...')
+    await Promise.all([
+      readFile(this.mergeHeadFilename).then((buffer) => (this.mergeHeadBuffer = buffer)),
+      readFile(this.mergeModeFilename).then((buffer) => (this.mergeModeBuffer = buffer)),
+      readFile(this.mergeMsgFilename).then((buffer) => (this.mergeMsgBuffer = buffer)),
+    ])
+    debugLog('Done backing up merge state!')
+  }
+
+  /**
+   * Restore meta information about ongoing git merge
+   */
+  async restoreMergeStatus(ctx) {
+    debugLog('Restoring merge state...')
+    try {
+      await Promise.all([
+        this.mergeHeadBuffer && writeFile(this.mergeHeadFilename, this.mergeHeadBuffer),
+        this.mergeModeBuffer && writeFile(this.mergeModeFilename, this.mergeModeBuffer),
+        this.mergeMsgBuffer && writeFile(this.mergeMsgFilename, this.mergeMsgBuffer),
+      ])
+      debugLog('Done restoring merge state!')
+    } catch (error) {
+      debugLog('Failed restoring merge state with error:')
+      debugLog(error)
+      handleError(
+        new Error('Merge state could not be restored due to an error!'),
+        ctx,
+        RestoreMergeStatusError
+      )
+    }
+  }
+
   /**
    * Get a list of all files with both staged and unstaged modifications.
    * Renames have special treatment, since the single status line includes
    * both the "from" and "to" filenames, where "from" is no longer on disk.
    */
   async getPartiallyStagedFiles() {
-    debug('Getting partially staged files...')
+    debugLog('Getting partially staged files...')
     const status = await this.execGit(['status', '-z'])
     /**
      * See https://git-scm.com/docs/git-status#_short_format
@@ -117,19 +180,16 @@ class GitWorkflow {
       })
       .map((line) => line.substr(3)) // Remove first three letters (index, workingTree, and a whitespace)
       .filter(Boolean) // Filter empty string
-    debug('Found partially staged files:', partiallyStaged)
+    debugLog('Found partially staged files:', partiallyStaged)
     return partiallyStaged.length ? partiallyStaged : null
   }
 
   /**
-   * Create a diff of partially staged files.
+   * Create a diff of partially staged files and backup stash if enabled.
    */
   async prepare(ctx) {
     try {
-      debug('Backing up original state...')
-
-      const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
-      await this.execGit(['diff', ...GIT_DIFF_ARGS, '--output', unstagedPatch])
+      debugLog('Backing up original state...')
 
       // Get a list of files with bot staged and unstaged changes.
       // Unstaged changes to these files should be hidden before the tasks run.
@@ -137,14 +197,33 @@ class GitWorkflow {
 
       if (this.partiallyStagedFiles) {
         ctx.hasPartiallyStagedFiles = true
-        const partialPatch = this.getHiddenFilepath(PATCH_PARTIAL)
+        const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
         const files = processRenames(this.partiallyStagedFiles)
-        await this.execGit(['diff', ...GIT_DIFF_ARGS, '--output', partialPatch, '--', ...files])
+        await this.execGit(['diff', ...GIT_DIFF_ARGS, '--output', unstagedPatch, '--', ...files])
       } else {
         ctx.hasPartiallyStagedFiles = false
       }
 
-      debug('Done backing up original state!')
+      /**
+       * If backup stash should be skipped, no need to continue
+       */
+      if (!ctx.shouldBackup) return
+
+      // When backup is enabled, the revert will clear ongoing merge status.
+      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 `git stash --keep-index` option resurrects deleted files
+      // - git stash can't infer RD or MD states correctly, and will lose the deletion
+      this.deletedFiles = await this.getDeletedFiles()
+
+      // Save stash of all staged files.
+      // The `stash create` command creates a dangling commit without removing any files,
+      // and `stash store` saves it as an actual stash.
+      const hash = await this.execGit(['stash', 'create'])
+      await this.execGit(['stash', 'store', '--quiet', '--message', STASH, hash])
+
+      debugLog('Done backing up original state!')
     } catch (error) {
       handleError(error, ctx)
     }
@@ -166,18 +245,12 @@ class GitWorkflow {
     }
   }
 
-  /** Add all task modifications to index for files that were staged before running. */
+  /**
+   * 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) {
-    debug('Adding task modifications to index...')
-
-    if (ctx.hasInitialCommit) {
-      const stagedFilesAfterAdd = await this.execGit(['diff', 'HEAD'])
-      if (!stagedFilesAfterAdd && !this.allowEmpty) {
-        // Tasks reverted all staged changes and the commit would be empty
-        // Throw error to stop commit unless `--allow-empty` was used
-        handleError(new Error('Prevented an empty git commit!'), ctx, ApplyEmptyCommitError)
-      }
-    }
+    debugLog('Adding task modifications to index...')
 
     // `matchedFileChunks` 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.
@@ -187,26 +260,13 @@ class GitWorkflow {
       await this.execGit(['add', '--', ...files])
     }
 
-    debug('Done adding task modifications to index!')
-  }
-
-  /**
-   * Restore original HEAD state in case of errors
-   */
-  async restoreOriginalState(ctx) {
-    try {
-      debug('Restoring original state...')
-      await this.execGit(['checkout', '--force', '--', '.'])
-
-      const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
-      const hasContents = !!(await fsReadFile(unstagedPatch)).toString()
-      if (hasContents) {
-        await this.execGit(['apply', ...GIT_APPLY_ARGS, unstagedPatch])
-      }
+    debugLog('Done adding task modifications to index!')
 
-      debug('Done restoring original state!')
-    } catch (error) {
-      handleError(error, ctx, RestoreOriginalStateError)
+    const stagedFilesAfterAdd = await this.execGit(['diff', '--name-only', '--cached'])
+    if (!stagedFilesAfterAdd && !this.allowEmpty) {
+      // Tasks reverted all staged changes and the commit would be empty
+      // Throw error to stop commit unless `--allow-empty` was used
+      handleError(new Error('Prevented an empty git commit!'), ctx, ApplyEmptyCommitError)
     }
   }
 
@@ -215,21 +275,21 @@ class GitWorkflow {
    * this is probably because of conflicts between new task modifications.
    * 3-way merge usually fixes this, and in case it doesn't we should just give up and throw.
    */
-  async restorePartialChanges(ctx) {
-    debug('Restoring unstaged changes...')
-    const partialPatch = this.getHiddenFilepath(PATCH_PARTIAL)
+  async restoreUnstagedChanges(ctx) {
+    debugLog('Restoring unstaged changes...')
+    const unstagedPatch = this.getHiddenFilepath(PATCH_UNSTAGED)
     try {
-      await this.execGit(['apply', ...GIT_APPLY_ARGS, partialPatch])
+      await this.execGit(['apply', ...GIT_APPLY_ARGS, unstagedPatch])
     } catch (applyError) {
-      debug('Error while restoring changes:')
-      debug(applyError)
-      debug('Retrying with 3-way merge')
+      debugLog('Error while restoring changes:')
+      debugLog(applyError)
+      debugLog('Retrying with 3-way merge')
       try {
         // Retry with a 3-way merge if normal apply fails
-        await this.execGit(['apply', ...GIT_APPLY_ARGS, '--3way', partialPatch])
+        await this.execGit(['apply', ...GIT_APPLY_ARGS, '--3way', unstagedPatch])
       } catch (threeWayApplyError) {
-        debug('Error while restoring unstaged changes using 3-way merge:')
-        debug(threeWayApplyError)
+        debugLog('Error while restoring unstaged changes using 3-way merge:')
+        debugLog(threeWayApplyError)
         handleError(
           new Error('Unstaged changes could not be restored due to a merge conflict!'),
           ctx,
@@ -240,15 +300,39 @@ class GitWorkflow {
   }
 
   /**
-   * Drop the created diff file after everything has run.
-   * Won't throw if the file has already been deleted (theoretically).
+   * Restore original HEAD state in case of errors
+   */
+  async restoreOriginalState(ctx) {
+    try {
+      debugLog('Restoring original state...')
+      await this.execGit(['reset', '--hard', 'HEAD'])
+      await this.execGit(['stash', 'apply', '--quiet', '--index', await this.getBackupStash(ctx)])
+
+      // Restore meta information about ongoing git merge
+      await this.restoreMergeStatus(ctx)
+
+      // If stashing resurrected deleted files, clean them out
+      await Promise.all(this.deletedFiles.map((file) => unlink(file)))
+
+      // Clean out patch
+      await unlink(this.getHiddenFilepath(PATCH_UNSTAGED))
+
+      debugLog('Done restoring original state!')
+    } catch (error) {
+      handleError(error, ctx, RestoreOriginalStateError)
+    }
+  }
+
+  /**
+   * Drop the created stashes after everything has run
    */
-  async cleanup() {
-    debug('Removing temp files...')
-    await unlink(this.getHiddenFilepath(PATCH_UNSTAGED))
-    await unlink(this.getHiddenFilepath(PATCH_PARTIAL))
-    debug('Done removing temp files!')
+  async cleanup(ctx) {
+    try {
+      debugLog('Dropping backup stash...')
+      await this.execGit(['stash', 'drop', '--quiet', await this.getBackupStash(ctx)])
+      debugLog('Done dropping backup stash!')
+    } catch (error) {
+      handleError(error, ctx)
+    }
   }
 }
-
-module.exports = GitWorkflow

package/lib/index.js

@@ -1,15 +1,20 @@
-'use strict'
-
-const { cosmiconfig } = require('cosmiconfig')
-const debugLog = require('debug')('lint-staged')
-const stringifyObject = require('stringify-object')
-
-const { PREVENTED_EMPTY_COMMIT, GIT_ERROR } = require('./messages')
-const printTaskOutput = require('./printTaskOutput')
-const runAll = require('./runAll')
-const { ApplyEmptyCommitError, ConfigNotFoundError, GitError } = require('./symbols')
-const validateConfig = require('./validateConfig')
-const validateOptions = require('./validateOptions')
+import { cosmiconfig } from 'cosmiconfig'
+import debug from 'debug'
+import inspect from 'object-inspect'
+
+import { PREVENTED_EMPTY_COMMIT, GIT_ERROR, RESTORE_STASH_EXAMPLE } from './messages.js'
+import { printTaskOutput } from './printTaskOutput.js'
+import { runAll } from './runAll.js'
+import {
+  ApplyEmptyCommitError,
+  ConfigNotFoundError,
+  GetBackupStashError,
+  GitError,
+} from './symbols.js'
+import { validateConfig } from './validateConfig.js'
+import { validateOptions } from './validateOptions.js'
+
+const debugLog = debug('lint-staged')
 
 const resolveConfig = (configPath) => {
   try {
@@ -53,8 +58,8 @@ const loadConfig = (configPath) => {
  * @param {number} [options.maxArgLength] - Maximum argument string length
  * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
  * @param {boolean} [options.relative] - Pass relative filepaths to tasks
- * @param {boolean} [options.reset] - Reset changes in case of errors
  * @param {boolean|string} [options.shell] - Skip parsing of tasks for better shell support
+ * @param {boolean} [options.stash] - Enable the backup stash, and revert in case of errors
  * @param {boolean} [options.verbose] - Show task output even when tasks succeed; by default only failed output is shown
  * @param {Logger} [logger]
  *
@@ -71,14 +76,13 @@ const lintStaged = async (
     maxArgLength,
     quiet = false,
     relative = false,
-    reset = true,
     shell = false,
-    stash, // kept for backwards-compatibility
+    stash = true,
     verbose = false,
   } = {},
   logger = console
 ) => {
-  await validateOptions({ shell, stash }, logger)
+  await validateOptions({ shell }, logger)
 
   debugLog('Loading config using `cosmiconfig`')
 
@@ -100,7 +104,7 @@ const lintStaged = async (
   if (debug) {
     // Log using logger to be able to test through `consolemock`.
     logger.log('Running lint-staged with the following config:')
-    logger.log(stringifyObject(config, { indent: '  ' }))
+    logger.log(inspect(config, { indent: 2 }))
   } else {
     // We might not be in debug mode but `DEBUG=lint-staged*` could have
     // been set.
@@ -122,8 +126,8 @@ const lintStaged = async (
         maxArgLength,
         quiet,
         relative,
-        reset: reset || !!stash,
         shell,
+        stash,
         verbose,
       },
       logger
@@ -136,8 +140,12 @@ const lintStaged = async (
       const { ctx } = runAllError
       if (ctx.errors.has(ApplyEmptyCommitError)) {
         logger.warn(PREVENTED_EMPTY_COMMIT)
-      } else if (ctx.errors.has(GitError)) {
+      } else if (ctx.errors.has(GitError) && !ctx.errors.has(GetBackupStashError)) {
         logger.error(GIT_ERROR)
+        if (ctx.shouldBackup) {
+          // No sense to show this if the backup stash itself is missing.
+          logger.error(RESTORE_STASH_EXAMPLE)
+        }
       }
 
       printTaskOutput(ctx, logger)
@@ -149,4 +157,4 @@ const lintStaged = async (
   }
 }
 
-module.exports = lintStaged
+export default lintStaged

package/lib/makeCmdTasks.js

@@ -1,10 +1,10 @@
-'use strict'
+import cliTruncate from 'cli-truncate'
+import debug from 'debug'
 
-const cliTruncate = require('cli-truncate')
-const debug = require('debug')('lint-staged:make-cmd-tasks')
+import { configurationError } from './messages.js'
+import { resolveTaskFn } from './resolveTaskFn.js'
 
-const { configurationError } = require('./messages')
-const resolveTaskFn = require('./resolveTaskFn')
+const debugLog = debug('lint-staged:makeCmdTasks')
 
 const STDOUT_COLUMNS_DEFAULT = 80
 
@@ -34,8 +34,8 @@ const getTitleLength = (renderer, columns = process.stdout.columns) => {
  * @param {Boolean} shell
  * @param {Boolean} verbose
  */
-const makeCmdTasks = async ({ commands, files, gitDir, renderer, shell, verbose }) => {
-  debug('Creating listr tasks for commands %o', commands)
+export const makeCmdTasks = async ({ commands, files, gitDir, renderer, shell, verbose }) => {
+  debugLog('Creating listr tasks for commands %o', commands)
   const commandArray = Array.isArray(commands) ? commands : [commands]
   const cmdTasks = []
 
@@ -68,5 +68,3 @@ const makeCmdTasks = async ({ commands, files, gitDir, renderer, shell, verbose
 
   return cmdTasks
 }
-
-module.exports = makeCmdTasks

package/lib/messages.js

@@ -1,55 +1,48 @@
-'use strict'
+import { redBright, bold, yellow } from 'colorette'
+import inspect from 'object-inspect'
 
-const { redBright, bold, yellow } = require('colorette')
-const format = require('stringify-object')
+import { error, info, warning } from './figures.js'
 
-const { error, info, warning } = require('./figures')
-
-const configurationError = (opt, helpMsg, value) =>
+export const configurationError = (opt, helpMsg, value) =>
   `${redBright(`${error} Validation Error:`)}
 
   Invalid value for '${bold(opt)}': ${bold(
-    format(value, { inlineCharacterLimit: Number.POSITIVE_INFINITY })
+    inspect(value, { inlineCharacterLimit: Number.POSITIVE_INFINITY })
   )}
 
   ${helpMsg}`
 
-const NOT_GIT_REPO = redBright(`${error} Current directory is not a git directory!`)
+export const NOT_GIT_REPO = redBright(`${error} Current directory is not a git directory!`)
 
-const FAILED_GET_STAGED_FILES = redBright(`${error} Failed to get staged files!`)
+export const FAILED_GET_STAGED_FILES = redBright(`${error} Failed to get staged files!`)
 
-const incorrectBraces = (before, after) =>
+export const incorrectBraces = (before, after) =>
   yellow(
     `${warning} Detected incorrect braces with only single value: \`${before}\`. Reformatted as: \`${after}\`
 `
   )
 
-const NO_STAGED_FILES = `${info} No staged files found.`
+export const NO_STAGED_FILES = `${info} No staged files found.`
 
-const NO_TASKS = `${info} No staged files match any configured task.`
+export const NO_TASKS = `${info} No staged files match any configured task.`
 
-const skippingReset = (hasInitialCommit) => {
-  const reason = hasInitialCommit ? '`--no-reset` was used' : 'there’s no initial commit yet'
-  return yellow(`${warning} Changes won't be reset because ${reason}.\n`)
+export const skippingBackup = (hasInitialCommit) => {
+  const reason = hasInitialCommit ? '`--no-stash` was used' : 'there’s no initial commit yet'
+  return yellow(`${warning} Skipping backup because ${reason}.\n`)
 }
 
-const DEPRECATED_GIT_ADD = yellow(
+export const DEPRECATED_GIT_ADD = yellow(
   `${warning} Some of your tasks use \`git add\` command. Please remove it from the config since all modifications made by tasks will be automatically added to the git commit index.
 `
 )
 
-const DEPRECATED_NO_STASH = yellow(
-  `${warning} The \`--no-stash\` option has been renamed to \`--no-reset\`.
-`
-)
-
-const TASK_ERROR = 'Skipped because of errors from tasks.'
+export const TASK_ERROR = 'Skipped because of errors from tasks.'
 
-const SKIPPED_GIT_ERROR = 'Skipped because of previous git error.'
+export const SKIPPED_GIT_ERROR = 'Skipped because of previous git error.'
 
-const GIT_ERROR = `\n  ${redBright(`${error} lint-staged failed due to a git error.`)}`
+export const GIT_ERROR = `\n  ${redBright(`${error} lint-staged failed due to a git error.`)}`
 
-const invalidOption = (name, value, message) => `${redBright(`${error} Validation Error:`)}
+export const invalidOption = (name, value, message) => `${redBright(`${error} Validation Error:`)}
 
   Invalid value for option '${bold(name)}': ${bold(value)}
 
@@ -57,27 +50,16 @@ const invalidOption = (name, value, message) => `${redBright(`${error} Validatio
 
 See https://github.com/okonet/lint-staged#command-line-flags`
 
-const PREVENTED_EMPTY_COMMIT = `
+export const PREVENTED_EMPTY_COMMIT = `
   ${yellow(`${warning} lint-staged prevented an empty git commit.
   Use the --allow-empty option to continue, or check your task configuration`)}
 `
 
-const CONFIG_STDIN_ERROR = 'Error: Could not read config from stdin.'
-
-module.exports = {
-  CONFIG_STDIN_ERROR,
-  configurationError,
-  DEPRECATED_GIT_ADD,
-  DEPRECATED_NO_STASH,
-  FAILED_GET_STAGED_FILES,
-  GIT_ERROR,
-  incorrectBraces,
-  invalidOption,
-  NO_STAGED_FILES,
-  NO_TASKS,
-  NOT_GIT_REPO,
-  PREVENTED_EMPTY_COMMIT,
-  SKIPPED_GIT_ERROR,
-  skippingReset,
-  TASK_ERROR,
-}
+export const RESTORE_STASH_EXAMPLE = `  Any lost modifications can be restored from a git stash:
+
+    > git stash list
+    stash@{0}: automatic lint-staged backup
+    > git stash apply --index stash@{0}
+`
+
+export const CONFIG_STDIN_ERROR = 'Error: Could not read config from stdin.'

package/lib/printTaskOutput.js

@@ -1,16 +1,12 @@
-'use strict'
-
 /**
  * Handle logging of listr `ctx.output` to the specified `logger`
  * @param {Object} ctx - The listr initial state
  * @param {Object} logger - The logger
  */
-const printTaskOutput = (ctx = {}, logger) => {
+export const printTaskOutput = (ctx = {}, logger) => {
   if (!Array.isArray(ctx.output)) return
   const log = ctx.errors && ctx.errors.size > 0 ? logger.error : logger.log
   for (const line of ctx.output) {
     log(line)
   }
 }
-
-module.exports = printTaskOutput

package/lib/resolveGitRepo.js

@@ -1,15 +1,13 @@
-'use strict'
+import { promises as fs } from 'fs'
+import path from 'path'
 
-const normalize = require('normalize-path')
-const debugLog = require('debug')('lint-staged:resolveGitRepo')
-const fs = require('fs')
-const path = require('path')
-const { promisify } = require('util')
+import debug from 'debug'
+import normalize from 'normalize-path'
 
-const execGit = require('./execGit')
+import { execGit } from './execGit.js'
+import { readFile } from './file.js'
 
-const fsLstat = promisify(fs.lstat)
-const fsReadFile = promisify(fs.readFile)
+const debugLog = debug('lint-staged:resolveGitRepo')
 
 /**
  * Resolve path to the .git directory, with special handling for
@@ -17,15 +15,16 @@ const fsReadFile = promisify(fs.readFile)
  */
 const resolveGitConfigDir = async (gitDir) => {
   const defaultDir = normalize(path.join(gitDir, '.git'))
-  const stats = await fsLstat(defaultDir)
+  const stats = await fs.lstat(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 fsReadFile(defaultDir)).toString()
+  const file = (await readFile(defaultDir)).toString()
   return path.resolve(gitDir, file.replace(/^gitdir: /, '')).trim()
 }
 
-const determineGitDir = (cwd, relativeDir) => {
+// exported for test
+export const determineGitDir = (cwd, relativeDir) => {
   // if relative dir and cwd have different endings normalize it
   // this happens under windows, where normalize is unable to normalize git's output
   if (relativeDir && relativeDir.endsWith(path.sep)) {
@@ -43,7 +42,7 @@ const determineGitDir = (cwd, relativeDir) => {
 /**
  * Resolve git directory and possible submodule paths
  */
-const resolveGitRepo = async (cwd = process.cwd()) => {
+export const resolveGitRepo = async (cwd = process.cwd()) => {
   try {
     debugLog('Resolving git repo from `%s`', cwd)
 
@@ -68,8 +67,3 @@ const resolveGitRepo = async (cwd = process.cwd()) => {
     return { error, gitDir: null, gitConfigDir: null }
   }
 }
-
-module.exports = resolveGitRepo
-
-// exported for test
-module.exports.determineGitDir = determineGitDir