git-chopstick-core 0.1.1 → 0.1.3

package/src/git/rev-list.ts

@@ -1,201 +0,0 @@
-import { GitError } from './exec'
-import { git } from './core'
-import { Repository } from '../models/repository'
-import { Branch, BranchType, IAheadBehind } from '../models/branch'
-import { CommitOneLine } from '../models/commit'
-
-/**
- * Convert two refs into the Git range syntax representing the set of commits
- * that are reachable from `to` but excluding those that are reachable from
- * `from`. This will not be inclusive to the `from` ref, see
- * `revRangeInclusive`.
- *
- * Each parameter can be the commit SHA or a ref name, or specify an empty
- * string to represent HEAD.
- *
- * @param from The start of the range
- * @param to The end of the range
- */
-export function revRange(from: string, to: string) {
-  return `${from}..${to}`
-}
-
-/**
- * Convert two refs into the Git range syntax representing the set of commits
- * that are reachable from `to` but excluding those that are reachable from
- * `from`. However as opposed to `revRange`, this will also include `from` ref.
- *
- * Each parameter can be the commit SHA or a ref name, or specify an empty
- * string to represent HEAD.
- *
- * @param from The start of the range
- * @param to The end of the range
- */
-export function revRangeInclusive(from: string, to: string) {
-  return `${from}^..${to}`
-}
-
-/**
- * Convert two refs into the Git symmetric difference syntax, which represents
- * the set of commits that are reachable from either `from` or `to` but not
- * from both.
- *
- * Each parameter can be the commit SHA or a ref name, or you can use an empty
- * string to represent HEAD.
- *
- * @param from The start of the range
- * @param to The end of the range
- */
-export function revSymmetricDifference(from: string, to: string) {
-  return `${from}...${to}`
-}
-
-/** Calculate the number of commits the range is ahead and behind. */
-export async function getAheadBehind(
-  repository: Repository,
-  range: string
-): Promise<IAheadBehind | null> {
-  // `--left-right` annotates the list of commits in the range with which side
-  // they're coming from. When used with `--count`, it tells us how many
-  // commits we have from the two different sides of the range.
-  const args = ['rev-list', '--left-right', '--count', range, '--']
-  const result = await git(args, repository.path, 'getAheadBehind', {
-    expectedErrors: new Set([GitError.BadRevision]),
-  })
-
-  // This means one of the refs (most likely the upstream branch) no longer
-  // exists. In that case we can't be ahead/behind at all.
-  if (result.gitError === GitError.BadRevision) {
-    return null
-  }
-
-  const stdout = result.stdout
-  const pieces = stdout.split('\t')
-  if (pieces.length !== 2) {
-    return null
-  }
-
-  const ahead = parseInt(pieces[0], 10)
-  if (isNaN(ahead)) {
-    return null
-  }
-
-  const behind = parseInt(pieces[1], 10)
-  if (isNaN(behind)) {
-    return null
-  }
-
-  return { ahead, behind }
-}
-
-/** Calculate the number of commits `branch` is ahead/behind its upstream. */
-export async function getBranchAheadBehind(
-  repository: Repository,
-  branch: Branch
-): Promise<IAheadBehind | null> {
-  if (branch.type === BranchType.Remote) {
-    return null
-  }
-
-  const upstream = branch.upstream
-  if (!upstream) {
-    return null
-  }
-
-  // NB: The three dot form means we'll go all the way back to the merge base
-  // of the branch and its upstream. Practically this is important for seeing
-  // "through" merges.
-  const range = revSymmetricDifference(branch.name, upstream)
-  return getAheadBehind(repository, range)
-}
-
-/**
- * Get a list of commits from the target branch that do not exist on the base
- * branch, ordered how they will be applied to the base branch.
- * Therefore, this will not include the baseBranchSha commit.
- *
- * This emulates how `git rebase` initially determines what will be applied to
- * the repository.
- *
- * Returns `null` when the rebase is not possible to perform, because of a
- * missing commit ID
- */
-export async function getCommitsBetweenCommits(
-  repository: Repository,
-  baseBranchSha: string,
-  targetBranchSha: string
-): Promise<ReadonlyArray<CommitOneLine> | null> {
-  const range = revRange(baseBranchSha, targetBranchSha)
-
-  return getCommitsInRange(repository, range)
-}
-
-/**
- * Get a list of commits inside the provided range.
- *
- * Returns `null` when it is not possible to perform because of a bad range.
- */
-export async function getCommitsInRange(
-  repository: Repository,
-  range: string
-): Promise<ReadonlyArray<CommitOneLine> | null> {
-  const args = [
-    'rev-list',
-    range,
-    '--reverse',
-    // the combination of these two arguments means each line of the stdout
-    // will contain the full commit sha and a commit summary
-    `--oneline`,
-    `--no-abbrev-commit`,
-    '--',
-  ]
-
-  const options = {
-    expectedErrors: new Set<GitError>([GitError.BadRevision]),
-  }
-
-  const result = await git(args, repository.path, 'getCommitsInRange', options)
-
-  if (result.gitError === GitError.BadRevision) {
-    return null
-  }
-
-  const lines = result.stdout.split('\n')
-
-  const commits = new Array<CommitOneLine>()
-
-  const commitSummaryRe = /^([a-z0-9]{40}) (.*)$/
-
-  for (const line of lines) {
-    const match = commitSummaryRe.exec(line)
-
-    if (match !== null && match.length === 3) {
-      const sha = match[1]
-      const summary = match[2]
-
-      commits.push({
-        sha,
-        summary,
-      })
-    }
-  }
-
-  return commits
-}
-
-/**
- * Determine if merge commits exist in history after given commit
- * If commitRef is null, goes back to HEAD of branch.
- */
-export async function doMergeCommitsExistAfterCommit(
-  repository: Repository,
-  commitRef: string | null
-): Promise<boolean> {
-  const revision = commitRef === null ? 'HEAD' : revRange(commitRef, 'HEAD')
-  const args = ['rev-list', '-1', '--merges', revision, '--']
-
-  return git(args, repository.path, 'doMergeCommitsExistAfterCommit', {
-    // 128 here means there's no HEAD, i.e we're on an unborn branch
-    successExitCodes: new Set([0, 128]),
-  }).then(x => x.stdout.length > 0)
-}

package/src/git/rev-parse.ts

@@ -1,92 +0,0 @@
-import { git } from './core'
-import { directoryExists } from '../lib/directory-exists'
-import { resolve } from 'path'
-
-export type RepositoryType =
-  | { kind: 'bare' }
-  | { kind: 'regular'; topLevelWorkingDirectory: string; gitDir: string }
-  | { kind: 'missing' }
-  | { kind: 'unsafe'; path: string }
-
-/**
- * Attempts to fulfill the work of isGitRepository and isBareRepository while
- * requiring only one Git process to be spawned.
- *
- * Returns 'bare', 'regular', or 'missing' if the repository couldn't be
- * found.
- */
-export async function getRepositoryType(path: string): Promise<RepositoryType> {
-  if (!(await directoryExists(path))) {
-    return { kind: 'missing' }
-  }
-
-  try {
-    const result = await git(
-      ['rev-parse', '--is-bare-repository', '--show-cdup', '--git-dir'],
-      path,
-      'getRepositoryType',
-      { successExitCodes: new Set([0, 128]) }
-    )
-
-    if (result.exitCode === 0) {
-      // Bare repositories will not include gitdir so we handle that separately
-      if (result.stdout.startsWith('true\n')) {
-        return { kind: 'bare' }
-      }
-
-      // --is-bare-repository and --show-cdup each produce a single line but
-      // --git-dir could theoretically contain newlines so we parse the known
-      // fields first and treat the remainder as the git dir. We use [\s\S]*
-      // instead of .* for the git dir capture group because .* doesn't match
-      // newlines whereas [\s\S]* matches any character including newlines.
-      const match = result.stdout.match(/^(true|false)\n(.*)\n([\s\S]*)\n$/)
-
-      if (match) {
-        const [, isBare, cdup, gitDir] = match
-
-        return isBare === 'true'
-          ? { kind: 'bare' }
-          : {
-              kind: 'regular',
-              topLevelWorkingDirectory: resolve(path, cdup),
-              gitDir: resolve(path, gitDir),
-            }
-      }
-    }
-
-    const unsafeMatch =
-      /fatal: detected dubious ownership in repository at '(.+)'/.exec(
-        result.stderr
-      )
-    if (unsafeMatch) {
-      return { kind: 'unsafe', path: unsafeMatch[1] }
-    }
-
-    return { kind: 'missing' }
-  } catch (err: any) {
-    if (err?.code === 'ENOENT') {
-      return { kind: 'missing' }
-    }
-    throw err
-  }
-}
-
-export async function getUpstreamRefForRef(path: string, ref?: string) {
-  const rev = (ref ?? '') + '@{upstream}'
-  const args = ['rev-parse', '--symbolic-full-name', rev]
-  const opts = { successExitCodes: new Set([0, 128]) }
-  const result = await git(args, path, 'getUpstreamRefForRef', opts)
-
-  return result.exitCode === 0 ? result.stdout.trim() : null
-}
-
-export async function getUpstreamRemoteNameForRef(path: string, ref?: string) {
-  const remoteRef = await getUpstreamRefForRef(path, ref)
-  return remoteRef?.match(/^refs\/remotes\/([^/]+)\//)?.[1] ?? null
-}
-
-export const getCurrentUpstreamRef = (path: string) =>
-  getUpstreamRefForRef(path)
-
-export const getCurrentUpstreamRemoteName = (path: string) =>
-  getUpstreamRemoteNameForRef(path)

package/src/git/revert.ts

@@ -1,55 +0,0 @@
-import { git, IGitStringExecutionOptions } from './core'
-
-import { Repository } from '../models/repository'
-import { Commit } from '../models/commit'
-import { IRevertProgress } from '../models/progress'
-
-import { executionOptionsWithProgress } from '../lib/progress/from-process'
-import { RevertProgressParser } from '../lib/progress/revert'
-import {
-  envForRemoteOperation,
-  getFallbackUrlForProxyResolve,
-} from './environment'
-import { IRemote } from '../models/remote'
-
-/**
- * Creates a new commit that reverts the changes of a previous commit
- *
- * @param repository  - The repository to update
- *
- * @param commit         - The SHA of the commit to be reverted
- */
-export async function revertCommit(
-  repository: Repository,
-  commit: Commit,
-  currentRemote: IRemote | null,
-  progressCallback?: (progress: IRevertProgress) => void
-) {
-  const args = ['revert']
-  if (commit.parentSHAs.length > 1) {
-    args.push('-m', '1')
-  }
-
-  args.push(commit.sha)
-
-  let opts: IGitStringExecutionOptions = {}
-  if (progressCallback) {
-    const env = await envForRemoteOperation(
-      getFallbackUrlForProxyResolve(repository, currentRemote)
-    )
-    opts = await executionOptionsWithProgress(
-      { env, trackLFSProgress: true },
-      new RevertProgressParser(),
-      progress => {
-        const description =
-          progress.kind === 'progress' ? progress.details.text : progress.text
-        const title = progress.kind === 'progress' ? progress.details.title : ''
-        const value = progress.percent
-
-        progressCallback({ kind: 'revert', description, value, title })
-      }
-    )
-  }
-
-  await git(args, repository.path, 'revert', opts)
-}

package/src/git/rm.ts

@@ -1,31 +0,0 @@
-import { git } from './core'
-import { Repository } from '../models/repository'
-import { WorkingDirectoryFileChange } from '../models/status'
-
-/**
- * Remove all files from the index
- *
- * @param repository the repository to update
- */
-export async function unstageAllFiles(repository: Repository): Promise<void> {
-  await git(
-    // these flags are important:
-    // --cached to only remove files from the index
-    // -r       to recursively remove files, in case files are in folders
-    // -f       to ignore differences between working directory and index
-    //          which will block this
-    ['rm', '--cached', '-r', '-f', '.'],
-    repository.path,
-    'unstageAllFiles'
-  )
-}
-
-/**
- * Remove conflicted file from  working tree and index
- */
-export async function removeConflictedFile(
-  repository: Repository,
-  file: WorkingDirectoryFileChange
-) {
-  await git(['rm', '--', file.path], repository.path, 'removeConflictedFile')
-}

package/src/git/spawn.ts

@@ -1,38 +0,0 @@
-import { spawnGit as spawn, IGitSpawnOptions } from './exec'
-import * as GitPerf from '../lib/git-perf'
-import { withTrampolineEnv } from '../lib/trampoline/trampoline-environment'
-
-type SpawnOptions = IGitSpawnOptions & {
-  /**
-   * Whether the command about to run is part of a background task or not.
-   * This affects error handling and UI such as credential prompts.
-   */
-  readonly isBackgroundTask?: boolean
-}
-
-/**
- * Spawn a Git process, deferring all processing work to the caller.
- *
- * @param args Array of strings to pass to the Git executable.
- * @param path The path to execute the command from.
- * @param name The name of the operation - for tracing purposes.
- * @param successExitCodes An optional array of exit codes that indicate success.
- */
-export const spawnGit = (
-  args: string[],
-  path: string,
-  name: string,
-  options?: SpawnOptions
-) =>
-  withTrampolineEnv(
-    trampolineEnv =>
-      GitPerf.measure(`${name}: git ${args.join(' ')}`, async () =>
-        spawn(args, path, {
-          ...options,
-          env: { ...options?.env, ...trampolineEnv },
-        })
-      ),
-    path,
-    options?.isBackgroundTask ?? false,
-    options?.env
-  )

package/src/git/squash.ts

@@ -1,173 +0,0 @@
-import { appendFile, rm, writeFile } from 'fs/promises'
-import { getCommits, revRange } from '.'
-import { Commit } from '../models/commit'
-import { MultiCommitOperationKind } from '../models/multi-commit-operation'
-import { IMultiCommitOperationProgress } from '../models/progress'
-import { Repository } from '../models/repository'
-import { getTempFilePath } from '../lib/file-system'
-import { rebaseInteractive, RebaseResult } from './rebase'
-
-/**
- * Squashes provided commits by calling interactive rebase.
- *
- * Goal is to replay the commits in order from oldest to newest to reduce
- * conflicts with toSquash commits placed in the log at the location of the
- * squashOnto commit.
- *
- * Example: A user's history from oldest to newest is A, B, C, D, E and they
- * want to squash A and E (toSquash) onto C. Our goal:  B, A-C-E, D. Thus,
- * maintaining that A came before C and E came after C, placed in history at the
- * the squashOnto of C.
- *
- * Also means if the last 2 commits in history are A, B, whether user squashes A
- * onto B or B onto A. It will always perform based on log history, thus, B onto
- * A.
- *
- * @param toSquash - commits to squash onto another commit and does not contain the squashOnto commit
- * @param squashOnto  - commit to squash the `toSquash` commits onto
- * @param lastRetainedCommitRef - sha of commit before commits in squash or null
- * if commit to be squash is the root (first in history) of the branch
- * @param commitMessage - the first line of the string provided will be the
- * summary and rest the body (similar to commit implementation)
- */
-export async function squash(
-  repository: Repository,
-  toSquash: ReadonlyArray<Commit>,
-  squashOnto: Commit,
-  lastRetainedCommitRef: string | null,
-  commitMessage: string,
-  progressCallback?: (progress: IMultiCommitOperationProgress) => void
-): Promise<RebaseResult> {
-  let messagePath, todoPath
-  let result: RebaseResult
-
-  try {
-    if (toSquash.length === 0) {
-      throw new Error('[squash] No commits provided to squash.')
-    }
-
-    const toSquashShas = new Set(toSquash.map(c => c.sha))
-    if (toSquashShas.has(squashOnto.sha)) {
-      throw new Error(
-        '[squash] The commits to squash cannot contain the commit to squash onto.'
-      )
-    }
-
-    const commits = await getCommits(
-      repository,
-      lastRetainedCommitRef === null
-        ? undefined
-        : revRange(lastRetainedCommitRef, 'HEAD')
-    )
-
-    if (commits.length === 0) {
-      throw new Error(
-        '[squash] Could not find commits in log for last retained commit ref.'
-      )
-    }
-
-    todoPath = await getTempFilePath('squashTodo')
-    let foundSquashOntoCommitInLog = false
-    const toReplayAtSquash = []
-    const toReplayAfterSquash = []
-    // Traversed in reverse so we do oldest to newest (replay commits)
-    for (let i = commits.length - 1; i >= 0; i--) {
-      const commit = commits[i]
-      if (toSquashShas.has(commit.sha)) {
-        // If it is toSquash commit and we have found the squashOnto commit, we
-        // can go ahead and squash them (as we will hold any picks till after)
-        if (foundSquashOntoCommitInLog) {
-          await appendFile(todoPath, `squash ${commit.sha} ${commit.summary}\n`)
-        } else {
-          // However, if we have not found the squashOnto commit yet we want to
-          // keep track of them in the order of the log. Thus, we use a new
-          // `toReplayAtSquash` array and not trust that what was sent is in the
-          // order of the log.
-          toReplayAtSquash.push(commit)
-        }
-
-        continue
-      }
-
-      // If it's the squashOnto commit, replay to the toSquash in the order they
-      // appeared on the log to reduce potential conflicts.
-      if (commit.sha === squashOnto.sha) {
-        foundSquashOntoCommitInLog = true
-        toReplayAtSquash.push(commit)
-
-        for (let j = 0; j < toReplayAtSquash.length; j++) {
-          const action = j === 0 ? 'pick' : 'squash'
-          await appendFile(
-            todoPath,
-            `${action} ${toReplayAtSquash[j].sha} ${toReplayAtSquash[j].summary}\n`
-          )
-        }
-
-        continue
-      }
-
-      // We can't just replay a pick in case there is a commit from the toSquash
-      // commits further up in history that need to be replayed with the
-      // squashes. Thus, we will keep track of these and replay after traversing
-      // the remainder of the log.
-      if (foundSquashOntoCommitInLog) {
-        toReplayAfterSquash.push(commit)
-        continue
-      }
-
-      // If it is not one toSquash nor the squashOnto and have not found the
-      // squashOnto commit, we simply record it is an unchanged pick (before the
-      // squash)
-      await appendFile(todoPath, `pick ${commit.sha} ${commit.summary}\n`)
-    }
-
-    if (toReplayAfterSquash.length > 0) {
-      for (let i = 0; i < toReplayAfterSquash.length; i++) {
-        await appendFile(
-          todoPath,
-          `pick ${toReplayAfterSquash[i].sha} ${toReplayAfterSquash[i].summary}\n`
-        )
-      }
-    }
-
-    if (!foundSquashOntoCommitInLog) {
-      throw new Error(
-        '[squash] The commit to squash onto was not in the log. Continuing would result in dropping the commits in the toSquash array.'
-      )
-    }
-
-    if (commitMessage.trim() !== '') {
-      messagePath = await getTempFilePath('squashCommitMessage')
-      await writeFile(messagePath, commitMessage)
-    }
-
-    // if no commit message provided, accept default editor
-    const gitEditor =
-      messagePath !== undefined ? `cat "${messagePath}" >` : undefined
-
-    result = await rebaseInteractive(
-      repository,
-      todoPath,
-      lastRetainedCommitRef,
-      {
-        action: MultiCommitOperationKind.Squash,
-        gitEditor,
-        progressCallback,
-        commits: [...toSquash, squashOnto],
-      }
-    )
-  } catch (e) {
-    console.error(e)
-    return RebaseResult.Error
-  } finally {
-    if (todoPath !== undefined) {
-      await rm(todoPath, { recursive: true, force: true })
-    }
-
-    if (messagePath !== undefined) {
-      await rm(messagePath, { recursive: true, force: true })
-    }
-  }
-
-  return result
-}

package/src/git/stage.ts

@@ -1,97 +0,0 @@
-import { Repository } from '../models/repository'
-import {
-  WorkingDirectoryFileChange,
-  isConflictedFileStatus,
-  GitStatusEntry,
-  isConflictWithMarkers,
-} from '../models/status'
-import { ManualConflictResolution } from '../models/manual-conflict-resolution'
-import { assertNever } from '../lib/fatal-error'
-import { removeConflictedFile } from './rm'
-import { checkoutConflictedFile } from './checkout'
-import { addConflictedFile } from './add'
-
-/**
- * Stages a file with the given manual resolution method. Useful for resolving binary conflicts at commit-time.
- *
- * @param repository
- * @param file conflicted file to stage
- * @param manualResolution method to resolve the conflict of file
- * @returns true if successful, false if something went wrong
- */
-export async function stageManualConflictResolution(
-  repository: Repository,
-  file: WorkingDirectoryFileChange,
-  manualResolution: ManualConflictResolution
-): Promise<void> {
-  const { status } = file
-  // if somehow the file isn't in a conflicted state
-  if (!isConflictedFileStatus(status)) {
-    console.error(`tried to manually resolve unconflicted file (${file.path})`)
-    return
-  }
-
-  if (isConflictWithMarkers(status) && status.conflictMarkerCount === 0) {
-    // If somehow the user used the Desktop UI to solve the conflict via ours/theirs
-    // but afterwards resolved manually the conflicts via an editor, used the manually
-    // resolved file.
-    return
-  }
-
-  const chosen =
-    manualResolution === ManualConflictResolution.theirs
-      ? status.entry.them
-      : status.entry.us
-
-  const addedInBoth =
-    status.entry.us === GitStatusEntry.Added &&
-    status.entry.them === GitStatusEntry.Added
-
-  if (chosen === GitStatusEntry.UpdatedButUnmerged || addedInBoth) {
-    await checkoutConflictedFile(repository, file, manualResolution)
-  }
-
-  switch (chosen) {
-    case GitStatusEntry.Deleted:
-      return removeConflictedFile(repository, file)
-    case GitStatusEntry.Added:
-    case GitStatusEntry.UpdatedButUnmerged:
-      return addConflictedFile(repository, file)
-    default:
-      assertNever(chosen, 'unaccounted for git status entry possibility')
-  }
-}
-
-/**
- * Stages all resolved conflict files before a checkout operation to prevent
- * "error: you need to resolve your current index first" from git.
- *
- * Handles two kinds of resolved conflicts:
- *  - Text conflicts resolved in an external editor (conflictMarkerCount === 0)
- *  - Manual conflicts where the user chose ours/theirs in the Desktop UI
- */
-export async function stageResolvedConflictFiles(
-  repository: Repository,
-  files: ReadonlyArray<WorkingDirectoryFileChange>,
-  manualResolutions: ReadonlyMap<string, ManualConflictResolution>
-): Promise<void> {
-  for (const file of files) {
-    const { status } = file
-    if (!isConflictedFileStatus(status)) {
-      continue
-    }
-
-    const manualResolution = manualResolutions.get(file.path)
-
-    if (manualResolution !== undefined) {
-      // Binary/manual conflict resolved via Desktop UI — stage it
-      await stageManualConflictResolution(repository, file, manualResolution)
-    } else if (
-      isConflictWithMarkers(status) &&
-      status.conflictMarkerCount === 0
-    ) {
-      // Text conflict resolved in external editor — stage it
-      await addConflictedFile(repository, file)
-    }
-  }
-}