1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
package furgit
import (
"bytes"
"errors"
"fmt"
"strconv"
)
// ObjType mirrors Git's object type tags.
type ObjType uint8
const (
ObjInvalid ObjType = 0
ObjCommit ObjType = 1
ObjTree ObjType = 2
ObjBlob ObjType = 3
ObjTag ObjType = 4
ObjFuture ObjType = 5
ObjOfsDelta ObjType = 6
ObjRefDelta ObjType = 7
)
const (
objNameBlob = "blob"
objNameTree = "tree"
objNameCommit = "commit"
objNameTag = "tag"
)
// Object describes any Git object variant.
type Object interface {
ObjType() ObjType
}
func computeRawHash(data []byte, hashSize int) Hash {
hashFunc := hashFuncs[hashSize]
return hashFunc(data)
}
func headerForType(ty ObjType, 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:
return nil, fmt.Errorf("furgit: object: unsupported type %d", ty)
default:
return nil, fmt.Errorf("furgit: object: unsupported type %d", ty)
}
size := strconv.Itoa(len(body))
var buf bytes.Buffer
buf.Grow(len(tyStr) + len(size) + 1)
buf.WriteString(tyStr)
buf.WriteByte(' ')
buf.WriteString(size)
buf.WriteByte(0)
return buf.Bytes(), nil
}
func verifyRawObject(buf []byte, want Hash, hashSize int) bool {
return computeRawHash(buf, hashSize) == want
}
func verifyTypedObject(ty ObjType, body []byte, want Hash, hashSize int) bool {
header, err := headerForType(ty, body)
if err != nil {
return false
}
raw := make([]byte, len(header)+len(body))
copy(raw, header)
copy(raw[len(header):], body)
return computeRawHash(raw, hashSize) == want
}
func parseObjectBody(ty ObjType, id Hash, body []byte, hashSize int) (Object, error) {
switch ty {
case ObjBlob:
return parseBlob(id, body)
case ObjTree:
return parseTree(id, body, hashSize)
case ObjCommit:
return parseCommit(id, body, hashSize)
case ObjTag:
return parseTag(id, body, hashSize)
case ObjInvalid, ObjFuture, ObjOfsDelta, ObjRefDelta:
return nil, fmt.Errorf("furgit: object: unsupported type %d", ty)
default:
return nil, fmt.Errorf("furgit: object: unknown type %d", ty)
}
}
// ReadObject resolves an ID by consulting loose then packed storage.
func (repo *Repository) ReadObject(id Hash) (Object, error) {
obj, err := repo.looseRead(id)
if err == nil {
return obj, nil
}
if !errors.Is(err, ErrNotFound) {
return nil, err
}
obj, err = repo.packRead(id)
if errors.Is(err, ErrNotFound) {
return nil, ErrInvalidObject
}
return obj, err
}
// ReadObjectTypeSize reports the object type and size without inflating the body.
func (repo *Repository) ReadObjectTypeSize(id Hash) (ObjType, int64, error) {
ty, size, err := repo.looseTypeSize(id)
if err == nil {
return ty, size, nil
}
if !errors.Is(err, ErrNotFound) {
return ObjInvalid, 0, err
}
loc, err := repo.packIndexFind(id)
if err != nil {
if errors.Is(err, ErrNotFound) {
return ObjInvalid, 0, ErrInvalidObject
}
return ObjInvalid, 0, err
}
return repo.packTypeSizeAtLocation(loc, nil)
}
|
