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
|
package dotgit
import (
"errors"
"os"
"strings"
"gopkg.in/src-d/go-git.v4/core"
"gopkg.in/src-d/go-git.v4/utils/fs"
)
const (
suffix = ".git"
packedRefsPath = "packed-refs"
configPath = "config"
)
var (
// ErrNotFound is returned by New when the path is not found.
ErrNotFound = errors.New("path not found")
// ErrIdxNotFound is returned by Idxfile when the idx file is not found
ErrIdxNotFound = errors.New("idx file not found")
// ErrPackfileNotFound is returned by Packfile when the packfile is not found
ErrPackfileNotFound = errors.New("packfile not found")
// ErrConfigNotFound is returned by Config when the config is not found
ErrConfigNotFound = errors.New("config file not found")
)
// The DotGit type represents a local git repository on disk. This
// type is not zero-value-safe, use the New function to initialize it.
type DotGit struct {
fs fs.FS
path string
}
// New returns a DotGit value ready to be used. The path argument must
// be the absolute path of a git repository directory (e.g.
// "/foo/bar/.git").
func New(fs fs.FS, path string) (*DotGit, error) {
d := &DotGit{fs: fs, path: path}
if _, err := fs.Stat(path); err != nil {
if os.IsNotExist(err) {
return nil, ErrNotFound
}
return nil, err
}
return d, nil
}
// Refs scans the git directory collecting references, which it returns.
// Symbolic references are resolved and included in the output.
func (d *DotGit) Refs() ([]*core.Reference, error) {
var refs []*core.Reference
if err := d.addRefsFromPackedRefs(&refs); err != nil {
return nil, err
}
if err := d.addRefsFromRefDir(&refs); err != nil {
return nil, err
}
if err := d.addRefFromHEAD(&refs); err != nil {
return nil, err
}
return refs, nil
}
// Packfile returns the path of the packfile (really, it returns the
// path of the first file in the "objects/pack/" directory with a
// ".pack" extension.
func (d *DotGit) Packfile() (fs.FS, string, error) {
packDir := d.fs.Join(d.path, "objects", "pack")
files, err := d.fs.ReadDir(packDir)
if err != nil {
return nil, "", err
}
for _, f := range files {
if strings.HasSuffix(f.Name(), ".pack") {
return d.fs, d.fs.Join(packDir, f.Name()), nil
}
}
return nil, "", ErrPackfileNotFound
}
// Idxfile returns the path of the idx file (really, it returns the
// path of the first file in the "objects/pack/" directory with an
// ".idx" extension.
func (d *DotGit) Idxfile() (fs.FS, string, error) {
packDir := d.fs.Join(d.path, "objects", "pack")
files, err := d.fs.ReadDir(packDir)
if err != nil {
return nil, "", err
}
for _, f := range files {
if strings.HasSuffix(f.Name(), ".idx") {
return d.fs, d.fs.Join(packDir, f.Name()), nil
}
}
return nil, "", ErrIdxNotFound
}
// Config returns the path of the config file
func (d *DotGit) Config() (fs.FS, string, error) {
configFile := d.fs.Join(d.path, configPath)
if _, err := d.fs.Stat(configFile); err != nil {
if os.IsNotExist(err) {
return nil, "", ErrNotFound
}
return nil, "", err
}
return d.fs, configFile, nil
}
|
