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
133
134
135
136
137
138
139
140
141
|
package forgepb
import (
"os"
"path/filepath"
"strings"
"go.wit.com/log"
)
func (f *Forge) ScanGoSrc() (bool, error) {
dirs, err := gitDirectories(f.goSrc)
if err != nil {
return false, err
}
for _, dir := range dirs {
if strings.HasPrefix(dir, f.goSrc) {
gopath := strings.TrimPrefix(dir, f.goSrc)
gopath = strings.Trim(gopath, "/")
// log.Info("ScanGoSrc() ok:", f.goSrc, gopath)
newr, err := f.Repos.NewGoPath(f.goSrc, gopath)
if err != nil {
log.Log(FORGEPBWARN, "init failed", err)
panic("crapnuts")
}
log.Info("init worked for", newr.GoPath)
// try to guess what the 'master' branch is
} else {
log.Log(FORGEPBWARN, "ScanGoSrc() bad:", dir)
}
}
return true, err
}
func gitDirectories(srcDir string) ([]string, error) {
var all []string
err := filepath.Walk(srcDir, func(path string, info os.FileInfo, err error) error {
if err != nil {
log.Log(FORGEPBWARN, "Error accessing path:", path, err)
return nil
}
// Check if the path is a directory and has a .git subdirectory
if info.IsDir() && IsGitDir(path) {
all = append(all, path)
}
return nil
})
if err != nil {
log.Log(FORGEPBWARN, "Error walking the path:", srcDir, err)
}
return all, err
}
/*
// rill is awesome. long live rill
func rillAddDirs(gopaths []string) {
// Convert a slice of user IDs into a channel
ids := rill.FromSlice(gopaths, nil)
// Read users from the API.
// Concurrency = 20
dirs := rill.Map(ids, 20, func(id string) (*repolist.RepoRow, error) {
return me.repos.View.FindByName(id), nil
})
// Activate users.
// Concurrency = 10
err := rill.ForEach(dirs, 10, func(repo *repolist.RepoRow) error {
fmt.Printf("Repo found : %s\n", repo.GoPath())
repo.Run([]string{"git", "pull"})
return nil
})
// Handle errors
fmt.Println("Error:", err)
}
*/
// IsGitDir checks if a .git directory exists inside the given directory
func IsGitDir(dir string) bool {
gitDir := filepath.Join(dir, ".git")
info, err := os.Stat(gitDir)
if os.IsNotExist(err) {
return false
}
return info.IsDir()
}
// attempt's to guess at what master is.
// TODO: fix this properly
func (repo *Repo) guessMainWorkingName() {
if repo.IsBranch("guimaster") {
return
}
if repo.IsBranch("master") {
return
}
if rs.TagExists("main") {
return
}
// figure out what to do here
rs.mainWorkingName.SetText("FIXME")
rs.mainBranchVersion.SetLabel("FIXME")
}
func (rs *RepoStatus) guessDevelWorkingName() {
if rs.TagExists("guidevel") {
rs.develWorkingName.SetValue("guidevel")
rs.develBranchVersion.SetLabel("guidevel")
return
}
if rs.TagExists("devel") {
rs.develWorkingName.SetValue("devel")
rs.develBranchVersion.SetLabel("devel")
return
}
// figure out what to do here
rs.develWorkingName.SetValue("develFIXME")
rs.develBranchVersion.SetLabel("develFIXME")
}
func (rs *RepoStatus) setUserWorkingName() {
usr, _ := user.Current()
uname := usr.Username
if rs.TagExists(uname) {
rs.userWorkingName.SetValue(uname)
rs.userBranchVersion.SetLabel(uname)
return
}
rs.userWorkingName.SetValue("need to create " + uname)
rs.userBranchVersion.SetLabel("need to create " + uname)
}
|
