[Breaking] Remove RepositoryDoesNotExist and GitNotFound errors

Instead of synchronously stat'ing the path on ENOENT when it's possible that the caller doesn't care we'll leave it up to callers to choose whether to try to detect why the exec failed.

Note that the pathExist approach was subject to race conditions and that there's no guarantee you'd ever be able to figure out exactly why the call failed

Author: niik

docs/overview.md

@@ -2,14 +2,11 @@
 
 `dugite` is a wrapper on top of the Git command line interface, with some helpers to make it easy to consume in your Node applications. The important parts:
 
- - `GitProcess` - the core of the library - `GitProcess.exec` is how you
-    interact with Git
- - `IGitResult` - the abstraction for a result returned by Git - contains
-    exit code and standard output/error text
- - `IGitExecutionOptions` - additional overrides to change the behaviour
-    of `GitProcess` (see [API extensibility](./api-extensibility.md) for
-    more information)
- - `GitError` - a collection of known error codes that `dugite` can understand
- - `GitNotFoundErrorCode` and `RepositoryDoesNotExistErrorCode` - error codes
-    that `dugite` will raise for exceptional scenarios when invoking Git - you
-    should check for these in your code.
+- `GitProcess` - the core of the library - `GitProcess.exec` is how you
+  interact with Git
+- `IGitResult` - the abstraction for a result returned by Git - contains
+  exit code and standard output/error text
+- `IGitExecutionOptions` - additional overrides to change the behaviour
+  of `GitProcess` (see [API extensibility](./api-extensibility.md) for
+  more information)
+- `GitError` - a collection of known error codes that `dugite` can understand

lib/errors.ts

@@ -169,15 +169,6 @@ export const GitErrorRegexes: { [regexp: string]: GitError } = {
     GitError.PathExistsButNotInRef,
 }
 
-/**
- * The error code for when git cannot be found. This most likely indicates a
- * problem with dugite itself.
- */
-export const GitNotFoundErrorCode = 'git-not-found-error'
-
-/** The error code for when the path to a repository doesn't exist. */
-export const RepositoryDoesNotExistErrorCode = 'repository-does-not-exist-error'
-
 export class ExecError extends Error {
   constructor(
     public readonly message: string,

lib/git-process.ts

@@ -1,12 +1,5 @@
-import * as fs from 'fs'
 import { execFile, ExecFileOptions, spawn } from 'child_process'
-import {
-  GitError,
-  GitErrorRegexes,
-  RepositoryDoesNotExistErrorCode,
-  GitNotFoundErrorCode,
-  ExecError,
-} from './errors'
+import { GitError, GitErrorRegexes, ExecError } from './errors'
 import { ChildProcess } from 'child_process'
 
 import { setupEnvironment } from './git-environment'
@@ -133,15 +126,6 @@ interface ErrorWithCode extends Error {
 }
 
 export class GitProcess {
-  private static pathExists(path: string): Boolean {
-    try {
-      fs.accessSync(path, (fs as any).F_OK)
-      return true
-    } catch {
-      return false
-    }
-  }
-
   /**
    * Execute a command and interact with the process outputs directly.
    *
@@ -235,19 +219,18 @@ export class GitProcess {
           // If the error's code is a string then it means the code isn't the
           // process's exit code but rather an error coming from Node's bowels,
           // e.g., ENOENT.
-          let { message, code } = err
+          let { message } = err
 
           if (err.code === 'ENOENT') {
-            if (GitProcess.pathExists(path) === false) {
-              message = 'Unable to find path to repository on disk.'
-              code = RepositoryDoesNotExistErrorCode
-            } else {
-              message = `Git could not be found at the expected path: '${gitLocation}'. This might be a problem with how the application is packaged, so confirm this folder hasn't been removed when packaging.`
-              code = GitNotFoundErrorCode
-            }
+            message =
+              `ENOENT: Git failed to execute. This typically means that ` +
+              `the path provided doesn't exist or that the Git executable ` +
+              `could not be found which could indicate a problem with the ` +
+              `packaging of dugite. Verify that resolveGitBinary returns a ` +
+              `valid path to the git binary.`
           }
 
-          reject(new ExecError(message, code, stdout, stderr, err))
+          reject(new ExecError(message, err.code, stdout, stderr, err))
         }
       )
 

lib/index.ts

@@ -1,7 +1,3 @@
 export { GitProcess, IGitResult, IGitExecutionOptions } from './git-process'
-export {
-  GitError,
-  RepositoryDoesNotExistErrorCode,
-  GitNotFoundErrorCode,
-} from './errors'
+export { GitError } from './errors'
 export * from './git-environment'

test/fast/git-process-test.ts

@@ -2,11 +2,7 @@ import * as path from 'path'
 import * as fs from 'fs'
 import * as crypto from 'crypto'
 
-import {
-  GitProcess,
-  GitError,
-  RepositoryDoesNotExistErrorCode,
-} from '../../lib'
+import { GitProcess, GitError } from '../../lib'
 import { ExecError, GitErrorRegexes } from '../../lib/errors'
 import {
   initialize,
@@ -289,8 +285,8 @@ describe('git-process', () => {
         error = e as Error
       }
 
-      expect(error!.message).toBe('Unable to find path to repository on disk.')
-      expect((error as any).code).toBe(RepositoryDoesNotExistErrorCode)
+      expect(error!.message).toContain('Git failed to execute.')
+      expect((error as any).code).toBe('ENOENT')
     })
 
     it('can parse HTTPS auth errors', () => {