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
|
package core
import "strings"
const (
refPrefix = "refs/"
refHeadPrefix = refPrefix + "heads/"
refTagPrefix = refPrefix + "tags/"
refRemotePrefix = refPrefix + "remotes/"
refNotePrefix = refPrefix + "notes/"
symrefPrefix = "ref: "
)
// ReferenceType reference type's
type ReferenceType int8
const (
InvalidReference ReferenceType = 0
HashReference ReferenceType = 1
SymbolicReference ReferenceType = 2
)
// ReferenceName reference name's
type ReferenceName string
const (
HEAD ReferenceName = "HEAD"
)
// Reference is a representation of git reference
type Reference struct {
t ReferenceType
n ReferenceName
h Hash
target ReferenceName
}
// NewReferenceFromStrings creates a reference from name and target as string,
// the resulting reference can be a SymbolicReference or a HashReference base
// on the target provided
func NewReferenceFromStrings(name, target string) *Reference {
r := &Reference{n: ReferenceName(name)}
if strings.HasPrefix(target, symrefPrefix) {
r.t = SymbolicReference
r.target = ReferenceName(target[len(symrefPrefix):])
return r
}
r.t = HashReference
r.h = NewHash(target)
return r
}
// NewSymbolicReference creates a new SymbolicReference reference
func NewSymbolicReference(n, target ReferenceName) *Reference {
return &Reference{
t: SymbolicReference,
n: n,
target: target,
}
}
// NewHashReference creates a new HashReference reference
func NewHashReference(n ReferenceName, h Hash) *Reference {
return &Reference{
t: HashReference,
n: n,
h: h,
}
}
// Type return the type of a reference
func (r *Reference) Type() ReferenceType {
return r.t
}
// Name return the name of a reference
func (r *Reference) Name() ReferenceName {
return r.n
}
// Hash return the hash of a hash reference
func (r *Reference) Hash() Hash {
return r.h
}
// Target return the target of a symbolic reference
func (r *Reference) Target() ReferenceName {
return r.target
}
// IsBranch check if a reference is a branch
func (r *Reference) IsBranch() bool {
return strings.HasPrefix(string(r.n), refHeadPrefix)
}
// IsNote check if a reference is a note
func (r *Reference) IsNote() bool {
return strings.HasPrefix(string(r.n), refNotePrefix)
}
// IsRemote check if a reference is a remote
func (r *Reference) IsRemote() bool {
return strings.HasPrefix(string(r.n), refRemotePrefix)
}
// IsTag check if a reference is a tag
func (r *Reference) IsTag() bool {
return strings.HasPrefix(string(r.n), refTagPrefix)
}
// ReferenceStorage generic storage of references
type ReferenceStorage interface {
Set(Reference) error
Get(ReferenceName) (Reference, error)
Iter(ObjectType) (ReferenceIter, error)
}
// ReferenceIter is a generic closable interface for iterating over references
type ReferenceIter interface {
Next() (Reference, error)
Close()
}
|
