runxiyu.tngl.sh
Fast implementation of Git in pure Go
object/stored: Move from objectstored
+16
-16
cmd/show-object/main.go
+16
-16
cmd/show-object/main.go
···
8
8
"os"
9
9
"strings"
10
10
11
+
"codeberg.org/lindenii/furgit/object/stored"
11
12
"codeberg.org/lindenii/furgit/objectid"
12
-
"codeberg.org/lindenii/furgit/objectstored"
13
13
"codeberg.org/lindenii/furgit/objecttype"
14
14
"codeberg.org/lindenii/furgit/repository"
15
15
)
···
50
50
return fmt.Errorf("resolve %q: %w", *name, err)
51
51
}
52
52
53
-
stored, err := repo.ReadStored(id)
53
+
s, err := repo.ReadStored(id)
54
54
if err != nil {
55
55
_ = repo.Close()
56
56
57
57
return fmt.Errorf("read object %s: %w", id, err)
58
58
}
59
59
60
-
printStored(stored)
60
+
printStored(s)
61
61
62
62
err = repo.Close()
63
63
if err != nil {
···
81
81
return resolved.ID, nil
82
82
}
83
83
84
-
func printStored(stored objectstored.StoredObject) {
84
+
func printStored(s stored.StoredObject) {
85
85
var b strings.Builder
86
86
87
-
id := stored.ID()
88
-
ty := stored.Object().ObjectType()
87
+
id := s.ID()
88
+
ty := s.Object().ObjectType()
89
89
90
90
tyName, ok := objecttype.Name(ty)
91
91
if !ok {
···
95
95
fmt.Fprintf(&b, "id: %s\n", id)
96
96
fmt.Fprintf(&b, "type: %s\n", tyName)
97
97
98
-
switch stored := stored.(type) {
99
-
case *objectstored.StoredBlob:
100
-
blob := stored.Blob()
98
+
switch s := s.(type) {
99
+
case *stored.StoredBlob:
100
+
blob := s.Blob()
101
101
fmt.Fprintf(&b, "size: %d\n", len(blob.Data))
102
102
fmt.Fprintf(&b, "data: %q\n", string(blob.Data))
103
-
case *objectstored.StoredTree:
104
-
tree := stored.Tree()
103
+
case *stored.StoredTree:
104
+
tree := s.Tree()
105
105
fmt.Fprintf(&b, "entries: %d\n", len(tree.Entries))
106
106
107
107
for _, entry := range tree.Entries {
108
108
fmt.Fprintf(&b, "%06o %s\t%s\n", entry.Mode, entry.ID, entry.Name)
109
109
}
110
-
case *objectstored.StoredCommit:
111
-
commit := stored.Commit()
110
+
case *stored.StoredCommit:
111
+
commit := s.Commit()
112
112
fmt.Fprintf(&b, "tree: %s\n", commit.Tree)
113
113
114
114
for _, parent := range commit.Parents {
···
118
118
fmt.Fprintf(&b, "author: %s <%s>\n", commit.Author.Name, commit.Author.Email)
119
119
fmt.Fprintf(&b, "committer: %s <%s>\n", commit.Committer.Name, commit.Committer.Email)
120
120
fmt.Fprintf(&b, "message:\n%s\n", string(commit.Message))
121
-
case *objectstored.StoredTag:
122
-
tag := stored.Tag()
121
+
case *stored.StoredTag:
122
+
tag := s.Tag()
123
123
124
124
targetTy, ok := objecttype.Name(tag.TargetType)
125
125
if !ok {
···
135
135
136
136
fmt.Fprintf(&b, "message:\n%s\n", string(tag.Message))
137
137
default:
138
-
fmt.Fprintf(&b, "%#v\n", stored.Object())
138
+
fmt.Fprintf(&b, "%#v\n", s.Object())
139
139
}
140
140
141
141
_, _ = os.Stdout.WriteString(b.String())
+2
object/stored/stored.go
+2
object/stored/stored.go
+1
-1
objectstored/blob.go
object/stored/blob.go
+1
-1
objectstored/blob.go
object/stored/blob.go
+1
-1
objectstored/commit.go
object/stored/commit.go
+1
-1
objectstored/commit.go
object/stored/commit.go
+1
-1
objectstored/object.go
object/stored/object.go
+1
-1
objectstored/object.go
object/stored/object.go
+1
-1
objectstored/objectstored.go
object/stored/objectstored.go
+1
-1
objectstored/objectstored.go
object/stored/objectstored.go
-2
objectstored/stored.go
-2
objectstored/stored.go
+1
-1
objectstored/tree.go
object/stored/tree.go
+1
-1
objectstored/tree.go
object/stored/tree.go
+22
-22
repository/stored.go
+22
-22
repository/stored.go
···
4
4
"fmt"
5
5
6
6
"codeberg.org/lindenii/furgit/object"
7
+
"codeberg.org/lindenii/furgit/object/stored"
7
8
"codeberg.org/lindenii/furgit/objectid"
8
-
"codeberg.org/lindenii/furgit/objectstored"
9
9
"codeberg.org/lindenii/furgit/objecttype"
10
10
)
11
11
12
12
// ReadStored reads, parses, and wraps one object by ID.
13
13
//
14
14
//nolint:ireturn
15
-
func (repo *Repository) ReadStored(id objectid.ObjectID) (objectstored.StoredObject, error) {
15
+
func (repo *Repository) ReadStored(id objectid.ObjectID) (stored.StoredObject, error) {
16
16
parsed, err := repo.readParsedObject(id)
17
17
if err != nil {
18
18
return nil, err
···
20
20
21
21
switch parsed := parsed.(type) {
22
22
case *object.Blob:
23
-
return objectstored.NewStoredBlob(id, parsed), nil
23
+
return stored.NewStoredBlob(id, parsed), nil
24
24
case *object.Tree:
25
-
return objectstored.NewStoredTree(id, parsed), nil
25
+
return stored.NewStoredTree(id, parsed), nil
26
26
case *object.Commit:
27
-
return objectstored.NewStoredCommit(id, parsed), nil
27
+
return stored.NewStoredCommit(id, parsed), nil
28
28
case *object.Tag:
29
-
return objectstored.NewStoredTag(id, parsed), nil
29
+
return stored.NewStoredTag(id, parsed), nil
30
30
default:
31
31
return nil, fmt.Errorf("repository: unsupported parsed object type %T", parsed)
32
32
}
33
33
}
34
34
35
35
// ReadStoredBlob reads and parses a blob object by ID.
36
-
func (repo *Repository) ReadStoredBlob(id objectid.ObjectID) (*objectstored.StoredBlob, error) {
37
-
stored, err := repo.ReadStored(id)
36
+
func (repo *Repository) ReadStoredBlob(id objectid.ObjectID) (*stored.StoredBlob, error) {
37
+
s, err := repo.ReadStored(id)
38
38
if err != nil {
39
39
return nil, err
40
40
}
41
41
42
-
blob, ok := stored.(*objectstored.StoredBlob)
42
+
blob, ok := s.(*stored.StoredBlob)
43
43
if !ok {
44
-
return nil, fmt.Errorf("repository: expected blob object %s, got %v", id, stored.Object().ObjectType())
44
+
return nil, fmt.Errorf("repository: expected blob object %s, got %v", id, s.Object().ObjectType())
45
45
}
46
46
47
47
return blob, nil
48
48
}
49
49
50
50
// ReadStoredTree reads and parses a tree object by ID.
51
-
func (repo *Repository) ReadStoredTree(id objectid.ObjectID) (*objectstored.StoredTree, error) {
52
-
stored, err := repo.ReadStored(id)
51
+
func (repo *Repository) ReadStoredTree(id objectid.ObjectID) (*stored.StoredTree, error) {
52
+
s, err := repo.ReadStored(id)
53
53
if err != nil {
54
54
return nil, err
55
55
}
56
56
57
-
tree, ok := stored.(*objectstored.StoredTree)
57
+
tree, ok := s.(*stored.StoredTree)
58
58
if !ok {
59
-
return nil, fmt.Errorf("repository: expected tree object %s, got %v", id, stored.Object().ObjectType())
59
+
return nil, fmt.Errorf("repository: expected tree object %s, got %v", id, s.Object().ObjectType())
60
60
}
61
61
62
62
return tree, nil
63
63
}
64
64
65
65
// ReadStoredCommit reads and parses a commit object by ID.
66
-
func (repo *Repository) ReadStoredCommit(id objectid.ObjectID) (*objectstored.StoredCommit, error) {
67
-
stored, err := repo.ReadStored(id)
66
+
func (repo *Repository) ReadStoredCommit(id objectid.ObjectID) (*stored.StoredCommit, error) {
67
+
s, err := repo.ReadStored(id)
68
68
if err != nil {
69
69
return nil, err
70
70
}
71
71
72
-
commit, ok := stored.(*objectstored.StoredCommit)
72
+
commit, ok := s.(*stored.StoredCommit)
73
73
if !ok {
74
-
return nil, fmt.Errorf("repository: expected commit object %s, got %v", id, stored.Object().ObjectType())
74
+
return nil, fmt.Errorf("repository: expected commit object %s, got %v", id, s.Object().ObjectType())
75
75
}
76
76
77
77
return commit, nil
78
78
}
79
79
80
80
// ReadStoredTag reads and parses a tag object by ID.
81
-
func (repo *Repository) ReadStoredTag(id objectid.ObjectID) (*objectstored.StoredTag, error) {
82
-
stored, err := repo.ReadStored(id)
81
+
func (repo *Repository) ReadStoredTag(id objectid.ObjectID) (*stored.StoredTag, error) {
82
+
s, err := repo.ReadStored(id)
83
83
if err != nil {
84
84
return nil, err
85
85
}
86
86
87
-
tag, ok := stored.(*objectstored.StoredTag)
87
+
tag, ok := s.(*stored.StoredTag)
88
88
if !ok {
89
-
return nil, fmt.Errorf("repository: expected tag object %s, got %v", id, stored.Object().ObjectType())
89
+
return nil, fmt.Errorf("repository: expected tag object %s, got %v", id, s.Object().ObjectType())
90
90
}
91
91
92
92
return tag, nil
+2
-2
repository/tree.go
+2
-2
repository/tree.go
···
5
5
"fmt"
6
6
7
7
"codeberg.org/lindenii/furgit/object"
8
-
"codeberg.org/lindenii/furgit/objectstored"
8
+
"codeberg.org/lindenii/furgit/object/stored"
9
9
)
10
10
11
11
// ResolveTreeEntry resolves one path within a stored root tree.
12
12
//
13
13
// parts must contain at least one path segment. Intermediate segments must be
14
14
// tree entries.
15
-
func (repo *Repository) ResolveTreeEntry(tree *objectstored.StoredTree, parts [][]byte) (object.TreeEntry, error) {
15
+
func (repo *Repository) ResolveTreeEntry(tree *stored.StoredTree, parts [][]byte) (object.TreeEntry, error) {
16
16
if tree == nil {
17
17
return object.TreeEntry{}, errors.New("repository: nil root tree")
18
18
}