git-chopstick-core 0.1.0

package/src/models/diff/diff-selection.ts

@@ -0,0 +1,165 @@
+export enum DiffSelectionType {
+  All = 'All',
+  Partial = 'Partial',
+  None = 'None',
+}
+
+function typeMatchesSelection(
+  selectionType: DiffSelectionType,
+  selected: boolean
+): boolean {
+  switch (selectionType) {
+    case DiffSelectionType.All:
+      return selected
+    case DiffSelectionType.None:
+      return !selected
+    case DiffSelectionType.Partial:
+      return false
+  }
+}
+
+export class DiffSelection {
+  public static fromInitialSelection(
+    initialSelection: DiffSelectionType.All | DiffSelectionType.None
+  ): DiffSelection {
+    return new DiffSelection(initialSelection, null, null)
+  }
+
+  private constructor(
+    private readonly defaultSelectionType: DiffSelectionType.All | DiffSelectionType.None,
+    private readonly divergingLines: Set<number> | null = null,
+    private readonly selectableLines: Set<number> | null = null
+  ) {}
+
+  public getSelectionType(): DiffSelectionType {
+    const divergingLines = this.divergingLines
+    const selectableLines = this.selectableLines
+
+    if (!divergingLines || divergingLines.size === 0) {
+      return this.defaultSelectionType
+    }
+
+    if (selectableLines && selectableLines.size === divergingLines.size) {
+      const allSelectableLinesAreDivergent = [...selectableLines].every(i =>
+        divergingLines.has(i)
+      )
+      if (allSelectableLinesAreDivergent) {
+        return this.defaultSelectionType === DiffSelectionType.All
+          ? DiffSelectionType.None
+          : DiffSelectionType.All
+      }
+    }
+
+    return DiffSelectionType.Partial
+  }
+
+  public isSelected(lineIndex: number): boolean {
+    const lineIsDivergent =
+      !!this.divergingLines && this.divergingLines.has(lineIndex)
+
+    if (this.defaultSelectionType === DiffSelectionType.All) {
+      return !lineIsDivergent
+    }
+    return lineIsDivergent
+  }
+
+  public isRangeSelected(from: number, length: number): DiffSelectionType {
+    if (length <= 0) return DiffSelectionType.None
+
+    const computedSelectionType = this.getSelectionType()
+    if (computedSelectionType !== DiffSelectionType.Partial) {
+      return computedSelectionType
+    }
+
+    if (length === 1) {
+      return this.isSelected(from) ? DiffSelectionType.All : DiffSelectionType.None
+    }
+
+    const to = from + length
+    let foundSelected = false
+    let foundDeselected = false
+    for (let i = from; i < to; i++) {
+      if (this.isSelected(i)) foundSelected = true
+      if (!this.isSelected(i)) foundDeselected = true
+      if (foundSelected && foundDeselected) return DiffSelectionType.Partial
+    }
+
+    return foundSelected ? DiffSelectionType.All : DiffSelectionType.None
+  }
+
+  public isSelectable(lineIndex: number): boolean {
+    return this.selectableLines ? this.selectableLines.has(lineIndex) : true
+  }
+
+  public withLineSelection(lineIndex: number, selected: boolean): DiffSelection {
+    return this.withRangeSelection(lineIndex, 1, selected)
+  }
+
+  public withRangeSelection(from: number, length: number, selected: boolean): DiffSelection {
+    const computedSelectionType = this.getSelectionType()
+    const to = from + length
+
+    if (typeMatchesSelection(computedSelectionType, selected)) {
+      return this
+    }
+
+    if (computedSelectionType === DiffSelectionType.Partial) {
+      const newDivergingLines = new Set<number>(this.divergingLines!)
+
+      if (typeMatchesSelection(this.defaultSelectionType, selected)) {
+        for (let i = from; i < to; i++) {
+          newDivergingLines.delete(i)
+        }
+      } else {
+        for (let i = from; i < to; i++) {
+          if (this.isSelectable(i)) {
+            newDivergingLines.add(i)
+          }
+        }
+      }
+
+      return new DiffSelection(
+        this.defaultSelectionType,
+        newDivergingLines.size === 0 ? null : newDivergingLines,
+        this.selectableLines
+      )
+    }
+
+    const newDivergingLines = new Set<number>()
+    for (let i = from; i < to; i++) {
+      if (this.isSelectable(i)) {
+        newDivergingLines.add(i)
+      }
+    }
+
+    return new DiffSelection(
+      computedSelectionType,
+      newDivergingLines,
+      this.selectableLines
+    )
+  }
+
+  public withToggleLineSelection(lineIndex: number): DiffSelection {
+    return this.withLineSelection(lineIndex, !this.isSelected(lineIndex))
+  }
+
+  public withSelectAll(): DiffSelection {
+    return new DiffSelection(DiffSelectionType.All, null, this.selectableLines)
+  }
+
+  public withSelectNone(): DiffSelection {
+    return new DiffSelection(DiffSelectionType.None, null, this.selectableLines)
+  }
+
+  public withSelectableLines(selectableLines: Set<number>) {
+    const divergingLines = this.divergingLines
+      ? new Set([...this.divergingLines].filter(x => selectableLines.has(x)))
+      : null
+
+    return new DiffSelection(
+      this.defaultSelectionType,
+      divergingLines,
+      selectableLines
+    )
+  }
+}

package/src/models/diff/image-diff.ts

@@ -0,0 +1,6 @@
+export enum ImageDiffType {
+  TwoUp,
+  Swipe,
+  OnionSkin,
+  Difference,
+}

package/src/models/diff/image.ts

@@ -0,0 +1,8 @@
+export class Image {
+  public constructor(
+    public readonly rawContents: ArrayBufferLike,
+    public readonly contents: string,
+    public readonly mediaType: string,
+    public readonly bytes: number
+  ) {}
+}

package/src/models/diff/index.ts

@@ -0,0 +1,6 @@
+export * from './diff-data'
+export * from './diff-line'
+export * from './diff-selection'
+export * from './image'
+export * from './raw-diff'
+export * from './image-diff'

package/src/models/diff/raw-diff.ts

@@ -0,0 +1,41 @@
+import { DiffLine } from './diff-line'
+
+export enum DiffHunkExpansionType {
+  None = 'None',
+  Up = 'Up',
+  Down = 'Down',
+  Both = 'Both',
+  Short = 'Short',
+}
+
+export class DiffHunk {
+  public constructor(
+    public readonly header: DiffHunkHeader,
+    public readonly lines: ReadonlyArray<DiffLine>,
+    public readonly unifiedDiffStart: number,
+    public readonly unifiedDiffEnd: number,
+    public readonly expansionType: DiffHunkExpansionType
+  ) {}
+}
+
+export class DiffHunkHeader {
+  public constructor(
+    public readonly oldStartLine: number,
+    public readonly oldLineCount: number,
+    public readonly newStartLine: number,
+    public readonly newLineCount: number
+  ) {}
+
+  public toDiffLineRepresentation() {
+    return `@@ -${this.oldStartLine},${this.oldLineCount} +${this.newStartLine},${this.newLineCount} @@`
+  }
+}
+
+export interface IRawDiff {
+  readonly header: string
+  readonly contents: string
+  readonly hunks: ReadonlyArray<DiffHunk>
+  readonly isBinary: boolean
+  readonly maxLineNumber: number
+  readonly hasHiddenBidiChars: boolean
+}

package/src/models/git-author.ts

@@ -0,0 +1,16 @@
+export class GitAuthor {
+  public static parse(value: string): GitAuthor | null {
+    const m = value.match(/^(.*?)\s*<(.+?)>\s*$/)
+    if (!m) return null
+    return new GitAuthor(m[1], m[2])
+  }
+
+  public constructor(
+    public readonly name: string,
+    public readonly email: string
+  ) {}
+
+  public toString(): string {
+    return `${this.name} <${this.email}>`
+  }
+}

package/src/models/manual-conflict-resolution.ts

@@ -0,0 +1,4 @@
+export enum ManualConflictResolution {
+  theirs = 'theirs',
+  ours = 'ours',
+}

package/src/models/merge.ts

@@ -0,0 +1,6 @@
+export type MergeTreeResult = {
+  readonly sha: string
+  readonly tree: string
+  readonly conflicted: boolean
+  readonly mergeBase: string
+}

package/src/models/multi-commit-operation.ts

@@ -0,0 +1,6 @@
+export enum MultiCommitOperationKind {
+  Squash = 'Squash',
+  Reorder = 'Reorder',
+  CherryPick = 'CherryPick',
+  Amend = 'Amend',
+}

package/src/models/progress.ts

@@ -0,0 +1,67 @@
+interface IProgress {
+  readonly value: number
+  readonly title?: string
+  readonly description?: string
+}
+
+export interface IGenericProgress extends IProgress {
+  kind: 'generic'
+}
+
+export interface ICheckoutProgress extends IProgress {
+  kind: 'checkout'
+  readonly target: string
+  readonly description: string
+}
+
+export interface IFetchProgress extends IProgress {
+  kind: 'fetch'
+  readonly remote: string
+}
+
+export interface IPullProgress extends IProgress {
+  kind: 'pull'
+  readonly remote: string
+}
+
+export interface IPushProgress extends IProgress {
+  kind: 'push'
+  readonly remote: string
+  readonly branch: string
+}
+
+export interface ICloneProgress extends IProgress {
+  kind: 'clone'
+}
+
+export interface IRevertProgress extends IProgress {
+  kind: 'revert'
+}
+
+export interface IMultiCommitOperationProgress extends IProgress {
+  readonly kind: 'multiCommitOperation'
+  readonly currentCommitSummary: string
+  readonly position: number
+  readonly totalCommitCount: number
+}
+
+export type Progress =
+  | IGenericProgress
+  | ICheckoutProgress
+  | IFetchProgress
+  | IPullProgress
+  | IPushProgress
+  | IRevertProgress
+  | IMultiCommitOperationProgress
+
+export function clampProgress<T extends Progress>(
+  minimum: number,
+  maximum: number,
+  progressCallback: (progress: T) => void
+): (progress: T) => void {
+  return (progress: T) =>
+    progressCallback({
+      ...progress,
+      value: minimum + progress.value * (maximum - minimum),
+    })
+}

package/src/models/rebase.ts

@@ -0,0 +1,20 @@
+import { IMultiCommitOperationProgress } from './progress'
+import { CommitOneLine } from './commit'
+
+export type RebaseInternalState = {
+  readonly targetBranch: string
+  readonly baseBranchTip: string
+  readonly originalBranchTip: string
+}
+
+export type RebaseProgressOptions = {
+  commits: ReadonlyArray<CommitOneLine>
+  progressCallback: (progress: IMultiCommitOperationProgress) => void
+}
+
+export enum ComputedAction {
+  Clean = 'Clean',
+  Conflicts = 'Conflicts',
+  Invalid = 'Invalid',
+  Loading = 'Loading',
+}

package/src/models/remote.ts

@@ -0,0 +1,10 @@
+export interface IRemote {
+  readonly name: string
+  readonly url: string
+}
+
+export function remoteEquals(x: IRemote | null, y: IRemote | null) {
+  if (x === y) return true
+  if (x === null || y === null) return false
+  return x.name === y.name && x.url === y.url
+}

package/src/models/repository.ts

@@ -0,0 +1,16 @@
+import * as Path from 'path'
+
+export class Repository {
+  public readonly name: string
+
+  public constructor(
+    public readonly path: string,
+    public readonly id: number
+  ) {
+    this.name = Path.basename(path)
+  }
+
+  public get resolvedGitDir(): string {
+    return Path.join(this.path, '.git')
+  }
+}

package/src/models/stash-entry.ts

@@ -0,0 +1,25 @@
+import { CommittedFileChange } from './status'
+
+export interface IStashEntry {
+  readonly name: string
+  readonly branchName: string
+  readonly stashSha: string
+  readonly files: StashedFileChanges
+  readonly tree: string
+  readonly parents: ReadonlyArray<string>
+}
+
+export enum StashedChangesLoadStates {
+  NotLoaded = 'NotLoaded',
+  Loading = 'Loading',
+  Loaded = 'Loaded',
+}
+
+export type StashedFileChanges =
+  | {
+      readonly kind: StashedChangesLoadStates.NotLoaded | StashedChangesLoadStates.Loading
+    }
+  | {
+      readonly kind: StashedChangesLoadStates.Loaded
+      readonly files: ReadonlyArray<CommittedFileChange>
+    }

package/src/models/status.ts

@@ -0,0 +1,275 @@
+import { DiffSelection, DiffSelectionType } from './diff'
+
+export enum GitStatusEntry {
+  Modified = 'M',
+  Added = 'A',
+  Deleted = 'D',
+  Renamed = 'R',
+  Copied = 'C',
+  Unchanged = '.',
+  Untracked = '?',
+  Ignored = '!',
+  UpdatedButUnmerged = 'U',
+}
+
+export enum AppFileStatusKind {
+  New = 'New',
+  Modified = 'Modified',
+  Deleted = 'Deleted',
+  Copied = 'Copied',
+  Renamed = 'Renamed',
+  Conflicted = 'Conflicted',
+  Untracked = 'Untracked',
+}
+
+export type PlainFileStatus = {
+  kind: AppFileStatusKind.New | AppFileStatusKind.Modified | AppFileStatusKind.Deleted
+  submoduleStatus?: SubmoduleStatus
+}
+
+export type CopiedOrRenamedFileStatus = {
+  kind: AppFileStatusKind.Copied | AppFileStatusKind.Renamed
+  oldPath: string
+  renameIncludesModifications: boolean
+  submoduleStatus?: SubmoduleStatus
+}
+
+export type ConflictsWithMarkers = {
+  kind: AppFileStatusKind.Conflicted
+  entry: TextConflictEntry
+  conflictMarkerCount: number
+  submoduleStatus?: SubmoduleStatus
+}
+
+export type ManualConflict = {
+  kind: AppFileStatusKind.Conflicted
+  entry: ManualConflictEntry
+  submoduleStatus?: SubmoduleStatus
+}
+
+export type ConflictedFileStatus = ConflictsWithMarkers | ManualConflict
+
+export function isConflictedFileStatus(
+  appFileStatus: AppFileStatus
+): appFileStatus is ConflictedFileStatus {
+  return appFileStatus.kind === AppFileStatusKind.Conflicted
+}
+
+export function isConflictWithMarkers(
+  conflictedFileStatus: ConflictedFileStatus
+): conflictedFileStatus is ConflictsWithMarkers {
+  return 'conflictMarkerCount' in conflictedFileStatus
+}
+
+export type UntrackedFileStatus = {
+  kind: AppFileStatusKind.Untracked
+  submoduleStatus?: SubmoduleStatus
+}
+
+export type AppFileStatus =
+  | PlainFileStatus
+  | CopiedOrRenamedFileStatus
+  | ConflictedFileStatus
+  | UntrackedFileStatus
+
+export type SubmoduleStatus = {
+  readonly commitChanged: boolean
+  readonly modifiedChanges: boolean
+  readonly untrackedChanges: boolean
+}
+
+type OrdinaryEntry = {
+  readonly kind: 'ordinary'
+  readonly type: 'added' | 'modified' | 'deleted'
+  readonly index?: GitStatusEntry
+  readonly workingTree?: GitStatusEntry
+  readonly submoduleStatus?: SubmoduleStatus
+}
+
+type RenamedOrCopiedEntry = {
+  readonly kind: 'renamed' | 'copied'
+  readonly index?: GitStatusEntry
+  readonly workingTree?: GitStatusEntry
+  readonly submoduleStatus?: SubmoduleStatus
+  readonly renameOrCopyScore?: number
+}
+
+export enum UnmergedEntrySummary {
+  AddedByUs = 'added-by-us',
+  DeletedByUs = 'deleted-by-us',
+  AddedByThem = 'added-by-them',
+  DeletedByThem = 'deleted-by-them',
+  BothDeleted = 'both-deleted',
+  BothAdded = 'both-added',
+  BothModified = 'both-modified',
+}
+
+type TextConflictDetails =
+  | {
+      readonly action: UnmergedEntrySummary.BothAdded
+      readonly us: GitStatusEntry.Added
+      readonly them: GitStatusEntry.Added
+    }
+  | {
+      readonly action: UnmergedEntrySummary.BothModified
+      readonly us: GitStatusEntry.UpdatedButUnmerged
+      readonly them: GitStatusEntry.UpdatedButUnmerged
+    }
+
+type TextConflictEntry = {
+  readonly kind: 'conflicted'
+  readonly submoduleStatus?: SubmoduleStatus
+} & TextConflictDetails
+
+type ManualConflictDetails = {
+  readonly submoduleStatus?: SubmoduleStatus
+} & (
+  | { readonly action: UnmergedEntrySummary.BothAdded; readonly us: GitStatusEntry.Added; readonly them: GitStatusEntry.Added }
+  | { readonly action: UnmergedEntrySummary.BothModified; readonly us: GitStatusEntry.UpdatedButUnmerged; readonly them: GitStatusEntry.UpdatedButUnmerged }
+  | { readonly action: UnmergedEntrySummary.AddedByUs; readonly us: GitStatusEntry.Added; readonly them: GitStatusEntry.UpdatedButUnmerged }
+  | { readonly action: UnmergedEntrySummary.DeletedByThem; readonly us: GitStatusEntry.UpdatedButUnmerged; readonly them: GitStatusEntry.Deleted }
+  | { readonly action: UnmergedEntrySummary.AddedByThem; readonly us: GitStatusEntry.UpdatedButUnmerged; readonly them: GitStatusEntry.Added }
+  | { readonly action: UnmergedEntrySummary.DeletedByUs; readonly us: GitStatusEntry.Deleted; readonly them: GitStatusEntry.UpdatedButUnmerged }
+  | { readonly action: UnmergedEntrySummary.BothDeleted; readonly us: GitStatusEntry.Deleted; readonly them: GitStatusEntry.Deleted }
+)
+
+type ManualConflictEntry = {
+  readonly kind: 'conflicted'
+  readonly submoduleStatus?: SubmoduleStatus
+} & ManualConflictDetails
+
+export type UnmergedEntry = TextConflictEntry | ManualConflictEntry
+
+type UntrackedEntry = {
+  readonly kind: 'untracked'
+  readonly submoduleStatus?: SubmoduleStatus
+}
+
+export type FileEntry =
+  | OrdinaryEntry
+  | RenamedOrCopiedEntry
+  | UnmergedEntry
+  | UntrackedEntry
+
+export class FileChange {
+  public readonly id: string
+
+  public constructor(
+    public readonly path: string,
+    public readonly status: AppFileStatus
+  ) {
+    if (
+      status.kind === AppFileStatusKind.Renamed ||
+      status.kind === AppFileStatusKind.Copied
+    ) {
+      this.id = `${status.kind}+${path}+${status.oldPath}`
+    } else {
+      this.id = `${status.kind}+${path}`
+    }
+  }
+
+  public isDeleted(): boolean {
+    return this.status.kind === AppFileStatusKind.Deleted
+  }
+
+  public isNew(): boolean {
+    return this.status.kind === AppFileStatusKind.New
+  }
+
+  public isModified(): boolean {
+    return this.status.kind === AppFileStatusKind.Modified
+  }
+
+  public isUntracked(): boolean {
+    return this.status.kind === AppFileStatusKind.Untracked
+  }
+}
+
+export class WorkingDirectoryFileChange extends FileChange {
+  public constructor(
+    path: string,
+    status: AppFileStatus,
+    public readonly selection: DiffSelection
+  ) {
+    super(path, status)
+  }
+
+  public withIncludeAll(include: boolean): WorkingDirectoryFileChange {
+    const newSelection = include
+      ? this.selection.withSelectAll()
+      : this.selection.withSelectNone()
+    return this.withSelection(newSelection)
+  }
+
+  public withSelection(selection: DiffSelection): WorkingDirectoryFileChange {
+    return new WorkingDirectoryFileChange(this.path, this.status, selection)
+  }
+
+  public isIncludedInCommit(): boolean {
+    return this.selection.getSelectionType() === DiffSelectionType.All
+  }
+
+  public isExcludedFromCommit(): boolean {
+    return this.selection.getSelectionType() === DiffSelectionType.None
+  }
+}
+
+export class CommittedFileChange extends FileChange {
+  public constructor(
+    path: string,
+    status: AppFileStatus,
+    public readonly commitish: string,
+    public readonly parentCommitish: string
+  ) {
+    super(path, status)
+  }
+}
+
+export class WorkingDirectoryStatus {
+  public static fromFiles(
+    files: ReadonlyArray<WorkingDirectoryFileChange>
+  ): WorkingDirectoryStatus {
+    return new WorkingDirectoryStatus(files, getIncludeAllState(files))
+  }
+
+  private readonly fileIxById = new Map<string, number>()
+
+  private constructor(
+    public readonly files: ReadonlyArray<WorkingDirectoryFileChange>,
+    public readonly includeAll: boolean | null = true
+  ) {
+    files.forEach((f, ix) => this.fileIxById.set(f.id, ix))
+  }
+
+  public withIncludeAllFiles(includeAll: boolean): WorkingDirectoryStatus {
+    const newFiles = this.files.map(f => f.withIncludeAll(includeAll))
+    return new WorkingDirectoryStatus(newFiles, includeAll)
+  }
+
+  public findFileWithID(id: string): WorkingDirectoryFileChange | null {
+    const ix = this.fileIxById.get(id)
+    return ix !== undefined ? this.files[ix] || null : null
+  }
+
+  public findFileIndexByID(id: string): number {
+    const ix = this.fileIxById.get(id)
+    return ix !== undefined ? ix : -1
+  }
+}
+
+function getIncludeAllState(
+  files: ReadonlyArray<WorkingDirectoryFileChange>
+): boolean | null {
+  if (!files.length) return true
+
+  const allSelected = files.every(
+    f => f.selection.getSelectionType() === DiffSelectionType.All
+  )
+  const noneSelected = files.every(
+    f => f.selection.getSelectionType() === DiffSelectionType.None
+  )
+
+  if (allSelected) return true
+  if (noneSelected) return false
+  return null
+}

package/src/models/submodule.ts

@@ -0,0 +1,13 @@
+export type SubmoduleEntry = {
+  readonly path: string
+  readonly url: string
+  readonly describe?: string
+  readonly sha: string
+  readonly status: SubmoduleStatus
+}
+
+export type SubmoduleStatus = {
+  readonly commitChanged: boolean
+  readonly modifiedChanges: boolean
+  readonly untrackedChanges: boolean
+}