330 lines
6.6 KiB
Go
330 lines
6.6 KiB
Go
package gowit
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"go.wit.com/gui"
|
|
"go.wit.com/log"
|
|
|
|
"go.wit.com/lib/gadgets"
|
|
"go.wit.com/lib/gui/repolist"
|
|
"go.wit.com/lib/gui/repostatus"
|
|
"go.wit.com/lib/gui/shell"
|
|
)
|
|
|
|
var lw *gadgets.BasicWindow
|
|
|
|
var allsections []*section
|
|
|
|
type witRepo struct {
|
|
hidden bool
|
|
sec *section
|
|
path *gui.Node
|
|
downloadB *gui.Node
|
|
configureB *gui.Node
|
|
}
|
|
|
|
func (w *witRepo) Show() {
|
|
w.hidden = false
|
|
w.path.Show()
|
|
w.downloadB.Show()
|
|
w.configureB.Show()
|
|
}
|
|
|
|
func (w *witRepo) Hide() {
|
|
w.hidden = true
|
|
w.path.Hide()
|
|
w.downloadB.Hide()
|
|
w.configureB.Hide()
|
|
}
|
|
|
|
type section struct {
|
|
name string
|
|
hidden bool
|
|
|
|
parent *gui.Node
|
|
box *gui.Node
|
|
group *gui.Node
|
|
grid *gui.Node // where the repos are listed
|
|
hideCB *gui.Node
|
|
downloadAllB *gui.Node
|
|
witRepos []*witRepo
|
|
}
|
|
|
|
func CheckRegistered(rs *repostatus.RepoStatus) (bool, string) {
|
|
var found bool = false
|
|
var source string
|
|
url := "https://" + rs.String()
|
|
lines := dumpURL(url)
|
|
for _, line := range lines {
|
|
// log.Info("HTTP:", i, line)
|
|
if strings.Contains(line, "\"go-import\"") {
|
|
line = strings.TrimSuffix(line, "\">")
|
|
parts := strings.Split(line, " ")
|
|
source = parts[len(parts)-1]
|
|
// log.Verbose("FOUND IMPORT:", i, source)
|
|
found = true
|
|
}
|
|
}
|
|
return found, source
|
|
}
|
|
|
|
func myrepolist(cfgfile string) []string {
|
|
homeDir, _ := os.UserHomeDir()
|
|
cfgfile = filepath.Join(homeDir, cfgfile)
|
|
content, _ := ioutil.ReadFile(cfgfile)
|
|
out := string(content)
|
|
out = strings.TrimSpace(out)
|
|
lines := strings.Split(out, "\n")
|
|
return lines
|
|
}
|
|
|
|
func ListWindow(view *repolist.RepoList) *gadgets.BasicWindow {
|
|
if lw != nil {
|
|
if lw.Hidden() {
|
|
lw.Show()
|
|
} else {
|
|
lw.Hide()
|
|
}
|
|
return lw
|
|
}
|
|
lw = gadgets.RawBasicWindow("go.wit.com repositories")
|
|
lw.Custom = func() {
|
|
log.Warn("got to close")
|
|
}
|
|
lw.Make()
|
|
box := lw.Box()
|
|
group := box.NewGroup("list")
|
|
group.NewButton("make new go version list", func() {
|
|
DumpVersions(view)
|
|
})
|
|
|
|
var lines []string
|
|
var currents *section
|
|
|
|
currents = NewSection(group, "local "+view.Cfgfile())
|
|
for i, line := range myrepolist(view.Cfgfile()) {
|
|
line = strings.TrimSpace(line)
|
|
if line == "" {
|
|
// skip blank lines
|
|
continue
|
|
}
|
|
if strings.HasPrefix(line, "#") {
|
|
// skip comment lines
|
|
continue
|
|
}
|
|
parts := strings.Split(line, " ")
|
|
log.Info("adding:", i, parts)
|
|
currents.add(view, parts[0])
|
|
}
|
|
|
|
lines = dumpURL("https://go.wit.com/list")
|
|
for i, line := range lines {
|
|
if line == "" {
|
|
continue
|
|
}
|
|
if line[0] == '#' {
|
|
currents = NewSection(group, line)
|
|
log.Warn("new group:", line)
|
|
continue
|
|
}
|
|
log.Warn(i, line)
|
|
parts := strings.Split(line, " ")
|
|
if currents != nil {
|
|
currents.add(view, parts[0])
|
|
}
|
|
}
|
|
for i, sec := range allsections {
|
|
log.Info("section name:", sec.name, "hidden:", sec.hidden, i)
|
|
parts := strings.Split(sec.name, " ")
|
|
if len(parts) > 1 {
|
|
if parts[1] == "Applications" {
|
|
// leave expanded
|
|
} else if parts[0] == "local" {
|
|
// leave expanded
|
|
} else {
|
|
sec.Hide()
|
|
}
|
|
}
|
|
}
|
|
return lw
|
|
}
|
|
|
|
func downloadRepo(path string) bool {
|
|
log.Info("downloading", path, "here")
|
|
os.Setenv("GO111MODULE", "off")
|
|
|
|
homeDir, _ := os.UserHomeDir()
|
|
goSrcDir := filepath.Join(homeDir, "go/src")
|
|
|
|
cmd := []string{"go-clone", "--recursive", "--no-work", "--go-src", path}
|
|
err := shell.NewRun(goSrcDir, cmd)
|
|
if err != nil {
|
|
log.Info("go-clone failed")
|
|
log.Info("err =", err)
|
|
// log.Info("output =", output)
|
|
return false
|
|
}
|
|
log.Info("go-clone worked")
|
|
return true
|
|
}
|
|
|
|
func (r *witRepo) doDownload() bool {
|
|
/*
|
|
if me.autoDryRun.Checked() {
|
|
r.downloadB.SetLabel("uncheck --dry-run")
|
|
return false
|
|
}
|
|
*/
|
|
if r.downloadB.String() == "downloaded" {
|
|
log.Info("skipping already downloaded", r.path.String())
|
|
r.downloadB.Disable()
|
|
return true
|
|
}
|
|
if downloadRepo(r.path.String()) {
|
|
log.Info("download", r.path.String(), "worked")
|
|
r.downloadB.SetLabel("downloaded")
|
|
r.downloadB.Disable()
|
|
} else {
|
|
r.downloadB.SetLabel("failed")
|
|
log.Info("download", r.path.String(), "failed")
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (s *section) add(view *repolist.RepoList, path string) {
|
|
if s == nil {
|
|
return
|
|
}
|
|
tmp := new(witRepo)
|
|
tmp.sec = s
|
|
tmp.path = s.grid.NewLabel(path)
|
|
tmp.downloadB = s.grid.NewButton("download", func() {
|
|
lw.Disable()
|
|
tmp.doDownload()
|
|
lw.Enable()
|
|
})
|
|
repo := view.FindRepo(path)
|
|
if repo != nil {
|
|
log.Verbose("repo is already downloaded", path)
|
|
tmp.downloadB.SetLabel("downloaded")
|
|
tmp.downloadB.Disable()
|
|
tmp.configureB = s.grid.NewButton("Configure", func() {
|
|
log.Log(WIT, "todo: open the repo window here")
|
|
})
|
|
}
|
|
|
|
s.grid.NextRow()
|
|
s.witRepos = append(s.witRepos, tmp)
|
|
}
|
|
|
|
func NewSection(parent *gui.Node, desc string) *section {
|
|
news := new(section)
|
|
news.name = desc
|
|
news.parent = parent
|
|
news.box = news.parent.NewBox("bw vbox", true)
|
|
news.group = news.box.NewGroup(desc)
|
|
news.hideCB = news.box.NewCheckbox("hide")
|
|
news.hideCB.Custom = func() {
|
|
news.toggle()
|
|
}
|
|
news.downloadAllB = news.box.NewButton("download all", func() {
|
|
lw.Disable()
|
|
log.Warn("Download all here")
|
|
for i, wrepo := range news.witRepos {
|
|
log.Warn("download:", i, wrepo.path.String())
|
|
wrepo.doDownload()
|
|
}
|
|
lw.Enable()
|
|
})
|
|
news.grid = news.parent.NewGrid("sections", 0, 0)
|
|
allsections = append(allsections, news)
|
|
return news
|
|
}
|
|
|
|
func (s *section) toggle() {
|
|
log.Warn(s.name)
|
|
if s.hidden {
|
|
s.hidden = false
|
|
for i, wrepo := range s.witRepos {
|
|
log.Warn(i, wrepo.path.String())
|
|
wrepo.Show()
|
|
}
|
|
} else {
|
|
s.Hide()
|
|
}
|
|
}
|
|
|
|
func (s *section) Hide() {
|
|
s.hidden = true
|
|
s.hideCB.SetChecked(true)
|
|
for i, wrepo := range s.witRepos {
|
|
log.Warn(i, wrepo.path.String())
|
|
wrepo.Hide()
|
|
}
|
|
}
|
|
|
|
/*
|
|
func dumpURL(url string) string {
|
|
resp, err := http.Get(url)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
return resp.Body.String()
|
|
|
|
_, err = io.Copy(os.Stdout, resp.Body)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
}
|
|
*/
|
|
|
|
func dumpURL(url string) []string {
|
|
resp, err := http.Get(url)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
bodyBytes, err := ioutil.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
return strings.Split(string(bodyBytes), "\n")
|
|
}
|
|
|
|
func formatDuration(d time.Duration) string {
|
|
seconds := int(d.Seconds()) % 60
|
|
minutes := int(d.Minutes()) % 60
|
|
hours := int(d.Hours()) % 24
|
|
days := int(d.Hours()) / 24
|
|
|
|
result := ""
|
|
if days > 0 {
|
|
result += fmt.Sprintf("%dd ", days)
|
|
return result
|
|
}
|
|
if hours > 0 {
|
|
result += fmt.Sprintf("%dh ", hours)
|
|
return result
|
|
}
|
|
if minutes > 0 {
|
|
result += fmt.Sprintf("%dm ", minutes)
|
|
return result
|
|
}
|
|
if seconds > 0 {
|
|
result += fmt.Sprintf("%ds", seconds)
|
|
}
|
|
return result
|
|
}
|