git-chopstick-core 0.1.2 → 0.1.4

package/src/git/apply.ts

@@ -1,154 +0,0 @@
-import { GitError as DugiteError } from './exec.js'
-import { git } from './core.js'
-import {
-  WorkingDirectoryFileChange,
-  AppFileStatusKind,
-} from '../models/status.js'
-import { DiffType, ITextDiff, DiffSelection } from '../models/diff/index.js'
-import { Repository } from '../models/repository.js'
-import { getWorkingDirectoryDiff } from './diff.js'
-import { formatPatch, formatPatchToDiscardChanges } from '../lib/patch-formatter.js'
-import { assertNever } from '../lib/fatal-error.js'
-
-export async function applyPatchToIndex(
-  repository: Repository,
-  file: WorkingDirectoryFileChange
-): Promise<void> {
-  // If the file was a rename we have to recreate that rename since we've
-  // just blown away the index. Think of this block of weird looking commands
-  // as running `git mv`.
-  if (file.status.kind === AppFileStatusKind.Renamed) {
-    // Make sure the index knows of the removed file. We could use
-    // update-index --force-remove here but we're not since it's
-    // possible that someone staged a rename and then recreated the
-    // original file and we don't have any guarantees for in which order
-    // partial stages vs full-file stages happen. By using git add the
-    // worst that could happen is that we re-stage a file already staged
-    // by updateIndex.
-    await git(
-      ['add', '--update', '--', file.status.oldPath],
-      repository.path,
-      'applyPatchToIndex'
-    )
-
-    // Figure out the blob oid of the removed file
-    // <mode> SP <type> SP <object> TAB <file>
-    const oldFile = await git(
-      ['ls-tree', 'HEAD', '--', file.status.oldPath],
-      repository.path,
-      'applyPatchToIndex'
-    )
-
-    const [info] = oldFile.stdout.split('\t', 1)
-    const [mode, , oid] = info.split(' ', 3)
-
-    // Add the old file blob to the index under the new name
-    await git(
-      ['update-index', '--add', '--cacheinfo', mode, oid, file.path],
-      repository.path,
-      'applyPatchToIndex'
-    )
-  }
-
-  const applyArgs: string[] = [
-    'apply',
-    '--cached',
-    '--unidiff-zero',
-    '--whitespace=nowarn',
-    '-',
-  ]
-
-  const diff = await getWorkingDirectoryDiff(repository, file)
-
-  if (diff.kind !== DiffType.Text && diff.kind !== DiffType.LargeText) {
-    const { kind } = diff
-    switch (diff.kind) {
-      case DiffType.Binary:
-      case DiffType.Submodule:
-      case DiffType.Image:
-        throw new Error(
-          `Can't create partial commit in binary file: ${file.path}`
-        )
-      case DiffType.Unrenderable:
-        throw new Error(
-          `File diff is too large to generate a partial commit: ${file.path}`
-        )
-      default:
-        assertNever(diff, `Unknown diff kind: ${kind}`)
-    }
-  }
-
-  const patch = await formatPatch(repository, file, file.selection)
-  await git(applyArgs, repository.path, 'applyPatchToIndex', { stdin: patch })
-
-  return Promise.resolve()
-}
-
-/**
- * Test a patch to see if it will apply cleanly.
- *
- * @param workTree work tree (which should be checked out to a specific commit)
- * @param patch a Git patch (or patch series) to try applying
- * @returns whether the patch applies cleanly
- *
- * See `formatPatch` to generate a patch series from existing Git commits
- */
-export async function checkPatch(
-  workTree: { path: string },
-  patch: string
-): Promise<boolean> {
-  const result = await git(
-    ['apply', '--check', '-'],
-    workTree.path,
-    'checkPatch',
-    {
-      stdin: patch,
-      encoding: 'utf8' as any,
-      expectedErrors: new Set<DugiteError>([DugiteError.PatchDoesNotApply]),
-    }
-  )
-
-  if (result.gitError === DugiteError.PatchDoesNotApply) {
-    // other errors will be thrown if encountered, so this is fine for now
-    return false
-  }
-
-  return true
-}
-
-/**
- * Discards the local changes for the specified file based on the passed diff
- * and a selection of lines from it.
- *
- * When passed an empty selection, this method won't do anything. When passed a
- * full selection, all changes from the file will be discarded.
- *
- * @param repository The repository in which to update the working directory
- *                   with information from the index
- *
- * @param filePath   The relative path in the working directory of the file to use
- *
- * @param diff       The diff containing the file local changes
- *
- * @param selection  The selection of changes from the diff to discard
- */
-export async function discardChangesFromSelection(
-  repository: Repository,
-  filePath: string,
-  diff: ITextDiff,
-  selection: DiffSelection
-) {
-  const file = new WorkingDirectoryFileChange(filePath, { kind: AppFileStatusKind.Modified }, selection)
-  const patch = await formatPatchToDiscardChanges(repository, file)
-
-  if (patch === null || patch === '') {
-    // When the patch is null we don't need to apply it since it will be a noop.
-    return
-  }
-
-  const args = ['apply', '--unidiff-zero', '--whitespace=nowarn', '-']
-
-  await git(args, repository.path, 'discardChangesFromSelection', {
-    stdin: patch,
-  })
-}

package/src/git/authentication.ts

@@ -1,20 +0,0 @@
-import { GitError as DugiteError } from './exec.js'
-
-/** Get the environment for authenticating remote operations. */
-export function envForAuthentication(): Record<string, string | undefined> {
-  return {
-    // supported since Git 2.3, this is used to ensure we never interactively prompt
-    // for credentials - even as a fallback
-    GIT_TERMINAL_PROMPT: '0',
-    // localStorage is not available in Node.js; fall back to process.env
-    GIT_TRACE: process.env.GIT_TRACE ?? '0',
-  }
-}
-
-/** The set of errors which fit under the "authentication failed" umbrella. */
-export const AuthenticationErrors: ReadonlySet<DugiteError> = new Set([
-  DugiteError.HTTPSAuthenticationFailed,
-  DugiteError.SSHAuthenticationFailed,
-  DugiteError.HTTPSRepositoryNotFound,
-  DugiteError.SSHRepositoryNotFound,
-])

package/src/git/branch.ts

@@ -1,206 +0,0 @@
-import { git, isGitError } from './core.js'
-import { Repository } from '../models/repository.js'
-import { Branch } from '../models/branch.js'
-import { formatAsLocalRef } from './refs.js'
-import { deleteRef } from './update-ref.js'
-import { GitError as DugiteError } from './exec.js'
-import { envForRemoteOperation } from './environment.js'
-import { createForEachRefParser } from './git-delimiter-parser.js'
-import { IRemote } from '../models/remote.js'
-import { coerceToString } from './coerce-to-string.js'
-
-/**
- * Create a new branch from the given start point.
- *
- * @param repository - The repository in which to create the new branch
- * @param name       - The name of the new branch
- * @param startPoint - A committish string that the new branch should be based
- *                     on, or undefined if the branch should be created based
- *                     off of the current state of HEAD
- */
-export async function createBranch(
-  repository: Repository,
-  name: string,
-  startPoint: string | null,
-  noTrack?: boolean
-): Promise<void> {
-  const args =
-    startPoint !== null ? ['branch', name, startPoint] : ['branch', name]
-
-  // if we're branching directly from a remote branch, we don't want to track it
-  // tracking it will make the rest of desktop think we want to push to that
-  // remote branch's upstream (which would likely be the upstream of the fork)
-  if (noTrack) {
-    args.push('--no-track')
-  }
-
-  await git(args, repository.path, 'createBranch')
-}
-
-export const getBranchNames = ({ path }: Repository): Promise<string[]> => {
-  const parser = createForEachRefParser({ name: '%(refname:short)' })
-  return git(['branch', ...parser.formatArgs], path, 'getBranchNames').then(x =>
-    parser.parse(x.stdout).map(b => b.name)
-  )
-}
-
-/** Rename the given branch to a new name. */
-export async function renameBranch(
-  repository: Repository,
-  branch: Branch,
-  newName: string,
-  force?: boolean
-): Promise<void> {
-  try {
-    await git(
-      ['branch', force ? '-M' : '-m', branch.nameWithoutRemote, newName],
-      repository.path,
-      'renameBranch'
-    )
-  } catch (error) {
-    // If we failed to rename and the branch name only differs by case, we
-    // we'll try again with the -M flag to force the rename. See
-    // https://github.com/desktop/desktop/issues/21320
-    if (
-      // Only retry if the caller hasn't explicitly asked us to force the rename
-      force === undefined &&
-      isGitError(error) &&
-      error.result.gitError === DugiteError.BranchAlreadyExists
-    ) {
-      const stderr = coerceToString(error.result.stderr)
-      const m = /fatal: a branch named '(.+?)' already exists/.exec(stderr)
-
-      if (m && m[1].toLowerCase() === newName.toLowerCase()) {
-        // At this point we're almost certain that we are dealing with a
-        // case-only rename on a case insensitive filesystem, but we can't
-        // be 100% sure, NTFS can be configured to be case sensitive and macOS
-        // might have case sensitive file systems mounted so we have to list
-        // all branches and check the names.
-        return (
-          getBranchNames(repository)
-            // Throw the original error if we fail to get the branch names
-            .catch(() => Promise.reject(error))
-            .then(names =>
-              // If we find the new name in the list of branches we can't
-              // safely assume it's a case-only rename and have to
-              // propagate the original error, otherwise try again with -M
-              names.includes(newName)
-                ? Promise.reject(error)
-                : renameBranch(repository, branch, newName, true)
-            )
-        )
-      }
-    }
-    throw error
-  }
-}
-
-/**
- * Delete the branch locally.
- */
-export async function deleteLocalBranch(
-  repository: Repository,
-  branchName: string
-): Promise<true> {
-  await git(['branch', '-D', branchName], repository.path, 'deleteLocalBranch')
-  return true
-}
-
-/**
- * Deletes a remote branch
- *
- * @param remoteName - the name of the remote to delete the branch from
- * @param remoteBranchName - the name of the branch on the remote
- */
-export async function deleteRemoteBranch(
-  repository: Repository,
-  remote: IRemote,
-  remoteBranchName: string
-): Promise<true> {
-  const args = ['push', remote.name, `:${remoteBranchName}`]
-
-  // If the user is not authenticated, the push is going to fail
-  // Let this propagate and leave it to the caller to handle
-  const result = await git(args, repository.path, 'deleteRemoteBranch', {
-    env: await envForRemoteOperation(remote.url),
-    expectedErrors: new Set<DugiteError>([DugiteError.BranchDeletionFailed]),
-  })
-
-  // It's possible that the delete failed because the ref has already
-  // been deleted on the remote. If we identify that specific
-  // error we can safely remove our remote ref which is what would
-  // happen if the push didn't fail.
-  if (result.gitError === DugiteError.BranchDeletionFailed) {
-    const ref = `refs/remotes/${remote.name}/${remoteBranchName}`
-    await deleteRef(repository, ref)
-  }
-
-  return true
-}
-
-/**
- * Finds branches that have a tip equal to the given committish
- *
- * @param repository within which to execute the command
- * @param commitish a sha, HEAD, etc that the branch(es) tip should be
- * @returns list branch names. null if an error is encountered
- */
-export async function getBranchesPointedAt(
-  repository: Repository,
-  commitish: string
-): Promise<Array<string> | null> {
-  const args = [
-    'branch',
-    `--points-at=${commitish}`,
-    '--format=%(refname:short)',
-  ]
-  // this command has an implicit \n delimiter
-  const { stdout, exitCode } = await git(
-    args,
-    repository.path,
-    'branchPointedAt',
-    {
-      // - 1 is returned if a common ancestor cannot be resolved
-      // - 129 is returned if ref is malformed
-      //   "warning: ignoring broken ref refs/remotes/origin/main."
-      successExitCodes: new Set([0, 1, 129]),
-    }
-  )
-  if (exitCode === 1 || exitCode === 129) {
-    return null
-  }
-  // split (and remove trailing element cause its always an empty string)
-  return stdout.split('\n').slice(0, -1)
-}
-
-/**
- * Gets all branches that have been merged into the given branch
- *
- * @param repository The repository in which to search
- * @param branchName The to be used as the base branch
- * @returns map of branch canonical refs paired to its sha
- */
-export async function getMergedBranches(
-  repository: Repository,
-  branchName: string
-): Promise<Map<string, string>> {
-  const canonicalBranchRef = formatAsLocalRef(branchName)
-  const { formatArgs, parse } = createForEachRefParser({
-    sha: '%(objectname)',
-    canonicalRef: '%(refname)',
-  })
-
-  const args = ['branch', ...formatArgs, '--merged', branchName]
-  const mergedBranches = new Map<string, string>()
-  const { stdout } = await git(args, repository.path, 'mergedBranches')
-
-  for (const branch of parse(stdout)) {
-    // Don't include the branch we're using to compare against
-    // in the list of branches merged into that branch.
-    if (branch.canonicalRef !== canonicalBranchRef) {
-      mergedBranches.set(branch.canonicalRef, branch.sha)
-    }
-  }
-
-  return mergedBranches
-}

package/src/git/checkout-index.ts

@@ -1,40 +0,0 @@
-import { git } from './core.js'
-import { Repository } from '../models/repository.js'
-
-/**
- * Forcefully updates the working directory with information from the index
- * for a given set of files.
- *
- * This method is essentially the same as running `git checkout -- files`
- * except by using `checkout-index` we can pass the files we want updated
- * on stdin, avoiding all issues with too long arguments.
- *
- * Note that this function will not yield errors for paths that don't
- * exist in the index (-q).
- *
- * @param repository The repository in which to update the working directory
- *                   with information from the index
- *
- * @param paths      The relative paths in the working directory to update
- *                   with information from the index.
- */
-export async function checkoutIndex(
-  repository: Repository,
-  paths: ReadonlyArray<string>
-) {
-  if (!paths.length) {
-    return
-  }
-
-  const options = {
-    successExitCodes: new Set([0, 1]),
-    stdin: paths.join('\0'),
-  }
-
-  await git(
-    ['checkout-index', '-f', '-u', '-q', '--stdin', '-z'],
-    repository.path,
-    'checkoutIndex',
-    options
-  )
-}

package/src/git/checkout.ts

@@ -1,235 +0,0 @@
-import { git, IGitStringExecutionOptions } from './core.js'
-import { Repository } from '../models/repository.js'
-import { Branch, BranchType } from '../models/branch.js'
-import { clampProgress, ICheckoutProgress } from '../models/progress.js'
-import {
-  CheckoutProgressParser,
-  executionOptionsWithProgress,
-} from '../lib/progress/index.js'
-import { AuthenticationErrors } from './authentication.js'
-import {
-  envForRemoteOperation,
-  getFallbackUrlForProxyResolve,
-} from './environment.js'
-import { WorkingDirectoryFileChange } from '../models/status.js'
-import { ManualConflictResolution } from '../models/manual-conflict-resolution.js'
-import { CommitOneLine, shortenSHA } from '../models/commit.js'
-import { IRemote } from '../models/remote.js'
-import { updateSubmodulesAfterOperation } from './submodule.js'
-
-export type ProgressCallback = (progress: ICheckoutProgress) => void
-
-const CheckoutStepWeight = 0.9
-
-function getCheckoutArgs(progressCallback?: ProgressCallback) {
-  return ['checkout', ...(progressCallback ? ['--progress'] : [])]
-}
-
-async function getBranchCheckoutArgs(branch: Branch) {
-  return [
-    branch.name,
-    ...(branch.type === BranchType.Remote
-      ? ['-b', branch.nameWithoutRemote]
-      : []),
-    '--',
-  ]
-}
-
-async function getCheckoutOpts(
-  repository: Repository,
-  title: string,
-  target: string,
-  currentRemote: IRemote | null,
-  progressCallback?: ProgressCallback,
-  initialDescription?: string
-): Promise<IGitStringExecutionOptions> {
-  const opts: IGitStringExecutionOptions = {
-    env: await envForRemoteOperation(
-      getFallbackUrlForProxyResolve(repository, currentRemote)
-    ),
-    expectedErrors: AuthenticationErrors,
-  }
-
-  if (!progressCallback) {
-    return opts
-  }
-
-  const kind = 'checkout'
-
-  // Initial progress
-  progressCallback({
-    kind,
-    title,
-    description: initialDescription ?? title,
-    value: 0,
-    target,
-  })
-
-  return await executionOptionsWithProgress(
-    { ...opts, trackLFSProgress: true },
-    new CheckoutProgressParser(),
-    progress => {
-      if (progress.kind === 'progress') {
-        const description = progress.details.text
-        const value = progress.percent
-
-        progressCallback({
-          kind,
-          title,
-          description,
-          value,
-          target,
-        })
-      }
-    }
-  )
-}
-
-/**
- * Check out the given branch.
- *
- * @param repository - The repository in which the branch checkout should
- *                     take place
- *
- * @param branch     - The branch name that should be checked out
- *
- * @param progressCallback - An optional function which will be invoked
- *                           with information about the current progress
- *                           of the checkout operation. When provided this
- *                           enables the '--progress' command line flag for
- *                           'git checkout'.
- */
-export async function checkoutBranch(
-  repository: Repository,
-  branch: Branch,
-  currentRemote: IRemote | null,
-  progressCallback?: ProgressCallback,
-  allowFileProtocol: boolean = false
-): Promise<true> {
-  const title = `Checking out branch ${branch.name}`
-  const opts = await getCheckoutOpts(
-    repository,
-    title,
-    branch.name,
-    currentRemote,
-    progressCallback
-      ? clampProgress(0, CheckoutStepWeight, progressCallback)
-      : undefined,
-    `Switching to branch`
-  )
-
-  const baseArgs = getCheckoutArgs(progressCallback)
-  const args = [...baseArgs, ...(await getBranchCheckoutArgs(branch))]
-
-  await git(args, repository.path, 'checkoutBranch', opts)
-
-  // Update submodules after checkout
-  await updateSubmodulesAfterOperation(
-    repository,
-    currentRemote,
-    progressCallback
-      ? clampProgress<ICheckoutProgress>(
-          CheckoutStepWeight,
-          1,
-          progressCallback
-        )
-      : undefined,
-    'checkout',
-    title,
-    branch.name,
-    allowFileProtocol
-  )
-
-  // we return `true` here so `GitStore.performFailableGitOperation`
-  // will return _something_ differentiable from `undefined` if this succeeds
-  return true
-}
-
-/**
- * Check out the given commit.
- * Literally invokes `git checkout <commit SHA>`.
- *
- * @param repository - The repository in which the branch checkout should
- *                     take place
- *
- * @param commit     - The commit that should be checked out
- *
- * @param progressCallback - An optional function which will be invoked
- *                           with information about the current progress
- *                           of the checkout operation. When provided this
- *                           enables the '--progress' command line flag for
- *                           'git checkout'.
- */
-export async function checkoutCommit(
-  repository: Repository,
-  commit: CommitOneLine,
-  currentRemote: IRemote | null,
-  progressCallback?: ProgressCallback,
-  allowFileProtocol: boolean = false
-): Promise<true> {
-  const title = `Checking out commit`
-  const target = shortenSHA(commit.sha)
-  const opts = await getCheckoutOpts(
-    repository,
-    title,
-    target,
-    currentRemote,
-    progressCallback
-      ? clampProgress(0, CheckoutStepWeight, progressCallback)
-      : undefined
-  )
-
-  const baseArgs = getCheckoutArgs(progressCallback)
-  const args = [...baseArgs, commit.sha]
-
-  await git(args, repository.path, 'checkoutCommit', opts)
-
-  // Update submodules after checkout
-  await updateSubmodulesAfterOperation(
-    repository,
-    currentRemote,
-    progressCallback
-      ? clampProgress<ICheckoutProgress>(
-          CheckoutStepWeight,
-          1,
-          progressCallback
-        )
-      : undefined,
-    'checkout',
-    title,
-    target,
-    allowFileProtocol
-  )
-
-  // we return `true` here so `GitStore.performFailableGitOperation`
-  // will return _something_ differentiable from `undefined` if this succeeds
-  return true
-}
-
-/** Check out the paths at HEAD. */
-export async function checkoutPaths(
-  repository: Repository,
-  paths: ReadonlyArray<string>
-): Promise<void> {
-  await git(
-    ['checkout', 'HEAD', '--', ...paths],
-    repository.path,
-    'checkoutPaths'
-  )
-}
-
-/**
- * Check out either stage #2 (ours) or #3 (theirs) for a conflicted
- * file.
- */
-export async function checkoutConflictedFile(
-  repository: Repository,
-  file: WorkingDirectoryFileChange,
-  resolution: ManualConflictResolution
-) {
-  await git(
-    ['checkout', `--${resolution}`, '--', file.path],
-    repository.path,
-    'checkoutConflictedFile'
-  )
-}