feat: Dynamic commit hash length (#5)

Query short commit hash from git instead of using custom `toShortHash()`
to shorten it. This way the length of the commit hash is dynamic instead
of always being 7 chars long. Now e.g. git's `core.abbrev` config option
affects the length of the short hash.

Also query short commit message (the _subject_ of the message) from git
instead of using `toShortCommitMessage()`.

Author: teogeb

CHANGELOG.md

@@ -5,6 +5,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+
+- Dynamic hash length
+
 ## 1.0.0 (2025-01-02)
 
 - Initial release

src/GitFacade.ts

@@ -1,5 +1,5 @@
 import simpleGit, { SimpleGit } from 'simple-git'
-import { BranchName, Commit, CommitHash } from './types'
+import { BranchName, Commit, ShortCommitHash } from './types'
 
 export const NO_UPSTREAM = 'NO_UPSTREAM'
 
@@ -15,6 +15,11 @@ export class GitFacade {
         this.git.cwd(path)
     }
 
+    async getStagedFiles(): Promise<string[]> {
+        const diff = await this.git.diff(['--name-only', '--cached']);
+        return diff.split('\n').filter((line) => line !== '')
+    }
+
     async getCurrentBranch(): Promise<BranchName> {
         const branchSummary = await this.git.branch()
         return branchSummary.current
@@ -36,38 +41,48 @@ export class GitFacade {
     }
 
     async getFeatureBranchCommits(featureBranch: BranchName, mainBranch: BranchName): Promise<readonly Commit[]> {
-        return (await this.git.log([featureBranch, '--not', mainBranch])).all
+        return this.queryCommits(featureBranch, '--not', mainBranch)
     }
 
     async getMainBranchCommits(mainBranch: BranchName): Promise<readonly Commit[]> {
-        return (await this.git.log([mainBranch])).all
+        return await this.queryCommits(mainBranch)
     }
-    
+
     async getCommitsNotInUpstream(): Promise<readonly Commit[] | typeof NO_UPSTREAM> { 
         try {
-            return (await this.git.log(['@{u}..'])).all
+            return (await this.queryCommits('@{u}..'))
         } catch (e: any) {
             if (e.message?.includes('no upstream configured')) {
                 return NO_UPSTREAM
             }
             throw e
         }
     }
-    
-    async getStagedFiles(): Promise<string[]> {
-        const diff = await this.git.diff(['--name-only', '--cached']);
-        return diff.split('\n').filter((line) => line !== '')
+
+    async getLatestFixedCommit(): Promise<Commit> {
+        return (await this.queryCommits('-g', '-1', '--grep-reflog=rebase \(fixup\)'))[0]
+    }
+
+    private async queryCommits(...args: string[]): Promise<Commit[]> {
+        const lines = (await this.git.raw(['log', ...args, '--format=%h %s'])).trim().split('\n')
+        return lines.map((line) => {
+            const separatorIndex = line.indexOf(' ')
+            const hash = line.slice(0, separatorIndex)
+            const subject = line.slice(separatorIndex + 1)
+            return { hash, subject }
+        })
     }
 
-    async commitFixup(hash: CommitHash): Promise<void> {
+
+    async commitFixup(hash: ShortCommitHash): Promise<void> {
         await this.git.commit('', undefined, { '--fixup': hash })
     }
 
-    async rebaseFixupCommit(hash: CommitHash): Promise<boolean> {
+    async rebaseFixupCommit(hash: ShortCommitHash): Promise<boolean> {
         try {
             await this.git.env({ 
                 ...process.env, 
-                GIT_SEQUENCE_EDITOR: 'true' // Bypass the interactive editor
+                GIT_SEQUENCE_EDITOR: 'true'  // bypass the interactive editor
             }).rebase(['--autosquash', '--autostash', '-i', `${hash}~`])
             return false
         } catch (e: any) {
@@ -77,8 +92,4 @@ export class GitFacade {
             throw e
         }
     }
-
-    async getLatestFixedCommit(): Promise<CommitHash> {
-        return await this.git.raw(['log', '-g', '-1', '--grep-reflog=rebase \(fixup\)', '--pretty=format:%h'])
-    }
 }

src/extension.ts

@@ -1,7 +1,6 @@
 import * as vscode from 'vscode'
 import { GitFacade, NO_UPSTREAM } from './GitFacade'
 import { Commit } from './types'
-import { toShortCommitMessage, toShortHash } from './utils'
 
 export const activate = (context: vscode.ExtensionContext): void => {
 
@@ -42,11 +41,11 @@ export const activate = (context: vscode.ExtensionContext): void => {
             const commitsNotInUpstream = await git.getCommitsNotInUpstream()
             const commitChoices = selectableCommits.map((commit: Commit) => {
                 const isInUpstream = (commitsNotInUpstream !== NO_UPSTREAM) && (commitsNotInUpstream.find((upstreamCommit) => upstreamCommit.hash === commit.hash) === undefined)
-                const shortMessage = toShortCommitMessage(commit.message)
+                const messageSubject = commit.subject
                 return {
-                    label: `${isInUpstream ? '$(cloud)' : '$(git-commit)'} ${shortMessage}`,
+                    label: `${isInUpstream ? '$(cloud)' : '$(git-commit)'} ${messageSubject}`,
                     hash: commit.hash,
-                    shortMessage,
+                    messageSubject,
                     isInUpstream: isInUpstream
                 }
             })
@@ -62,12 +61,12 @@ export const activate = (context: vscode.ExtensionContext): void => {
                 await git.commitFixup(selectedCommit.hash)
                 const isMergeConflict = await git.rebaseFixupCommit(selectedCommit.hash)
                 if (isMergeConflict) {
-                    writeToOutputChannel(`Merge conflict while fixing ${toShortHash(selectedCommit.hash)}`)
+                    writeToOutputChannel(`Merge conflict while fixing ${selectedCommit.hash}`)
                     vscode.window.showErrorMessage('Merge conflict\n\nResolve the conflict manually, then use Git: Commit (Amend) to commit the changes.\n', { modal: true })
                     return 
                 }
-                const fixedCommitHash = await git.getLatestFixedCommit()
-                const successMessage = `Fixed: ${toShortHash(selectedCommit.hash)}->${toShortHash(fixedCommitHash)} - ${selectedCommit.shortMessage}`
+                const fixedCommit = await git.getLatestFixedCommit()
+                const successMessage = `Fixed: ${selectedCommit.hash}->${fixedCommit.hash} - ${selectedCommit.messageSubject}`
                 writeToOutputChannel(successMessage)
                 vscode.window.showInformationMessage(successMessage)
             }

src/types.ts

@@ -1,8 +1,8 @@
-export type CommitHash = string
+export type ShortCommitHash = string
 
 export type BranchName = string
 
 export interface Commit {
-    hash: CommitHash
-    message: string
+    hash: ShortCommitHash
+    subject: string
 }

src/utils.ts

@@ -3,7 +3,6 @@ import * as os from 'node:os'
 import * as path from 'node:path'
 import simpleGit, { SimpleGit } from 'simple-git'
 import { GitFacade } from '../src/GitFacade'
-import { toShortHash } from '../src/utils'
 
 describe('GitFacade', () => {
 
@@ -37,9 +36,9 @@ describe('GitFacade', () => {
         git = simpleGit(repoDirectory)
         await git.init(['-b', 'main'])
         await configureGit()
-        await createCommit('lorem\n\n', 'commit 1')
-        await createCommit('lorem\n\n\n\nipsum\n\n', 'commit 2')
-        await createCommit('lorem\n\n\n\nipsum\n\n\n\ndolor', 'commit 3')
+        await createCommit('lorem\n\n', 'subject 1')
+        await createCommit('lorem\n\n\n\nipsum\n\n', 'subject 2')
+        await createCommit('lorem\n\n\n\nipsum\n\n\n\ndolor', 'subject 3\n\nbody test')
         facade = new GitFacade()
         facade.updateWorkingDirectory(repoDirectory)
     })
@@ -52,19 +51,20 @@ describe('GitFacade', () => {
         await facade.commitFixup(fixableCommit.hash)
         const isMergeConflict = await facade.rebaseFixupCommit(fixableCommit.hash)
         expect(isMergeConflict).toBe(false)
-        const fixedCommitHash = await facade.getLatestFixedCommit()
+        const fixedCommit = await facade.getLatestFixedCommit()
         const commitsAfter = await facade.getMainBranchCommits('main')
-        expect(toShortHash(commitsAfter[FIXABLE_COMMIT_INDEX].hash)).toEqual(fixedCommitHash)
-        const fixedCommitDiff = await git.raw(['diff', '-U0', `${fixedCommitHash}~`, `${fixedCommitHash}`])
+        expect(commitsAfter[FIXABLE_COMMIT_INDEX].hash).toEqual(fixedCommit.hash)
+        const fixedCommitDiff = await git.raw(['diff', '-U0', `${fixedCommit.hash}~`, `${fixedCommit.hash}`])
         expect(fixedCommitDiff).toContain('+\n+\n+foobar\n+\n')
-        const fixupCommitDiff = await git.raw(['diff', '-U0', `${fixableCommit.hash}`, `${fixedCommitHash}`])
+        const fixupCommitDiff = await git.raw(['diff', '-U0', `${fixableCommit.hash}`, `${fixedCommit.hash}`])
         expect(fixupCommitDiff).toContain('-ipsum\n+foobar\n')
     })
 
     it('getMainBranchCommits()', async () => {
         const commits = await facade.getMainBranchCommits('main')
         expect(commits).toHaveLength(3)
-        expect(commits.map((c) => c.hash.length)).toEqual([40, 40, 40])
-        expect(commits.map((c) => c.message)).toEqual(['commit 3', 'commit 2', 'commit 1'])
+        const expectedLength = (await git.raw(['rev-parse', '--short', 'HEAD'])).trim().length
+        expect(commits.map((c) => c.hash.length)).toEqual([expectedLength, expectedLength, expectedLength])
+        expect(commits.map((c) => c.subject)).toEqual(['subject 3', 'subject 2', 'subject 1'])
     })
 })