From 94bfb1fa147f80e6ec39009d41fc2f853925e0a5 Mon Sep 17 00:00:00 2001
From: Runxi Yu
Date: Sun, 16 Nov 2025 00:00:00 +0000
Subject: hash: Generic hash-algorithm API

---
 refs.go | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

(limited to 'refs.go')

diff --git a/refs.go b/refs.go
index b543a842..92837454 100644
--- a/refs.go
+++ b/refs.go
@@ -9,44 +9,45 @@ import (
 )
 
 // ResolveRef resolves a fully qualified ref name to its object ID.
-func (repo *Repository) ResolveRef(refname string) (Hash, error) {
+func (repo *Repository[T]) ResolveRef(refname string) (Hash[T], error) {
 	id, err := repo.resolveLooseRef(refname)
 	if err == nil {
 		return id, nil
 	} else if !errors.Is(err, ErrNotFound) {
-		return Hash{}, err
+		return Hash[T]{}, err
 	}
 
 	return repo.resolvePackedRef(refname)
 }
 
-func (repo *Repository) resolveLooseRef(refname string) (Hash, error) {
+func (repo *Repository[T]) resolveLooseRef(refname string) (Hash[T], error) {
 	data, err := os.ReadFile(repo.repoPath(refname))
 	if err != nil {
 		if os.IsNotExist(err) {
-			return Hash{}, ErrNotFound
+			return Hash[T]{}, ErrNotFound
 		}
-		return Hash{}, err
+		return Hash[T]{}, err
 	}
 	line := strings.TrimSpace(string(data))
-	id, err := ParseHashWithSize(line, repo.HashSize)
+	id, err := ParseHash[T](line)
 	if err != nil {
-		return Hash{}, err
+		return Hash[T]{}, err
 	}
 	return id, nil
 }
 
-func (repo *Repository) resolvePackedRef(refname string) (Hash, error) {
+func (repo *Repository[T]) resolvePackedRef(refname string) (Hash[T], error) {
 	path := repo.repoPath("packed-refs")
 	f, err := os.Open(path)
 	if err != nil {
 		if os.IsNotExist(err) {
-			return Hash{}, ErrInvalidObject
+			return Hash[T]{}, ErrInvalidObject
 		}
-		return Hash{}, err
+		return Hash[T]{}, err
 	}
 	defer func() { _ = f.Close() }()
 
+	hashSize := repo.hashSize()
 	want := []byte(refname)
 	scanner := bufio.NewScanner(f)
 	for scanner.Scan() {
@@ -55,28 +56,28 @@ func (repo *Repository) resolvePackedRef(refname string) (Hash, error) {
 			continue
 		}
 		sp := bytes.IndexByte(line, ' ')
-		if sp != repo.HashSize*2 {
+		if sp != hashSize*2 {
 			continue
 		}
 		name := line[sp+1:]
 		if bytes.Equal(name, want) {
 			hex := string(line[:sp])
-			id, err := ParseHashWithSize(hex, repo.HashSize)
+			id, err := ParseHash[T](hex)
 			if err != nil {
-				return Hash{}, err
+				return Hash[T]{}, err
 			}
 			return id, nil
 		}
 	}
 	scanErr := scanner.Err()
 	if scanErr != nil {
-		return Hash{}, scanErr
+		return Hash[T]{}, scanErr
 	}
-	return Hash{}, ErrInvalidObject
+	return Hash[T]{}, ErrInvalidObject
 }
 
 // ResolveHEAD reads HEAD and returns the ref that HEAD points to.
-func (repo *Repository) ResolveHEAD() (string, error) {
+func (repo *Repository[T]) ResolveHEAD() (string, error) {
 	data, err := os.ReadFile(repo.repoPath("HEAD"))
 	if err != nil {
 		return "", err
-- 
cgit v1.3.1-10-gc9f91