web frontend for git (tangled's grandpa)
git: show lightweight annotated tags (#42)
The "TagObjects" function only returns annotated tags (the ones created
with "-a"). Git interpretes lightweight and annotated tags[^1]
differently, so we need to query all reference and check which one have
a tag object attached.
[^1]: https://git-scm.com/book/en/v2/Git-Basics-Tagging
+75
-23
+75
-23
git/git.go
+75
-23
git/git.go
···
19
19
h plumbing.Hash
20
20
}
21
21
22
-
type TagList []*object.Tag
22
+
type TagList struct {
23
+
refs []*TagReference
24
+
r *git.Repository
25
+
}
26
+
27
+
// TagReference is used to list both tag and non-annotated tags.
28
+
// Non-annotated tags should only contains a reference.
29
+
// Annotated tags should contain its reference and its tag information.
30
+
type TagReference struct {
31
+
ref *plumbing.Reference
32
+
tag *object.Tag
33
+
}
23
34
24
35
// infoWrapper wraps the property of a TreeEntry so it can export fs.FileInfo
25
36
// to tar WriteHeader
···
31
42
isDir bool
32
43
}
33
44
34
-
func (self TagList) Len() int {
35
-
return len(self)
45
+
func (self *TagList) Len() int {
46
+
return len(self.refs)
36
47
}
37
48
38
-
func (self TagList) Swap(i, j int) {
39
-
self[i], self[j] = self[j], self[i]
49
+
func (self *TagList) Swap(i, j int) {
50
+
self.refs[i], self.refs[j] = self.refs[j], self.refs[i]
40
51
}
41
52
42
53
// sorting tags in reverse chronological order
43
-
func (self TagList) Less(i, j int) bool {
44
-
return self[i].Tagger.When.After(self[j].Tagger.When)
54
+
func (self *TagList) Less(i, j int) bool {
55
+
var dateI time.Time
56
+
var dateJ time.Time
57
+
58
+
if self.refs[i].tag != nil {
59
+
dateI = self.refs[i].tag.Tagger.When
60
+
} else {
61
+
c, err := self.r.CommitObject(self.refs[i].ref.Hash())
62
+
if err != nil {
63
+
dateI = time.Now()
64
+
} else {
65
+
dateI = c.Committer.When
66
+
}
67
+
}
68
+
69
+
if self.refs[j].tag != nil {
70
+
dateJ = self.refs[j].tag.Tagger.When
71
+
} else {
72
+
c, err := self.r.CommitObject(self.refs[j].ref.Hash())
73
+
if err != nil {
74
+
dateJ = time.Now()
75
+
} else {
76
+
dateJ = c.Committer.When
77
+
}
78
+
}
79
+
80
+
return dateI.After(dateJ)
45
81
}
46
82
47
83
func Open(path string, ref string) (*GitRepo, error) {
···
116
152
}
117
153
}
118
154
119
-
func (g *GitRepo) Tags() ([]*object.Tag, error) {
120
-
ti, err := g.r.TagObjects()
155
+
func (g *GitRepo) Tags() ([]*TagReference, error) {
156
+
iter, err := g.r.Tags()
121
157
if err != nil {
122
158
return nil, fmt.Errorf("tag objects: %w", err)
123
159
}
124
160
125
-
tags := []*object.Tag{}
161
+
tags := make([]*TagReference, 0)
126
162
127
-
_ = ti.ForEach(func(t *object.Tag) error {
128
-
for i, existing := range tags {
129
-
if existing.Name == t.Name {
130
-
if t.Tagger.When.After(existing.Tagger.When) {
131
-
tags[i] = t
132
-
}
133
-
return nil
134
-
}
163
+
if err := iter.ForEach(func(ref *plumbing.Reference) error {
164
+
obj, err := g.r.TagObject(ref.Hash())
165
+
switch err {
166
+
case nil:
167
+
tags = append(tags, &TagReference{
168
+
ref: ref,
169
+
tag: obj,
170
+
})
171
+
case plumbing.ErrObjectNotFound:
172
+
tags = append(tags, &TagReference{
173
+
ref: ref,
174
+
})
175
+
default:
176
+
return err
135
177
}
136
-
tags = append(tags, t)
137
178
return nil
138
-
})
179
+
}); err != nil {
180
+
return nil, err
181
+
}
139
182
140
-
var tagList TagList
141
-
tagList = tags
183
+
tagList := &TagList{r: g.r, refs: tags}
142
184
sort.Sort(tagList)
143
-
144
185
return tags, nil
145
186
}
146
187
···
290
331
func (i *infoWrapper) Sys() any {
291
332
return nil
292
333
}
334
+
335
+
func (t *TagReference) Name() string {
336
+
return t.ref.Name().Short()
337
+
}
338
+
339
+
func (t *TagReference) Message() string {
340
+
if t.tag != nil {
341
+
return t.tag.Message
342
+
}
343
+
return ""
344
+
}