From ec7ddd9b4e4067a046ea4d9b35fa2601b58823ba Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Sun, 16 Nov 2025 00:00:00 +0000 Subject: Rename ObjType enum --- loose.go | 62 ++++++++++++++++++++++----------------------- obj.go | 58 +++++++++++++++++++++--------------------- obj_blob.go | 4 +-- obj_commit.go | 4 +-- obj_tag.go | 24 +++++++++--------- obj_tree.go | 4 +-- objects_test.go | 6 ++--- pack_pack.go | 78 ++++++++++++++++++++++++++++----------------------------- pack_test.go | 4 +-- repo_test.go | 20 +++++++-------- 10 files changed, 132 insertions(+), 132 deletions(-) diff --git a/loose.go b/loose.go index b8e9b19e..60cdfbc9 100644 --- a/loose.go +++ b/loose.go @@ -32,32 +32,32 @@ func (repo *Repository) looseRead(id Hash) (Object, error) { func (repo *Repository) looseReadTyped(id Hash) (ObjectType, []byte, error) { path, err := repo.loosePath(id) if err != nil { - return ObjInvalid, nil, err + return ObjectTypeInvalid, nil, err } path = repo.repoPath(path) f, err := os.Open(path) if err != nil { if os.IsNotExist(err) { - return ObjInvalid, nil, ErrNotFound + return ObjectTypeInvalid, nil, ErrNotFound } - return ObjInvalid, nil, err + return ObjectTypeInvalid, nil, err } defer func() { _ = f.Close() }() zr, err := zlib.NewReader(f) if err != nil { - return ObjInvalid, nil, err + return ObjectTypeInvalid, nil, err } defer func() { _ = zr.Close() }() raw, err := io.ReadAll(zr) if err != nil { - return ObjInvalid, nil, err + return ObjectTypeInvalid, nil, err } nul := bytes.IndexByte(raw, 0) if nul < 0 { - return ObjInvalid, nil, ErrInvalidObject + return ObjectTypeInvalid, nil, ErrInvalidObject } header := raw[:nul] @@ -65,13 +65,13 @@ func (repo *Repository) looseReadTyped(id Hash) (ObjectType, []byte, error) { ty, declaredSize, err := parseLooseHeader(header) if err != nil { - return ObjInvalid, nil, err + return ObjectTypeInvalid, nil, err } if declaredSize != int64(len(body)) { - return ObjInvalid, nil, ErrInvalidObject + return ObjectTypeInvalid, nil, ErrInvalidObject } if !repo.verifyRawObject(raw, id) { - return ObjInvalid, nil, ErrInvalidObject + return ObjectTypeInvalid, nil, ErrInvalidObject } out := append([]byte(nil), body...) @@ -81,22 +81,22 @@ func (repo *Repository) looseReadTyped(id Hash) (ObjectType, []byte, error) { func (repo *Repository) looseTypeSize(id Hash) (ObjectType, int64, error) { path, err := repo.loosePath(id) if err != nil { - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } path = repo.repoPath(path) // #nosec G304 f, err := os.Open(path) if err != nil { if os.IsNotExist(err) { - return ObjInvalid, 0, ErrNotFound + return ObjectTypeInvalid, 0, ErrNotFound } - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } defer func() { _ = f.Close() }() zr, err := zlib.NewReader(f) if err != nil { - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } defer func() { _ = zr.Close() }() @@ -109,20 +109,20 @@ func (repo *Repository) looseTypeSize(id Hash) (ObjectType, int64, error) { if nul := bytes.IndexByte(data, 0); nul >= 0 { header = append(header, data[:nul]...) if len(header) > looseHeaderLimit { - return ObjInvalid, 0, ErrInvalidObject + return ObjectTypeInvalid, 0, ErrInvalidObject } break } header = append(header, data...) if len(header) > looseHeaderLimit { - return ObjInvalid, 0, ErrInvalidObject + return ObjectTypeInvalid, 0, ErrInvalidObject } } if readErr != nil { if readErr == io.EOF { - return ObjInvalid, 0, ErrInvalidObject + return ObjectTypeInvalid, 0, ErrInvalidObject } - return ObjInvalid, 0, readErr + return ObjectTypeInvalid, 0, readErr } } return parseLooseHeader(header) @@ -131,38 +131,38 @@ func (repo *Repository) looseTypeSize(id Hash) (ObjectType, int64, error) { func parseLooseHeader(header []byte) (ObjectType, int64, error) { space := bytes.IndexByte(header, ' ') if space < 0 { - return ObjInvalid, 0, ErrInvalidObject + return ObjectTypeInvalid, 0, ErrInvalidObject } ty, err := objTypeFromName(string(header[:space])) if err != nil { - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } expect := header[space+1:] if len(expect) == 0 { - return ObjInvalid, 0, ErrInvalidObject + return ObjectTypeInvalid, 0, ErrInvalidObject } size, err := strconv.ParseInt(string(expect), 10, 64) if err != nil { - return ObjInvalid, 0, fmt.Errorf("furgit: loose: size parse: %w", err) + return ObjectTypeInvalid, 0, fmt.Errorf("furgit: loose: size parse: %w", err) } if size < 0 { - return ObjInvalid, 0, ErrInvalidObject + return ObjectTypeInvalid, 0, ErrInvalidObject } return ty, size, nil } func objTypeFromName(name string) (ObjectType, error) { switch name { - case objNameBlob: - return ObjBlob, nil - case objNameTree: - return ObjTree, nil - case objNameCommit: - return ObjCommit, nil - case objNameTag: - return ObjTag, nil + case objectTypeNameBlob: + return ObjectTypeBlob, nil + case objectTypeNameTree: + return ObjectTypeTree, nil + case objectTypeNameCommit: + return ObjectTypeCommit, nil + case objectTypeNameTag: + return ObjectTypeTag, nil default: - return ObjInvalid, ErrInvalidObject + return ObjectTypeInvalid, ErrInvalidObject } } diff --git a/obj.go b/obj.go index ab37c570..de847607 100644 --- a/obj.go +++ b/obj.go @@ -11,21 +11,21 @@ import ( type ObjectType uint8 const ( - ObjInvalid ObjectType = 0 - ObjCommit ObjectType = 1 - ObjTree ObjectType = 2 - ObjBlob ObjectType = 3 - ObjTag ObjectType = 4 - ObjFuture ObjectType = 5 - ObjOfsDelta ObjectType = 6 - ObjRefDelta ObjectType = 7 + ObjectTypeInvalid ObjectType = 0 + ObjectTypeCommit ObjectType = 1 + ObjectTypeTree ObjectType = 2 + ObjectTypeBlob ObjectType = 3 + ObjectTypeTag ObjectType = 4 + ObjectTypeFuture ObjectType = 5 + ObjectTypeOfsDelta ObjectType = 6 + ObjectTypeRefDelta ObjectType = 7 ) const ( - objNameBlob = "blob" - objNameTree = "tree" - objNameCommit = "commit" - objNameTag = "tag" + objectTypeNameBlob = "blob" + objectTypeNameTree = "tree" + objectTypeNameCommit = "commit" + objectTypeNameTag = "tag" ) // Object describes any Git object variant. @@ -36,15 +36,15 @@ type Object interface { func headerForType(ty ObjectType, body []byte) ([]byte, error) { var tyStr string switch ty { - case ObjBlob: - tyStr = objNameBlob - case ObjTree: - tyStr = objNameTree - case ObjCommit: - tyStr = objNameCommit - case ObjTag: - tyStr = objNameTag - case ObjInvalid, ObjFuture, ObjOfsDelta, ObjRefDelta: + case ObjectTypeBlob: + tyStr = objectTypeNameBlob + case ObjectTypeTree: + tyStr = objectTypeNameTree + case ObjectTypeCommit: + tyStr = objectTypeNameCommit + case ObjectTypeTag: + tyStr = objectTypeNameTag + case ObjectTypeInvalid, ObjectTypeFuture, ObjectTypeOfsDelta, ObjectTypeRefDelta: return nil, fmt.Errorf("furgit: object: unsupported type %d", ty) default: return nil, fmt.Errorf("furgit: object: unsupported type %d", ty) @@ -61,15 +61,15 @@ func headerForType(ty ObjectType, body []byte) ([]byte, error) { func parseObjectBody(ty ObjectType, id Hash, body []byte, repo *Repository) (Object, error) { switch ty { - case ObjBlob: + case ObjectTypeBlob: return parseBlob(id, body) - case ObjTree: + case ObjectTypeTree: return parseTree(id, body, repo) - case ObjCommit: + case ObjectTypeCommit: return parseCommit(id, body, repo) - case ObjTag: + case ObjectTypeTag: return parseTag(id, body, repo) - case ObjInvalid, ObjFuture, ObjOfsDelta, ObjRefDelta: + case ObjectTypeInvalid, ObjectTypeFuture, ObjectTypeOfsDelta, ObjectTypeRefDelta: return nil, fmt.Errorf("furgit: object: unsupported type %d", ty) default: return nil, fmt.Errorf("furgit: object: unknown type %d", ty) @@ -99,14 +99,14 @@ func (repo *Repository) ReadObjectTypeSize(id Hash) (ObjectType, int64, error) { return ty, size, nil } if !errors.Is(err, ErrNotFound) { - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } loc, err := repo.packIndexFind(id) if err != nil { if errors.Is(err, ErrNotFound) { - return ObjInvalid, 0, ErrInvalidObject + return ObjectTypeInvalid, 0, ErrInvalidObject } - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } return repo.packTypeSizeAtLocation(loc, nil) } diff --git a/obj_blob.go b/obj_blob.go index d3be2f23..c25f88eb 100644 --- a/obj_blob.go +++ b/obj_blob.go @@ -10,7 +10,7 @@ type Blob struct { // ObjectType allows Blob to satisfy the Object interface. func (blob *Blob) ObjectType() ObjectType { _ = blob - return ObjBlob + return ObjectTypeBlob } func parseBlob(id Hash, body []byte) (*Blob, error) { @@ -23,7 +23,7 @@ func parseBlob(id Hash, body []byte) (*Blob, error) { // Serialize renders the full "blob size\\0body" representation. func (blob *Blob) Serialize() ([]byte, error) { - header, err := headerForType(ObjBlob, blob.Data) + header, err := headerForType(ObjectTypeBlob, blob.Data) if err != nil { return nil, err } diff --git a/obj_commit.go b/obj_commit.go index 628a188a..f1616fba 100644 --- a/obj_commit.go +++ b/obj_commit.go @@ -20,7 +20,7 @@ type Commit struct { // ObjectType allows Commit to satisfy the Object interface. func (commit *Commit) ObjectType() ObjectType { _ = commit - return ObjCommit + return ObjectTypeCommit } func parseCommit(id Hash, body []byte, repo *Repository) (*Commit, error) { @@ -124,7 +124,7 @@ func (commit *Commit) Serialize() ([]byte, error) { if err != nil { return nil, err } - header, err := headerForType(ObjCommit, body) + header, err := headerForType(ObjectTypeCommit, body) if err != nil { return nil, err } diff --git a/obj_tag.go b/obj_tag.go index 8c5981e9..20088f17 100644 --- a/obj_tag.go +++ b/obj_tag.go @@ -19,7 +19,7 @@ type Tag struct { // ObjectType allows Tag to satisfy the Object interface. func (tag *Tag) ObjectType() ObjectType { _ = tag - return ObjTag + return ObjectTypeTag } // parseTag parses a tag object body. @@ -51,15 +51,15 @@ func parseTag(id Hash, body []byte, repo *Repository) (*Tag, error) { case bytes.HasPrefix(line, []byte("type ")): switch string(line[5:]) { case "commit": - t.TargetType = ObjCommit + t.TargetType = ObjectTypeCommit case "tree": - t.TargetType = ObjTree + t.TargetType = ObjectTypeTree case "blob": - t.TargetType = ObjBlob + t.TargetType = ObjectTypeBlob case "tag": - t.TargetType = ObjTag + t.TargetType = ObjectTypeTag default: - t.TargetType = ObjInvalid + t.TargetType = ObjectTypeInvalid return nil, errors.New("furgit: tag: unknown target type") } haveType = true @@ -100,15 +100,15 @@ func tagBody(t *Tag) ([]byte, error) { fmt.Fprintf(&buf, "object %s\n", t.Target.String()) buf.WriteString("type ") switch t.TargetType { - case ObjCommit: + case ObjectTypeCommit: buf.WriteString("commit") - case ObjTree: + case ObjectTypeTree: buf.WriteString("tree") - case ObjBlob: + case ObjectTypeBlob: buf.WriteString("blob") - case ObjTag: + case ObjectTypeTag: buf.WriteString("tag") - case ObjInvalid, ObjFuture, ObjOfsDelta, ObjRefDelta: + case ObjectTypeInvalid, ObjectTypeFuture, ObjectTypeOfsDelta, ObjectTypeRefDelta: return nil, fmt.Errorf("furgit: tag: invalid target type %d", t.TargetType) default: return nil, fmt.Errorf("furgit: tag: invalid target type %d", t.TargetType) @@ -138,7 +138,7 @@ func (tag *Tag) Serialize() ([]byte, error) { if err != nil { return nil, err } - header, err := headerForType(ObjTag, body) + header, err := headerForType(ObjectTypeTag, body) if err != nil { return nil, err } diff --git a/obj_tree.go b/obj_tree.go index 8ba1e26f..36c98950 100644 --- a/obj_tree.go +++ b/obj_tree.go @@ -23,7 +23,7 @@ type TreeEntry struct { // ObjectType allows Tree to satisfy the Object interface. func (tree *Tree) ObjectType() ObjectType { _ = tree - return ObjTree + return ObjectTypeTree } // parseTree decodes a tree body. @@ -99,7 +99,7 @@ func treeBody(t *Tree) []byte { // Serialize renders a Tree into canonical Git format. func (tree *Tree) Serialize() ([]byte, error) { body := treeBody(tree) - header, err := headerForType(ObjTree, body) + header, err := headerForType(ObjectTypeTree, body) if err != nil { return nil, err } diff --git a/objects_test.go b/objects_test.go index 8836515c..141ba1d7 100644 --- a/objects_test.go +++ b/objects_test.go @@ -65,7 +65,7 @@ func TestParseBlobAndSerialize(t *testing.T) { if err != nil { t.Fatalf("Serialize error: %v", err) } - header, err := headerForType(ObjBlob, data) + header, err := headerForType(ObjectTypeBlob, data) if err != nil { t.Fatalf("headerForType: %v", err) } @@ -99,7 +99,7 @@ func TestParseTreeAndSerialize(t *testing.T) { if err != nil { t.Fatalf("Serialize error: %v", err) } - header, _ := headerForType(ObjTree, body) + header, _ := headerForType(ObjectTypeTree, body) want := append(append([]byte(nil), header...), body...) if !bytes.Equal(serialized, want) { t.Fatalf("serialized tree mismatch") @@ -190,7 +190,7 @@ func TestParseTagAndSerialize(t *testing.T) { if err != nil { t.Fatalf("parseTag error: %v", err) } - if tag.Target != target || tag.TargetType != ObjCommit { + if tag.Target != target || tag.TargetType != ObjectTypeCommit { t.Fatalf("tag target mismatch") } if tag.Tagger == nil { diff --git a/pack_pack.go b/pack_pack.go index 3ab935cd..1569cf57 100644 --- a/pack_pack.go +++ b/pack_pack.go @@ -81,7 +81,7 @@ func (repo *Repository) packReadAt(loc packlocation, want Hash) (Object, error) func (repo *Repository) packBodyResolveAtLocation(loc packlocation) (ObjectType, borrowedBody, error) { pf, err := repo.packFile(loc.PackPath) if err != nil { - return ObjInvalid, borrowedBody{}, err + return ObjectTypeInvalid, borrowedBody{}, err } return repo.packBodyResolveWithin(pf, loc.Offset) } @@ -89,7 +89,7 @@ func (repo *Repository) packBodyResolveAtLocation(loc packlocation) (ObjectType, func (repo *Repository) packTypeSizeAtLocation(loc packlocation, seen map[packKey]struct{}) (ObjectType, int64, error) { pf, err := repo.packFile(loc.PackPath) if err != nil { - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } return repo.packTypeSizeWithin(pf, loc.Offset, seen) } @@ -100,7 +100,7 @@ func (repo *Repository) packTypeSizeByID(id Hash, seen map[packKey]struct{}) (Ob return repo.packTypeSizeAtLocation(loc, seen) } if !errors.Is(err, ErrNotFound) { - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } return repo.looseTypeSize(id) } @@ -109,7 +109,7 @@ func packHeaderRead(r io.Reader) (ObjectType, int, error) { var b [1]byte _, err := io.ReadFull(r, b[:]) if err != nil { - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } ty := ObjectType((b[0] >> 4) & 0x07) size := int(b[0] & 0x0f) @@ -117,7 +117,7 @@ func packHeaderRead(r io.Reader) (ObjectType, int, error) { for (b[0] & 0x80) != 0 { _, err = io.ReadFull(r, b[:]) if err != nil { - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } size |= int(b[0]&0x7f) << shift shift += 7 @@ -175,30 +175,30 @@ func packSectionInflate(r io.Reader, sizeHint int) (borrowedBody, error) { func (repo *Repository) packDeltaResolveOfs(pf *packFile, deltaOffset uint64, r io.Reader) (ObjectType, borrowedBody, error) { dist, err := packDeltaReadOfsDistance(r) if err != nil { - return ObjInvalid, borrowedBody{}, err + return ObjectTypeInvalid, borrowedBody{}, err } var baseOfs uint64 if deltaOffset > dist { baseOfs = deltaOffset - dist } if baseOfs == 0 { - return ObjInvalid, borrowedBody{}, ErrInvalidObject + return ObjectTypeInvalid, borrowedBody{}, ErrInvalidObject } ty, body, err := repo.packBodyResolveWithin(pf, baseOfs) if err != nil { - return ObjInvalid, borrowedBody{}, err + return ObjectTypeInvalid, borrowedBody{}, err } delta, err := packSectionInflate(r, 0) if err != nil { body.Release() - return ObjInvalid, borrowedBody{}, err + return ObjectTypeInvalid, borrowedBody{}, err } out, err := packDeltaApply(body, delta) delta.Release() body.Release() if err != nil { out.Release() - return ObjInvalid, borrowedBody{}, err + return ObjectTypeInvalid, borrowedBody{}, err } return ty, out, nil } @@ -226,11 +226,11 @@ func (repo *Repository) packBodyResolveByID(id Hash) (ObjectType, borrowedBody, return repo.packBodyResolveAtLocation(loc) } if !errors.Is(err, ErrNotFound) { - return ObjInvalid, borrowedBody{}, err + return ObjectTypeInvalid, borrowedBody{}, err } ty, body, err := repo.looseReadTyped(id) if err != nil { - return ObjInvalid, borrowedBody{}, err + return ObjectTypeInvalid, borrowedBody{}, err } return ty, borrowedFromOwned(body), nil } @@ -242,108 +242,108 @@ type packKey struct { func (repo *Repository) packTypeSizeWithin(pf *packFile, ofs uint64, seen map[packKey]struct{}) (ObjectType, int64, error) { if pf == nil { - return ObjInvalid, 0, ErrInvalidObject + return ObjectTypeInvalid, 0, ErrInvalidObject } if seen == nil { seen = make(map[packKey]struct{}) } key := packKey{path: pf.relPath, ofs: ofs} if _, dup := seen[key]; dup { - return ObjInvalid, 0, ErrInvalidObject + return ObjectTypeInvalid, 0, ErrInvalidObject } seen[key] = struct{}{} defer delete(seen, key) r, err := pf.cursor(ofs) if err != nil { - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } ty, size, err := packHeaderRead(r) if err != nil { - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } declaredSize := int64(size) switch ty { - case ObjCommit, ObjTree, ObjBlob, ObjTag: + case ObjectTypeCommit, ObjectTypeTree, ObjectTypeBlob, ObjectTypeTag: return ty, declaredSize, nil - case ObjRefDelta: + case ObjectTypeRefDelta: var base Hash _, err := io.ReadFull(r, base.data[:repo.hashSize]) if err != nil { - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } base.size = repo.hashSize baseTy, _, err := repo.packTypeSizeByID(base, seen) if err != nil { - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } return baseTy, declaredSize, nil - case ObjOfsDelta: + case ObjectTypeOfsDelta: dist, err := packDeltaReadOfsDistance(r) if err != nil { - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } if ofs <= dist { - return ObjInvalid, 0, ErrInvalidObject + return ObjectTypeInvalid, 0, ErrInvalidObject } baseOfs := ofs - dist baseTy, _, err := repo.packTypeSizeWithin(pf, baseOfs, seen) if err != nil { - return ObjInvalid, 0, err + return ObjectTypeInvalid, 0, err } return baseTy, declaredSize, nil - case ObjInvalid, ObjFuture: - return ObjInvalid, 0, ErrInvalidObject + case ObjectTypeInvalid, ObjectTypeFuture: + return ObjectTypeInvalid, 0, ErrInvalidObject default: - return ObjInvalid, 0, ErrInvalidObject + return ObjectTypeInvalid, 0, ErrInvalidObject } } func (repo *Repository) packBodyResolveWithin(pf *packFile, ofs uint64) (ObjectType, borrowedBody, error) { r, err := pf.cursor(ofs) if err != nil { - return ObjInvalid, borrowedBody{}, err + return ObjectTypeInvalid, borrowedBody{}, err } ty, size, err := packHeaderRead(r) if err != nil { - return ObjInvalid, borrowedBody{}, err + return ObjectTypeInvalid, borrowedBody{}, err } switch ty { - case ObjCommit, ObjTree, ObjBlob, ObjTag: + case ObjectTypeCommit, ObjectTypeTree, ObjectTypeBlob, ObjectTypeTag: body, err := packSectionInflate(r, size) return ty, body, err - case ObjRefDelta: + case ObjectTypeRefDelta: var base Hash _, err := io.ReadFull(r, base.data[:repo.hashSize]) if err != nil { - return ObjInvalid, borrowedBody{}, err + return ObjectTypeInvalid, borrowedBody{}, err } base.size = repo.hashSize delta, err := packSectionInflate(r, 0) if err != nil { - return ObjInvalid, borrowedBody{}, err + return ObjectTypeInvalid, borrowedBody{}, err } bt, body, err := repo.packBodyResolveByID(base) if err != nil { delta.Release() - return ObjInvalid, borrowedBody{}, err + return ObjectTypeInvalid, borrowedBody{}, err } out, err := packDeltaApply(body, delta) delta.Release() body.Release() if err != nil { out.Release() - return ObjInvalid, borrowedBody{}, err + return ObjectTypeInvalid, borrowedBody{}, err } return bt, out, nil - case ObjOfsDelta: + case ObjectTypeOfsDelta: return repo.packDeltaResolveOfs(pf, ofs, r) - case ObjInvalid, ObjFuture: - return ObjInvalid, borrowedBody{}, ErrInvalidObject + case ObjectTypeInvalid, ObjectTypeFuture: + return ObjectTypeInvalid, borrowedBody{}, ErrInvalidObject default: - return ObjInvalid, borrowedBody{}, ErrInvalidObject + return ObjectTypeInvalid, borrowedBody{}, ErrInvalidObject } } diff --git a/pack_test.go b/pack_test.go index c2a3c573..82176ae1 100644 --- a/pack_test.go +++ b/pack_test.go @@ -62,12 +62,12 @@ func encodePackHeader(ty ObjectType, size int) []byte { } func TestPackHeaderRead(t *testing.T) { - buf := encodePackHeader(ObjTree, 0x1fff) + buf := encodePackHeader(ObjectTypeTree, 0x1fff) ty, size, err := packHeaderRead(bytes.NewReader(buf)) if err != nil { t.Fatalf("packHeaderRead error: %v", err) } - if ty != ObjTree || size != 0x1fff { + if ty != ObjectTypeTree || size != 0x1fff { t.Fatalf("unexpected header decode ty=%d size=%d", ty, size) } if _, _, err := packHeaderRead(bytes.NewReader([]byte{0x80})); err == nil { diff --git a/repo_test.go b/repo_test.go index c8eab26e..4f43f33d 100644 --- a/repo_test.go +++ b/repo_test.go @@ -128,7 +128,7 @@ func TestReadObjectTypeSizeLoose(t *testing.T) { if err != nil { t.Fatalf("ReadObjectTypeSize loose error: %v", err) } - if ty != ObjBlob || size != int64(len(data)) { + if ty != ObjectTypeBlob || size != int64(len(data)) { t.Fatalf("unexpected loose metadata ty=%d size=%d", ty, size) } } @@ -139,9 +139,9 @@ func TestReadObjectTypeSizePackedObjects(t *testing.T) { setupRepoConfig(t, root) objs := []testPackObject{ - {finalType: ObjBlob, body: []byte("packed base payload")}, + {finalType: ObjectTypeBlob, body: []byte("packed base payload")}, { - finalType: ObjBlob, + finalType: ObjectTypeBlob, body: []byte("packed delta payload with extra bytes"), encoding: packEncodingOfsDelta, baseIndex: 0, @@ -159,7 +159,7 @@ func TestReadObjectTypeSizePackedObjects(t *testing.T) { if err != nil { t.Fatalf("ReadObjectTypeSize base error: %v", err) } - if ty != ObjBlob || size != int64(len(objs[0].body)) { + if ty != ObjectTypeBlob || size != int64(len(objs[0].body)) { t.Fatalf("unexpected base metadata ty=%d size=%d", ty, size) } @@ -167,7 +167,7 @@ func TestReadObjectTypeSizePackedObjects(t *testing.T) { if err != nil { t.Fatalf("ReadObjectTypeSize delta error: %v", err) } - if ty != ObjBlob || size != int64(len(objs[1].body)) { + if ty != ObjectTypeBlob || size != int64(len(objs[1].body)) { t.Fatalf("unexpected delta metadata ty=%d size=%d", ty, size) } } @@ -188,7 +188,7 @@ func TestReadObjectTypeSizePackRefDeltaLooseBase(t *testing.T) { objs := []testPackObject{ { - finalType: ObjBlob, + finalType: ObjectTypeBlob, body: []byte("ref delta rewritten body"), encoding: packEncodingRefDelta, baseHash: baseID, @@ -201,7 +201,7 @@ func TestReadObjectTypeSizePackRefDeltaLooseBase(t *testing.T) { if err != nil { t.Fatalf("ReadObjectTypeSize ref delta error: %v", err) } - if ty != ObjBlob || size != int64(len(objs[0].body)) { + if ty != ObjectTypeBlob || size != int64(len(objs[0].body)) { t.Fatalf("unexpected ref delta metadata ty=%d size=%d", ty, size) } } @@ -285,7 +285,7 @@ func TestWriteLooseObjectAllTypes(t *testing.T) { // Tag tag := &Tag{ Target: commitID, - TargetType: ObjCommit, + TargetType: ObjectTypeCommit, Name: []byte("v1.0.0"), Tagger: &Ident{ Name: []byte("Test Tagger"), @@ -378,7 +378,7 @@ func writeTestPack(t *testing.T, root, name string, objs []testPackObject) []Has if obj.baseIndex < 0 || obj.baseIndex >= i { t.Fatalf("invalid base index %d for ofs delta %d", obj.baseIndex, i) } - buf.Write(encodePackHeader(ObjOfsDelta, len(obj.body))) + buf.Write(encodePackHeader(ObjectTypeOfsDelta, len(obj.body))) dist := offsets[i] - offsets[obj.baseIndex] buf.Write(encodeOfsDistance(dist)) baseBody := objs[obj.baseIndex].body @@ -392,7 +392,7 @@ func writeTestPack(t *testing.T, root, name string, objs []testPackObject) []Has if len(baseBody) == 0 { t.Fatalf("ref delta %d missing base body", i) } - buf.Write(encodePackHeader(ObjRefDelta, len(obj.body))) + buf.Write(encodePackHeader(ObjectTypeRefDelta, len(obj.body))) buf.Write(obj.baseHash.data[:testHashSize]) delta := buildInsertOnlyDelta(len(baseBody), obj.body) buf.Write(compressBytes(t, delta)) -- cgit v1.3.1-10-gc9f91