git-chopstick-core 0.1.1 → 0.1.3

package/src/git/reflog.ts

@@ -1,127 +0,0 @@
-import { git } from './core'
-import { Repository } from '../models/repository'
-
-/**
- * Get the `limit` most recently checked out branches.
- */
-export async function getRecentBranches(
-  repository: Repository,
-  limit: number
-): Promise<ReadonlyArray<string>> {
-  // "git reflog show" is just an alias for "git log -g --abbrev-commit --pretty=oneline"
-  // but by using log we can give it a max number which should prevent us from balling out
-  // of control when there's ginormous reflogs around (as in e.g. github/github).
-  const regex = new RegExp(
-    /.*? (renamed|checkout)(?:: moving from|\s*) (?:refs\/heads\/|\s*)(.*?) to (?:refs\/heads\/|\s*)(.*?)$/i
-  )
-
-  const result = await git(
-    [
-      'log',
-      '-g',
-      '--no-abbrev-commit',
-      '--pretty=oneline',
-      'HEAD',
-      '-n',
-      '2500',
-      '--',
-    ],
-    repository.path,
-    'getRecentBranches',
-    { successExitCodes: new Set([0, 128]) }
-  )
-
-  if (result.exitCode === 128) {
-    // error code 128 is returned if the branch is unborn
-    return []
-  }
-
-  const lines = result.stdout.split('\n')
-  const names = new Set<string>()
-  const excludedNames = new Set<String>()
-
-  for (const line of lines) {
-    const result = regex.exec(line)
-    if (result && result.length === 4) {
-      const operationType = result[1]
-      const excludeBranchName = result[2]
-      const branchName = result[3]
-
-      if (operationType === 'renamed') {
-        // exclude intermediate-state renaming branch from recent branches
-        excludedNames.add(excludeBranchName)
-      }
-
-      if (!excludedNames.has(branchName)) {
-        names.add(branchName)
-      }
-    }
-
-    if (names.size === limit) {
-      break
-    }
-  }
-
-  return [...names]
-}
-
-const noCommitsOnBranchRe = new RegExp(
-  "fatal: your current branch '.*' does not have any commits yet"
-)
-
-/**
- * Gets the distinct list of branches that have been checked out after a specific date
- * Returns a map keyed on branch names
- *
- * @param repository the repository who's reflog you want to check
- * @param afterDate filters checkouts so that only those occurring on or after this date are returned
- * @returns map of branch name -> checkout date
- */
-export async function getBranchCheckouts(
-  repository: Repository,
-  afterDate: Date
-): Promise<Map<string, Date>> {
-  //regexr.com/46n1v
-  const regex = new RegExp(
-    /^[a-z0-9]{40}\sHEAD@{(.*)}\scheckout: moving from\s.*\sto\s(.*)$/
-  )
-  const result = await git(
-    [
-      'reflog',
-      '--date=iso',
-      `--after="${afterDate.toISOString()}"`,
-      '--pretty=%H %gd %gs',
-      `--grep-reflog=checkout: moving from .* to .*$`,
-      '--',
-    ],
-    repository.path,
-    'getCheckoutsAfterDate',
-    { successExitCodes: new Set([0, 128]) }
-  )
-
-  const checkouts = new Map<string, Date>()
-
-  // edge case where orphaned branch is created but Git raises error when
-  // reading the reflog on this new branch as it has no commits
-  //
-  // see https://github.com/desktop/desktop/issues/7983 for more information
-  if (result.exitCode === 128 && noCommitsOnBranchRe.test(result.stderr)) {
-    return checkouts
-  }
-
-  const lines = result.stdout.split('\n')
-  for (const line of lines) {
-    const parsedLine = regex.exec(line)
-
-    if (parsedLine === null || parsedLine.length !== 3) {
-      continue
-    }
-
-    const [, timestamp, branchName] = parsedLine
-    if (!checkouts.has(branchName)) {
-      checkouts.set(branchName, new Date(timestamp))
-    }
-  }
-
-  return checkouts
-}

package/src/git/refs.ts

@@ -1,63 +0,0 @@
-import { git } from './core'
-import { Repository } from '../models/repository'
-
-/**
- * Format a local branch in the ref syntax, ensuring situations when the branch
- * is ambiguous are handled.
- *
- * Examples:
- *  - main -> refs/heads/main
- *  - heads/Microsoft/main -> refs/heads/Microsoft/main
- *
- * @param branch The local branch name
- */
-export function formatAsLocalRef(name: string): string {
-  if (name.startsWith('heads/')) {
-    // In some cases, Git will report this name explicitly to distinguish from
-    // a remote ref with the same name - this ensures we format it correctly.
-    return `refs/${name}`
-  } else if (!name.startsWith('refs/heads/')) {
-    // By default Git will drop the heads prefix unless absolutely necessary
-    // - include this to ensure the ref is fully qualified.
-    return `refs/heads/${name}`
-  } else {
-    return name
-  }
-}
-
-/**
- * Read a symbolic ref from the repository.
- *
- * Symbolic refs are used to point to other refs, similar to how symlinks work
- * for files. Because refs can be removed easily from a Git repository,
- * symbolic refs should only be used when absolutely necessary.
- *
- * @param repository The repository to lookup
- * @param ref The symbolic ref to resolve
- *
- * @returns the canonical ref, if found, or `null` if `ref` cannot be found or
- *          is not a symbolic ref
- */
-export async function getSymbolicRef(
-  repository: Repository,
-  ref: string
-): Promise<string | null> {
-  const result = await git(
-    ['symbolic-ref', '-q', ref],
-    repository.path,
-    'getSymbolicRef',
-    {
-      //  - 1 is the exit code that Git throws in quiet mode when the ref is not a
-      //    symbolic ref
-      //  - 128 is the generic error code that Git returns when it can't find
-      //    something
-      successExitCodes: new Set([0, 1, 128]),
-    }
-  )
-
-  if (result.exitCode === 1 || result.exitCode === 128) {
-    return null
-  }
-
-  return result.stdout.trim()
-}

package/src/git/remote.ts

@@ -1,143 +0,0 @@
-import { git } from './core'
-import { GitError } from './exec'
-
-import { Repository } from '../models/repository'
-import { IRemote } from '../models/remote'
-import { envForRemoteOperation } from './environment'
-import { getSymbolicRef } from './refs'
-import memoizeOne from 'memoize-one'
-
-/**
- * List the remotes, sorted alphabetically by `name`, for a repository.
- */
-export async function getRemotes(
-  repository: Repository
-): Promise<ReadonlyArray<IRemote>> {
-  return memoizedGetRemotesFromPath(repository.path)
-}
-
-/**
- * List the remotes, sorted alphabetically by `name`, for a repository path.
- */
-export async function getRemotesFromPath(
-  path: string
-): Promise<ReadonlyArray<IRemote>> {
-  const result = await git(['remote', '-v'], path, 'getRemotes', {
-    expectedErrors: new Set([GitError.NotAGitRepository]),
-  })
-
-  if (result.gitError === GitError.NotAGitRepository) {
-    return []
-  }
-
-  return [...result.stdout.matchAll(/^(.+)\t(.+)\s\(fetch\)/gm)].map(
-    ([, name, url]) => ({ name, url })
-  )
-}
-export const memoizedGetRemotesFromPath = memoizeOne(getRemotesFromPath)
-
-/** Add a new remote with the given URL. */
-export async function addRemote(
-  repository: Repository,
-  name: string,
-  url: string
-): Promise<IRemote> {
-  await git(['remote', 'add', name, url], repository.path, 'addRemote')
-
-  return { url, name }
-}
-
-/** Removes an existing remote, or silently errors if it doesn't exist */
-export async function removeRemote(
-  repository: Repository,
-  name: string
-): Promise<void> {
-  const options = {
-    successExitCodes: new Set([0, 2, 128]),
-  }
-
-  await git(
-    ['remote', 'remove', name],
-    repository.path,
-    'removeRemote',
-    options
-  )
-}
-
-/** Changes the URL for the remote that matches the given name  */
-export async function setRemoteURL(
-  repository: Repository,
-  name: string,
-  url: string
-): Promise<true> {
-  await git(['remote', 'set-url', name, url], repository.path, 'setRemoteURL')
-  return true
-}
-
-/**
- * Get the URL for the remote that matches the given name.
- *
- * Returns null if the remote could not be found
- */
-export async function getRemoteURL(
-  repository: Repository,
-  name: string
-): Promise<string | null> {
-  const result = await git(
-    ['remote', 'get-url', name],
-    repository.path,
-    'getRemoteURL',
-    { successExitCodes: new Set([0, 2, 128]) }
-  )
-
-  if (result.exitCode !== 0) {
-    return null
-  }
-
-  return result.stdout
-}
-
-/**
- * Update the HEAD ref of the remote, which is the default branch.
- *
- * @param isBackgroundTask Whether the fetch is being performed as a
- *                         background task as opposed to being user initiated
- */
-export async function updateRemoteHEAD(
-  repository: Repository,
-  remote: IRemote,
-  isBackgroundTask: boolean
-): Promise<void> {
-  const options = {
-    successExitCodes: new Set([0, 1, 128]),
-    env: await envForRemoteOperation(remote.url),
-    isBackgroundTask,
-  }
-
-  await git(
-    ['remote', 'set-head', '-a', remote.name],
-    repository.path,
-    'updateRemoteHEAD',
-    options
-  )
-}
-
-export async function getRemoteHEAD(
-  repository: Repository,
-  remote: string
-): Promise<string | null> {
-  const remoteNamespace = `refs/remotes/${remote}/`
-  const match = await getSymbolicRef(repository, `${remoteNamespace}HEAD`)
-  if (
-    match != null &&
-    match.length > remoteNamespace.length &&
-    match.startsWith(remoteNamespace)
-  ) {
-    // strip out everything related to the remote because this
-    // is likely to be a tracked branch locally
-    // e.g. `main`, `develop`, etc
-    return match.substring(remoteNamespace.length)
-  }
-
-  return null
-}

package/src/git/reorder.ts

@@ -1,153 +0,0 @@
-import { appendFile, rm } 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'
-
-/**
- * Reorders provided commits by calling interactive rebase.
- *
- * Goal is to replay the commits in order from oldest to newest to reduce
- * conflicts with toMove commits placed in the log at the location of the
- * prior to the base commit.
- *
- * Example: A user's history from oldest to newest is A, B, C, D, E and they
- * want to move A and E (toMove) before C. Our goal:  B, A, E, C, D. Thus,
- * maintaining that A came before E, placed in history before the the base
- * commit C.
- *
- * @param toMove - commits to move
- * @param beforeCommit  - commits will be moved right before this commit. If it's
- * null, the commits will be moved to the end of the history.
- * @param lastRetainedCommitRef - sha of commit before commits to reorder or null
- * if base commit for reordering is the root (first in history) of the branch
- */
-export async function reorder(
-  repository: Repository,
-  toMove: ReadonlyArray<Commit>,
-  beforeCommit: Commit | null,
-  lastRetainedCommitRef: string | null,
-  progressCallback?: (progress: IMultiCommitOperationProgress) => void
-): Promise<RebaseResult> {
-  let todoPath
-  let result: RebaseResult
-
-  try {
-    if (toMove.length === 0) {
-      throw new Error('[reorder] No commits provided to reorder.')
-    }
-
-    const toMoveShas = new Set(toMove.map(c => c.sha))
-
-    const commits = await getCommits(
-      repository,
-      lastRetainedCommitRef === null
-        ? undefined
-        : revRange(lastRetainedCommitRef, 'HEAD')
-    )
-
-    if (commits.length === 0) {
-      throw new Error(
-        '[reorder] Could not find commits in log for last retained commit ref.'
-      )
-    }
-
-    todoPath = await getTempFilePath('reorderTodo')
-    let foundBaseCommitInLog = false
-    const toReplayBeforeBaseCommit = []
-    const toReplayAfterReorder = []
-
-    // 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 (toMoveShas.has(commit.sha)) {
-        // If it is toMove commit and we have found the base commit, we
-        // can go ahead and insert them (as we will hold any picks till after)
-        if (foundBaseCommitInLog) {
-          await appendFile(todoPath, `pick ${commit.sha} ${commit.summary}\n`)
-        } else {
-          // However, if we have not found the base commit yet we want to
-          // keep track of them in the order of the log. Thus, we use a new
-          // `toReplayBeforeBaseCommit` array and not trust that what was sent is in the
-          // order of the log.
-          toReplayBeforeBaseCommit.push(commit)
-        }
-
-        continue
-      }
-
-      // If it's the base commit, replay to the toMove in the order they
-      // appeared on the log to reduce potential conflicts.
-      if (beforeCommit !== null && commit.sha === beforeCommit.sha) {
-        foundBaseCommitInLog = true
-        toReplayAfterReorder.push(commit)
-
-        for (let j = 0; j < toReplayBeforeBaseCommit.length; j++) {
-          await appendFile(
-            todoPath,
-            `pick ${toReplayBeforeBaseCommit[j].sha} ${toReplayBeforeBaseCommit[j].summary}\n`
-          )
-        }
-
-        continue
-      }
-
-      // We can't just replay a pick in case there is a commit from the toMove
-      // commits further up in history that need to be moved. Thus, we will keep
-      // track of these and replay after traversing the remainder of the log.
-      if (foundBaseCommitInLog) {
-        toReplayAfterReorder.push(commit)
-        continue
-      }
-
-      // If it is not one toMove nor the base commit and have not found the base
-      // commit, we simply record it is an unchanged pick (before the base commit)
-      await appendFile(todoPath, `pick ${commit.sha} ${commit.summary}\n`)
-    }
-
-    if (toReplayAfterReorder.length > 0) {
-      for (let i = 0; i < toReplayAfterReorder.length; i++) {
-        await appendFile(
-          todoPath,
-          `pick ${toReplayAfterReorder[i].sha} ${toReplayAfterReorder[i].summary}\n`
-        )
-      }
-    }
-
-    if (beforeCommit === null) {
-      for (let i = 0; i < toReplayBeforeBaseCommit.length; i++) {
-        await appendFile(
-          todoPath,
-          `pick ${toReplayBeforeBaseCommit[i].sha} ${toReplayBeforeBaseCommit[i].summary}\n`
-        )
-      }
-    } else if (!foundBaseCommitInLog) {
-      throw new Error(
-        '[reorder] The base commit onto was not in the log. Continuing would result in dropping the commits in the toMove array.'
-      )
-    }
-
-    result = await rebaseInteractive(
-      repository,
-      todoPath,
-      lastRetainedCommitRef,
-      {
-        action: MultiCommitOperationKind.Reorder,
-        progressCallback,
-        commits,
-      }
-    )
-  } catch (e) {
-    console.error(e)
-    return RebaseResult.Error
-  } finally {
-    if (todoPath !== undefined) {
-      await rm(todoPath, { recursive: true, force: true })
-    }
-  }
-
-  return result
-}

package/src/git/reset.ts

@@ -1,101 +0,0 @@
-import { git } from './core'
-import { Repository } from '../models/repository'
-import { assertNever } from '../lib/fatal-error'
-
-/** The reset modes which are supported. */
-export const enum GitResetMode {
-  /**
-   * Resets the index and working tree. Any changes to tracked files in the
-   * working tree since <commit> are discarded.
-   */
-  Hard = 0,
-  /**
-   * Does not touch the index file or the working tree at all (but resets the
-   * head to <commit>, just like all modes do). This leaves all your changed
-   * files "Changes to be committed", as git status would put it.
-   */
-  Soft,
-
-  /**
-   * Resets the index but not the working tree (i.e., the changed files are
-   * preserved but not marked for commit) and reports what has not been updated.
-   * This is the default action for git reset.
-   */
-  Mixed,
-}
-
-function resetModeToArgs(mode: GitResetMode, ref: string): string[] {
-  switch (mode) {
-    case GitResetMode.Hard:
-      return ['reset', '--hard', ref]
-    case GitResetMode.Mixed:
-      return ['reset', ref]
-    case GitResetMode.Soft:
-      return ['reset', '--soft', ref]
-    default:
-      return assertNever(mode, `Unknown reset mode: ${mode}`)
-  }
-}
-
-/** Reset with the mode to the ref. */
-export async function reset(
-  repository: Repository,
-  mode: GitResetMode,
-  ref: string
-): Promise<true> {
-  const args = resetModeToArgs(mode, ref)
-  await git(args, repository.path, 'reset')
-  return true
-}
-
-/**
- * Updates the index with information from a particular tree for a given
- * set of paths.
- *
- * @param repository The repository in which to reset the index.
- *
- * @param mode      Which mode to use when resetting, see the GitResetMode
- *                  enum for more information.
- *
- * @param ref       A string which resolves to a tree, for example 'HEAD' or a
- *                  commit sha.
- *
- * @param paths     The paths that should be updated in the index with information
- *                  from the given tree
- */
-export async function resetPaths(
-  repository: Repository,
-  mode: GitResetMode,
-  ref: string,
-  paths: ReadonlyArray<string>
-): Promise<void> {
-  if (!paths.length) {
-    return
-  }
-
-  const baseArgs = resetModeToArgs(mode, ref)
-
-  if (process.platform === 'win32' && mode === GitResetMode.Mixed) {
-    // Git for Windows has experimental support for reading paths to reset
-    // from standard input. This is helpful in situations where your file
-    // paths are greater than 32KB in length, because of shell limitations.
-    //
-    // This hasn't made it to Git core, so we fallback to the default behaviour
-    // as macOS and Linux don't have this same shell limitation. See
-    // https://github.com/desktop/desktop/issues/2833#issuecomment-331352952
-    // for more context.
-    const args = [...baseArgs, '--stdin', '-z', '--']
-    await git(args, repository.path, 'resetPaths', {
-      stdin: paths.join('\0'),
-    })
-  } else {
-    const args = [...baseArgs, '--', ...paths]
-    await git(args, repository.path, 'resetPaths')
-  }
-}
-
-/** Unstage all paths. */
-export async function unstageAll(repository: Repository): Promise<true> {
-  await git(['reset', '--', '.'], repository.path, 'unstageAll')
-  return true
-}