git-chopstick-core 0.1.2 → 0.1.4

package/src/git/rev-list.ts

@@ -1,201 +0,0 @@
-import { GitError } from './exec.js'
-import { git } from './core.js'
-import { Repository } from '../models/repository.js'
-import { Branch, BranchType, IAheadBehind } from '../models/branch.js'
-import { CommitOneLine } from '../models/commit.js'
-
-/**
- * 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.js'
-import { directoryExists } from '../lib/directory-exists.js'
-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.js'
-
-import { Repository } from '../models/repository.js'
-import { Commit } from '../models/commit.js'
-import { IRevertProgress } from '../models/progress.js'
-
-import { executionOptionsWithProgress } from '../lib/progress/from-process.js'
-import { RevertProgressParser } from '../lib/progress/revert.js'
-import {
-  envForRemoteOperation,
-  getFallbackUrlForProxyResolve,
-} from './environment.js'
-import { IRemote } from '../models/remote.js'
-
-/**
- * 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.js'
-import { Repository } from '../models/repository.js'
-import { WorkingDirectoryFileChange } from '../models/status.js'
-
-/**
- * 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/show.ts

@@ -1,88 +0,0 @@
-import { git, isMaxBufferExceededError } from './core.js'
-
-import { Repository } from '../models/repository.js'
-import { GitError } from './exec.js'
-import { coerceToBuffer } from './coerce-to-buffer.js'
-
-/**
- * Retrieve the binary contents of a blob from the repository at a given
- * reference, commit, or tree.
- *
- * Returns a promise that will produce a Buffer instance containing
- * the binary contents of the blob or an error if the file doesn't
- * exists in the given revision.
- *
- * @param repository - The repository from where to read the blob
- *
- * @param commitish  - A commit SHA or some other identifier that
- *                     ultimately dereferences to a commit/tree.
- *
- * @param path       - The file path, relative to the repository
- *                     root from where to read the blob contents
- */
-export const getBlobContents = (
-  repository: Repository,
-  commitish: string,
-  path: string
-) =>
-  git(['show', `${commitish}:${path}`], repository.path, 'getBlobContents', {
-    successExitCodes: new Set([0, 1]),
-    encoding: 'buffer',
-  }).then(r => r.stdout)
-
-/**
- * Retrieve some or all binary contents of a blob from the repository
- * at a given reference, commit, or tree. This is almost identical
- * to the getBlobContents method except that it supports only reading
- * a maximum number of bytes.
- *
- * Returns a promise that will produce a Buffer instance containing
- * the binary contents of the blob or an error if the file doesn't
- * exists in the given revision.
- *
- * @param repository - The repository from where to read the blob
- *
- * @param commitish  - A commit SHA or some other identifier that
- *                     ultimately dereferences to a commit/tree.
- *
- * @param path       - The file path, relative to the repository
- *                     root from where to read the blob contents
- *
- * @param length     - The maximum number of bytes to read from
- *                     the blob. Note that the number of bytes
- *                     returned may always be less than this number.
- */
-export async function getPartialBlobContents(
-  repository: Repository,
-  commitish: string,
-  path: string,
-  length: number
-): Promise<Buffer | null> {
-  return getPartialBlobContentsCatchPathNotInRef(
-    repository,
-    commitish,
-    path,
-    length
-  )
-}
-
-export async function getPartialBlobContentsCatchPathNotInRef(
-  repository: Repository,
-  commitish: string,
-  path: string,
-  length: number
-): Promise<Buffer | null> {
-  const args = ['show', `${commitish}:${path}`]
-
-  return git(args, repository.path, 'getPartialBlobContentsCatchPathNotInRef', {
-    maxBuffer: length,
-    expectedErrors: new Set([GitError.PathExistsButNotInRef]),
-    encoding: 'buffer',
-  })
-    .then(r =>
-      r.gitError === GitError.PathExistsButNotInRef ? null : r.stdout
-    )
-    .catch(e =>
-      isMaxBufferExceededError(e) ? coerceToBuffer(e.stdout) : Promise.reject(e)
-    )
-}

package/src/git/spawn.ts

@@ -1,38 +0,0 @@
-import { spawnGit as spawn, IGitSpawnOptions } from './exec.js'
-import * as GitPerf from '../lib/git-perf.js'
-import { withTrampolineEnv } from '../lib/trampoline/trampoline-environment.js'
-
-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 './index.js'
-import { Commit } from '../models/commit.js'
-import { MultiCommitOperationKind } from '../models/multi-commit-operation.js'
-import { IMultiCommitOperationProgress } from '../models/progress.js'
-import { Repository } from '../models/repository.js'
-import { getTempFilePath } from '../lib/file-system.js'
-import { rebaseInteractive, RebaseResult } from './rebase.js'
-
-/**
- * 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
-}