Compare commits
No commits in common. "guimaster" and "v0.12.19" have entirely different histories.
|
|
@ -1,3 +0,0 @@
|
|||
*.swp
|
||||
go.mod
|
||||
go.sum
|
||||
12
Makefile
12
Makefile
|
|
@ -1,8 +1,7 @@
|
|||
all: goimports
|
||||
GO111MODULE=off go vet
|
||||
|
||||
goimports:
|
||||
goimports -w *.go
|
||||
all:
|
||||
@echo
|
||||
@echo Run: make redomod
|
||||
@echo
|
||||
|
||||
redomod:
|
||||
rm -f go.*
|
||||
|
|
@ -10,6 +9,3 @@ redomod:
|
|||
GO111MODULE= go mod init
|
||||
GO111MODULE= go mod tidy
|
||||
|
||||
clean:
|
||||
rm -f go.*
|
||||
go-mod-clean --purge
|
||||
|
|
|
|||
25
args.go
25
args.go
|
|
@ -8,24 +8,25 @@ import (
|
|||
"go.wit.com/log"
|
||||
)
|
||||
|
||||
var NOW *log.LogFlag
|
||||
var INFO *log.LogFlag
|
||||
var WARN *log.LogFlag
|
||||
var CHANGE *log.LogFlag
|
||||
|
||||
var REPO *log.LogFlag
|
||||
var REPOWARN *log.LogFlag
|
||||
var SPEW *log.LogFlag
|
||||
var WARN *log.LogFlag
|
||||
|
||||
var CHANGE *log.LogFlag
|
||||
var STATUS *log.LogFlag
|
||||
|
||||
func init() {
|
||||
full := "go.wit.com/lib/gui/repostatus"
|
||||
full := "go.wit.com/gui/gadgets/repostatus"
|
||||
short := "repostatus"
|
||||
|
||||
INFO = log.NewFlag("INFO", false, full, short, "general repo things")
|
||||
NOW = log.NewFlag("NOW", true, full, short, "temp debugging stuff")
|
||||
INFO = log.NewFlag("INFO", false, full, short, "normal debugging stuff")
|
||||
|
||||
WARN = log.NewFlag("WARN", true, full, short, "bad things")
|
||||
SPEW = log.NewFlag("SPEW", false, full, short, "spew stuff")
|
||||
|
||||
CHANGE = log.NewFlag("CHANGE", true, full, short, "when repo changes")
|
||||
|
||||
full = "go.wit.com/lib/gui/repo"
|
||||
short = "repo"
|
||||
|
||||
REPO = log.NewFlag("REPO", false, full, short, "general repo things")
|
||||
REPOWARN = log.NewFlag("REPOWARN", true, full, short, "repo warnings")
|
||||
STATUS = log.NewFlag("STATUS", false, full, short, "current status")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,37 +0,0 @@
|
|||
package repostatus
|
||||
|
||||
import (
|
||||
"go.wit.com/gui"
|
||||
"go.wit.com/log"
|
||||
)
|
||||
|
||||
func (rs *RepoStatus) makeBranchesBox(parent *gui.Node) {
|
||||
repo := rs.pb
|
||||
rs.gitBranchesGroup = parent.NewGroup("branches") // `progname:"BRANCHES"` // can the toolkits use these for i18n support?
|
||||
grid := rs.gitBranchesGroup.RawGrid()
|
||||
|
||||
var win *repoBranchesWindow
|
||||
grid.NewButton("Branches Window", func() {
|
||||
if win != nil {
|
||||
win.Toggle()
|
||||
return
|
||||
}
|
||||
log.Info("redo this")
|
||||
win = MakeRepoBranchesWindow(repo)
|
||||
win.Show()
|
||||
})
|
||||
grid.NextRow()
|
||||
|
||||
var mergeWin *repoMergeWindow
|
||||
grid.NewButton("Merge Window", func() {
|
||||
if mergeWin != nil {
|
||||
mergeWin.Toggle()
|
||||
return
|
||||
}
|
||||
log.Info("redo this")
|
||||
mergeWin = rs.MakeRepoMergeWindow(repo)
|
||||
mergeWin.Show()
|
||||
})
|
||||
grid.NextRow()
|
||||
|
||||
}
|
||||
89
common.go
89
common.go
|
|
@ -2,27 +2,27 @@ package repostatus
|
|||
|
||||
import (
|
||||
"go.wit.com/log"
|
||||
// "go.wit.com/gui/gui"
|
||||
)
|
||||
|
||||
// reports externally if something has changed
|
||||
// since the last time it was asked about it
|
||||
func (rs *RepoStatus) Changed() (string, bool) {
|
||||
func (rs *RepoStatus) Changed() bool {
|
||||
if !rs.Ready() {
|
||||
return "", false
|
||||
return false
|
||||
}
|
||||
|
||||
return rs.getChanges(), rs.changed
|
||||
return rs.changed
|
||||
}
|
||||
|
||||
// keeps a human readable list of things that have
|
||||
// changed. todo: timestampe these?
|
||||
func (rs *RepoStatus) getChanges() string {
|
||||
return rs.changes
|
||||
func (rs *RepoStatus) Draw() {
|
||||
if !rs.Ready() {
|
||||
return
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) NoteChange(s string) {
|
||||
rs.changed = true
|
||||
rs.changes += s + "\n"
|
||||
log.Log(CHANGE, "Draw() window ready =", rs.ready)
|
||||
rs.window.TestDraw()
|
||||
// rs.window.Draw()
|
||||
rs.ready = true
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) Show() {
|
||||
|
|
@ -31,6 +31,7 @@ func (rs *RepoStatus) Show() {
|
|||
}
|
||||
log.Log(CHANGE, "Show() window ready =", rs.ready)
|
||||
rs.window.Show()
|
||||
rs.hidden = false
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) Hide() {
|
||||
|
|
@ -39,6 +40,7 @@ func (rs *RepoStatus) Hide() {
|
|||
}
|
||||
log.Log(CHANGE, "Hide() window ready =", rs.ready)
|
||||
rs.window.Hide()
|
||||
rs.hidden = true
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) Toggle() {
|
||||
|
|
@ -46,7 +48,7 @@ func (rs *RepoStatus) Toggle() {
|
|||
return
|
||||
}
|
||||
log.Log(CHANGE, "Toggle() window ready =", rs.ready)
|
||||
if rs.window.Hidden() {
|
||||
if rs.hidden {
|
||||
rs.Show()
|
||||
} else {
|
||||
rs.Hide()
|
||||
|
|
@ -54,6 +56,7 @@ func (rs *RepoStatus) Toggle() {
|
|||
}
|
||||
|
||||
func (rs *RepoStatus) Ready() bool {
|
||||
log.Log(SPEW, "Ready() maybe not ready? rs =", rs)
|
||||
if rs == nil {
|
||||
return false
|
||||
}
|
||||
|
|
@ -63,59 +66,11 @@ func (rs *RepoStatus) Ready() bool {
|
|||
return rs.ready
|
||||
}
|
||||
|
||||
// disable all things besides Update() button
|
||||
func (rs *RepoStatus) DisableEverything() {
|
||||
log.Log(INFO, "DisableEverything()")
|
||||
|
||||
// choosing a major, minor or revision
|
||||
rs.major.Disable()
|
||||
rs.minor.Disable()
|
||||
rs.revision.Disable()
|
||||
|
||||
// disable adding a tag message
|
||||
rs.versionMessage.Disable()
|
||||
|
||||
// disable the merge devel to master button
|
||||
rs.develMergeB.Disable()
|
||||
|
||||
// disable the tag a new version button
|
||||
rs.releaseVersion.Disable()
|
||||
}
|
||||
|
||||
// this means devel needs to be merged to master
|
||||
func (rs *RepoStatus) EnableMergeDevel() {
|
||||
rs.DisableEverything()
|
||||
|
||||
rs.develMergeB.Enable()
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) Disable() {
|
||||
rs.window.Disable()
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) Enable() {
|
||||
rs.window.Enable()
|
||||
}
|
||||
|
||||
// this means you need to release a new version of the master repository
|
||||
func (rs *RepoStatus) EnableSelectTag() {
|
||||
rs.DisableEverything()
|
||||
|
||||
// choosing a major, minor or revision
|
||||
rs.major.Enable()
|
||||
rs.minor.Enable()
|
||||
rs.revision.Enable()
|
||||
|
||||
// disable adding a tag message
|
||||
rs.versionMessage.Enable()
|
||||
|
||||
rs.develMergeB.SetLabel("ready to release")
|
||||
|
||||
if len(rs.versionMessage.String()) == 0 {
|
||||
// force there to be a commit message
|
||||
rs.releaseVersion.Disable()
|
||||
} else {
|
||||
// rs.generateCmd()
|
||||
rs.releaseVersion.Enable()
|
||||
}
|
||||
/*
|
||||
func (rs *RepoStatus) Initialized() bool {
|
||||
log.Log(CHANGE, "checking Initialized()")
|
||||
if rs == nil {return false}
|
||||
if rs.parent == nil {return false}
|
||||
return true
|
||||
}
|
||||
*/
|
||||
|
|
|
|||
422
draw.go
422
draw.go
|
|
@ -1,36 +1,422 @@
|
|||
package repostatus
|
||||
|
||||
import (
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"go.wit.com/gui"
|
||||
"go.wit.com/lib/gadgets"
|
||||
"go.wit.com/log"
|
||||
"go.wit.com/widget"
|
||||
)
|
||||
|
||||
func (rs *RepoStatus) drawGitStatus(box *gui.Node) {
|
||||
rs.gitStatusGroup = box.NewGroup("What GIT Knows It Has")
|
||||
// creates the actual widgets.
|
||||
// it's assumed you are always passing in a box
|
||||
func (rs *RepoStatus) draw() {
|
||||
if !rs.Ready() {
|
||||
return
|
||||
}
|
||||
|
||||
// display the status of the git repository
|
||||
rs.drawGitStatus()
|
||||
|
||||
// display the git branches and options
|
||||
rs.drawGitBranches()
|
||||
|
||||
// show standard git commit and merge controls
|
||||
rs.drawGitCommands()
|
||||
|
||||
// figure out what the state of the git repository is
|
||||
// rs.Update()
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) drawGitBranches() {
|
||||
rs.gitBranchesGroup = rs.window.Box().NewGroup("branches")
|
||||
newgrid := rs.gitBranchesGroup.NewGrid("gridnuts", 2, 2)
|
||||
|
||||
rs.masterDrop = gadgets.NewBasicDropdown(newgrid, "main branch")
|
||||
rs.develDrop = gadgets.NewBasicDropdown(newgrid, "devel branch")
|
||||
rs.userDrop = gadgets.NewBasicDropdown(newgrid, "user branch")
|
||||
var master = ""
|
||||
all := rs.getBranches()
|
||||
for _, branch := range all {
|
||||
log.Warn("getBranches()", branch)
|
||||
rs.masterDrop.AddText(branch)
|
||||
rs.develDrop.AddText(branch)
|
||||
rs.userDrop.AddText(branch)
|
||||
if branch == "master" {
|
||||
master = "master"
|
||||
}
|
||||
if branch == "main" {
|
||||
master = "main"
|
||||
}
|
||||
}
|
||||
// relabel the various gadgets with the right branch name
|
||||
rs.masterBranchVersion.SetLabel(master)
|
||||
|
||||
var count *gui.Node
|
||||
|
||||
rs.showBranchesButton = newgrid.NewButton("show branches", func() {
|
||||
all := rs.getBranches()
|
||||
i := len(all)
|
||||
count.SetText(strconv.Itoa(i) + " branches")
|
||||
})
|
||||
count = newgrid.NewLabel("")
|
||||
|
||||
rs.checkBranchesButton = newgrid.NewButton("check branches", func() {
|
||||
if rs.CheckBranches() {
|
||||
log.Warn("Branches are perfect")
|
||||
} else {
|
||||
log.Warn("Branches are not perfect")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) drawGitStatus() {
|
||||
rs.gitStatusGroup = rs.window.Box().NewGroup("What GO Knows It Has")
|
||||
newgrid := rs.gitStatusGroup.NewGrid("gridnuts", 2, 2)
|
||||
newgrid.Margin()
|
||||
newgrid.Pad()
|
||||
|
||||
rs.path = gadgets.NewOneLiner(newgrid, "path")
|
||||
rs.goSrcPath = gadgets.NewOneLiner(newgrid, "~/go/src")
|
||||
rs.goPath = gadgets.NewOneLiner(newgrid, "go path")
|
||||
rs.realPath = gadgets.NewOneLiner(newgrid, "full path")
|
||||
rs.isGoLang = gadgets.NewOneLiner(newgrid, "Is GO Lang?")
|
||||
rs.isGoLang.SetText("false")
|
||||
rs.mainWorkingName = gadgets.NewOneLiner(newgrid, "main working branch")
|
||||
rs.mainWorkingName.SetValue("???")
|
||||
rs.develWorkingName = gadgets.NewOneLiner(newgrid, "devel working branch")
|
||||
rs.develWorkingName.SetValue("devel")
|
||||
rs.userWorkingName = gadgets.NewOneLiner(newgrid, "user working branch")
|
||||
rs.userWorkingName.SetValue("uid")
|
||||
rs.currentBranch = gadgets.NewOneLiner(newgrid, "branch")
|
||||
rs.lasttag = gadgets.NewOneLiner(newgrid, "last tag")
|
||||
rs.currentVersion = gadgets.NewOneLiner(newgrid, "Version")
|
||||
rs.tagsDrop = gadgets.NewBasicDropdown(newgrid, "existing tags")
|
||||
|
||||
// git for-each-ref --sort=taggerdate --format '%(tag) ,,,_,,, %(subject)' refs/tags
|
||||
var cmd []string
|
||||
cmd = append(cmd, "git", "for-each-ref", "--sort=taggerdate", "--format", "%(tag) %(subject)", "refs/tags")
|
||||
_, _, output := RunCmd("/home/jcarr/go/src/"+rs.repopath, cmd)
|
||||
log.Info(output)
|
||||
for _, line := range strings.Split(output, "\n") {
|
||||
rs.tagsDrop.AddText(line)
|
||||
}
|
||||
|
||||
rs.masterBranchVersion = gadgets.NewOneLiner(newgrid, "master")
|
||||
rs.develBranchVersion = gadgets.NewOneLiner(newgrid, "devel")
|
||||
rs.userBranchVersion = gadgets.NewOneLiner(newgrid, "user")
|
||||
|
||||
rs.dirtyLabel = gadgets.NewOneLiner(newgrid, "dirty")
|
||||
rs.gitState = gadgets.NewOneLiner(newgrid, "git state")
|
||||
rs.readOnly = gadgets.NewOneLiner(newgrid, "read only")
|
||||
rs.primitive = gadgets.NewOneLiner(newgrid, "primitive")
|
||||
rs.private = gadgets.NewOneLiner(newgrid, "private")
|
||||
rs.targetReleaseVersion = gadgets.NewOneLiner(newgrid, "target release version")
|
||||
|
||||
rs.speed = gadgets.NewOneLiner(newgrid, "refresh speed =")
|
||||
rs.speedActual = gadgets.NewOneLiner(newgrid, "speed actual =")
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) drawGitCommands() {
|
||||
rs.gitCommandsGroup = rs.window.Box().NewGroup("git commands")
|
||||
newgrid := rs.gitCommandsGroup.NewGrid("gridnuts", 2, 2)
|
||||
|
||||
newgrid.NewButton("update", func() {
|
||||
rs.Update()
|
||||
})
|
||||
|
||||
newgrid.NewButton("git pull", func() {
|
||||
var cmd []string
|
||||
cmd = append(cmd, "git", "pull")
|
||||
err, b, output := RunCmd("/home/jcarr/go/src/"+rs.repopath, cmd)
|
||||
log.Warn("Did git pull here", err, b, output)
|
||||
})
|
||||
|
||||
rs.major = gadgets.NewBasicCombobox(newgrid, "major")
|
||||
rs.major.Custom = func() {
|
||||
rs.setTag()
|
||||
rs.generateCmd()
|
||||
}
|
||||
rs.minor = gadgets.NewBasicCombobox(newgrid, "minor")
|
||||
rs.minor.Custom = func() {
|
||||
rs.setTag()
|
||||
rs.generateCmd()
|
||||
}
|
||||
rs.revision = gadgets.NewBasicCombobox(newgrid, "revision")
|
||||
rs.revision.Custom = func() {
|
||||
rs.setTag()
|
||||
rs.generateCmd()
|
||||
}
|
||||
newgrid.NewLabel("new tag version")
|
||||
rs.newversion = newgrid.NewLabel("0.0.1")
|
||||
|
||||
rs.versionMessage = gadgets.NewBasicEntry(newgrid, "tag message")
|
||||
rs.versionMessage.Custom = func() {
|
||||
rs.generateCmd()
|
||||
}
|
||||
rs.versionCmdOutput = gadgets.NewOneLiner(newgrid, "tag cmd")
|
||||
|
||||
label := "merge " + rs.masterDrop.String() + " to devel"
|
||||
rs.develMerge = newgrid.NewButton(label, func() {
|
||||
rs.Disable()
|
||||
master := rs.masterDrop.String()
|
||||
rs.checkoutBranch("master", master)
|
||||
if rs.getCurrentBranchName() != master {
|
||||
log.Warn("something went wrong switching to the master branch. full stop!")
|
||||
return
|
||||
}
|
||||
if !rs.runGitCommands() {
|
||||
log.Warn("SOMETHING WENT WRONG")
|
||||
return
|
||||
}
|
||||
rs.Update()
|
||||
rs.Enable()
|
||||
log.Warn("THINGS SEEM OK")
|
||||
})
|
||||
|
||||
rs.releaseVersion = newgrid.NewButton("tag and release new version", func() {
|
||||
if !rs.generateCmd() {
|
||||
log.Warn("something is wrong. fix the errors first")
|
||||
return
|
||||
}
|
||||
rs.releaseVersion.Disable()
|
||||
log.Warn("COMMIT IT HERE")
|
||||
if !rs.runGitCommands() {
|
||||
log.Warn("SOMETHING WENT WRONG")
|
||||
}
|
||||
rs.Update()
|
||||
log.Warn("THINGS SEEM OK")
|
||||
})
|
||||
|
||||
newgrid.Margin()
|
||||
newgrid.Pad()
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) setTag() bool {
|
||||
lasttag := rs.lasttag.String()
|
||||
var major, minor, revision string
|
||||
major, minor, revision = splitVersion(lasttag)
|
||||
|
||||
olda, _ := strconv.Atoi(major)
|
||||
oldb, _ := strconv.Atoi(minor)
|
||||
oldc, _ := strconv.Atoi(revision)
|
||||
|
||||
log.Warn("current version here", lasttag)
|
||||
log.Warn("current release a,b,c =", major, minor, revision)
|
||||
|
||||
newa, _ := strconv.Atoi(rs.major.String())
|
||||
|
||||
newver := strconv.Itoa(newa)
|
||||
if newa < olda {
|
||||
log.Warn("new version bad", newver, "vs old version", lasttag, "newa =", newa, "olda =", olda)
|
||||
rs.newversion.SetLabel("bad")
|
||||
return false
|
||||
}
|
||||
if newa > olda {
|
||||
log.Warn("new version ok", newver, "vs old version", lasttag)
|
||||
rs.newversion.SetLabel(newver)
|
||||
rs.minor.SetText("")
|
||||
rs.revision.SetText("")
|
||||
return true
|
||||
}
|
||||
|
||||
newb, _ := strconv.Atoi(rs.minor.String())
|
||||
newver = strconv.Itoa(newa) + "." + strconv.Itoa(newb)
|
||||
if newb < oldb {
|
||||
log.Warn("new version bad", newver, "vs old version", lasttag, "newb =", newb, "oldb =", oldb)
|
||||
rs.newversion.SetLabel("bad")
|
||||
return false
|
||||
}
|
||||
|
||||
if newb > oldb {
|
||||
log.Warn("new version ok", newver, "vs old version", lasttag)
|
||||
rs.newversion.SetLabel(newver)
|
||||
rs.revision.SetText("")
|
||||
return true
|
||||
}
|
||||
|
||||
newc, _ := strconv.Atoi(rs.revision.String())
|
||||
newver = strconv.Itoa(newa) + "." + strconv.Itoa(newb) + "." + strconv.Itoa(newc)
|
||||
if newc <= oldc {
|
||||
log.Warn("new version bad", newver, "vs old version", lasttag)
|
||||
rs.newversion.SetLabel("bad")
|
||||
return false
|
||||
}
|
||||
log.Warn("new version ok", newver, "vs old version", lasttag)
|
||||
rs.newversion.SetLabel(newver)
|
||||
return true
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) incrementVersion() {
|
||||
lasttag := rs.lasttag.String()
|
||||
var major, minor, revision string
|
||||
major, minor, revision = splitVersion(lasttag)
|
||||
log.Warn("Should release version here", lasttag)
|
||||
log.Warn("Should release a,b,c", major, minor, revision)
|
||||
|
||||
a, _ := strconv.Atoi(major)
|
||||
b, _ := strconv.Atoi(minor)
|
||||
c, _ := strconv.Atoi(revision)
|
||||
|
||||
rs.major.AddText(widget.GetString(a))
|
||||
rs.major.AddText(widget.GetString(a + 1))
|
||||
rs.major.SetText(widget.GetString(a))
|
||||
|
||||
rs.minor.AddText(widget.GetString(b))
|
||||
rs.minor.AddText(widget.GetString(b + 1))
|
||||
rs.minor.SetText(widget.GetString(b))
|
||||
|
||||
// rs.c := strconv.Atoi(revision)
|
||||
rs.revision.AddText(widget.GetString(c + 1))
|
||||
rs.revision.AddText(widget.GetString(c + 2))
|
||||
rs.revision.SetText(widget.GetString(c + 1))
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) recommend() {
|
||||
log.Warn("Is repo dirty?", rs.dirtyLabel.String())
|
||||
log.Warn("list the known tags")
|
||||
rs.DisableEverything()
|
||||
rs.populateTags()
|
||||
log.Warn("Does devel == user?", rs.develBranchVersion.String(), rs.userBranchVersion.String())
|
||||
if rs.develBranchVersion.String() != rs.userBranchVersion.String() {
|
||||
log.Warn("devel does not equal user")
|
||||
log.Warn("merge or squash?")
|
||||
rs.EnableMergeDevel()
|
||||
rs.setMergeUserCommands()
|
||||
label := "merge user into " + rs.GetDevelBranchName()
|
||||
rs.develMerge.SetLabel(label)
|
||||
return
|
||||
}
|
||||
log.Warn("Does master == devel? ", rs.masterBranchVersion.String(), rs.develBranchVersion.String())
|
||||
if rs.masterBranchVersion.String() != rs.develBranchVersion.String() {
|
||||
log.Warn("master does not equal devel. merge devel into master")
|
||||
rs.EnableMergeDevel()
|
||||
rs.setMergeDevelCommands()
|
||||
label := "merge devel into " + rs.GetMasterBranchName()
|
||||
rs.develMerge.SetLabel(label)
|
||||
return
|
||||
}
|
||||
rs.getLastTagVersion()
|
||||
if rs.lasttag.String() != rs.masterBranchVersion.String() {
|
||||
log.Warn("master does not equal last tag")
|
||||
rs.incrementVersion()
|
||||
rs.EnableSelectTag()
|
||||
rs.setTag()
|
||||
return
|
||||
}
|
||||
log.Warn("Is repo pushed upstream? git.wit.org or github?")
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) generateCmd() bool {
|
||||
// the length of 24 is arbitrary, but should be short
|
||||
// they should be things like perhaps, major release names
|
||||
// or something the users might see.
|
||||
// aka: "Topsy", "Picasso", "Buzz", etc
|
||||
|
||||
if !rs.setTag() {
|
||||
log.Warn("tag sucked. fix your tag version")
|
||||
rs.versionMessage.SetLabel("tag message (bad version)")
|
||||
rs.releaseVersion.Disable()
|
||||
return false
|
||||
}
|
||||
|
||||
log.Warn("tag is valid!!!!")
|
||||
rs.setGitCommands()
|
||||
|
||||
if rs.versionMessage.String() == "" {
|
||||
log.Warn("tag message is empty!!!!")
|
||||
rs.releaseVersion.Disable()
|
||||
return false
|
||||
}
|
||||
if len(rs.versionMessage.String()) > 24 {
|
||||
rs.versionMessage.SetLabel("tag message (too long)")
|
||||
} else {
|
||||
rs.versionMessage.SetLabel("tag message")
|
||||
}
|
||||
rs.releaseVersion.Enable()
|
||||
return true
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) runGitCommands() bool {
|
||||
for _, line := range rs.versionCmds {
|
||||
s := strings.Join(line, " ")
|
||||
log.Warn("NEED TO RUN:", s)
|
||||
rs.develMerge.SetText(s)
|
||||
err, b, output := runCmd(rs.repopath, line)
|
||||
if err != nil {
|
||||
log.Warn("ABEND EXECUTION")
|
||||
log.Warn("error =", err)
|
||||
log.Warn("output =", output)
|
||||
return false
|
||||
}
|
||||
log.Warn("Returned with b =", b)
|
||||
log.Warn("output was =", output)
|
||||
log.Warn("RUN DONE")
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) setGitCommands() {
|
||||
var line1, line2, line3 []string
|
||||
var all [][]string
|
||||
|
||||
newTag := rs.newversion.String()
|
||||
line1 = append(line1, "git", "tag", "v"+newTag, "-m", rs.versionMessage.String())
|
||||
all = append(all, line1)
|
||||
line2 = append(line2, "git", "push", "--tags")
|
||||
all = append(all, line2)
|
||||
line3 = append(line3, "git", "push", "--prune", "--tags")
|
||||
all = append(all, line3)
|
||||
|
||||
rs.versionCmds = all
|
||||
|
||||
var tmp []string
|
||||
// convert to displayable to the user text
|
||||
for _, line := range all {
|
||||
s := strings.Join(line, " ")
|
||||
log.Warn("s =", s)
|
||||
tmp = append(tmp, s)
|
||||
}
|
||||
|
||||
rs.versionCmdOutput.SetValue(strings.Join(tmp, "\n"))
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) setMergeDevelCommands() {
|
||||
var line1, line2, line3 []string
|
||||
var all [][]string
|
||||
|
||||
master := rs.GetMasterBranchName()
|
||||
devel := rs.GetDevelBranchName()
|
||||
|
||||
line1 = append(line1, "git", "checkout", master)
|
||||
all = append(all, line1)
|
||||
line2 = append(line2, "git", "merge", devel)
|
||||
all = append(all, line2)
|
||||
line3 = append(line3, "git", "push")
|
||||
all = append(all, line3)
|
||||
|
||||
rs.versionCmds = all
|
||||
|
||||
var tmp []string
|
||||
// convert to displayable to the user text
|
||||
for _, line := range all {
|
||||
s := strings.Join(line, " ")
|
||||
log.Warn("s =", s)
|
||||
tmp = append(tmp, s)
|
||||
}
|
||||
|
||||
rs.versionCmdOutput.SetValue(strings.Join(tmp, "\n"))
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) setMergeUserCommands() {
|
||||
var line1, line2, line3 []string
|
||||
var all [][]string
|
||||
|
||||
devel := rs.GetDevelBranchName()
|
||||
user := rs.GetUserBranchName()
|
||||
|
||||
line1 = append(line1, "git", "checkout", devel)
|
||||
all = append(all, line1)
|
||||
line2 = append(line2, "git", "merge", user)
|
||||
all = append(all, line2)
|
||||
line3 = append(line3, "git", "push")
|
||||
all = append(all, line3)
|
||||
|
||||
rs.versionCmds = all
|
||||
|
||||
var tmp []string
|
||||
// convert to displayable to the user text
|
||||
for _, line := range all {
|
||||
s := strings.Join(line, " ")
|
||||
log.Warn("s =", s)
|
||||
tmp = append(tmp, s)
|
||||
}
|
||||
|
||||
rs.versionCmdOutput.SetValue(strings.Join(tmp, "\n"))
|
||||
}
|
||||
|
|
|
|||
312
git.go
312
git.go
|
|
@ -1,42 +1,306 @@
|
|||
package repostatus
|
||||
|
||||
// most everything here needs to be deprecated now
|
||||
func (rs *RepoStatus) Path() string {
|
||||
return rs.realPath.String()
|
||||
import (
|
||||
"strings"
|
||||
"unicode/utf8"
|
||||
|
||||
"io/ioutil"
|
||||
|
||||
"go.wit.com/log"
|
||||
)
|
||||
|
||||
func (rs *RepoStatus) String() string {
|
||||
return rs.repopath
|
||||
}
|
||||
|
||||
/*
|
||||
func (rs *RepoStatus) GitState() string {
|
||||
return rs.gitState.String()
|
||||
func (rs *RepoStatus) GetPath() string {
|
||||
return rs.repopath
|
||||
}
|
||||
*/
|
||||
|
||||
func (rs *RepoStatus) GetStatus() string {
|
||||
return rs.gitState.String()
|
||||
func (rs *RepoStatus) GetCurrentBranchName() string {
|
||||
return rs.currentBranch.String()
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) GetCurrentBranchVersion() string {
|
||||
return rs.currentVersion.String()
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) GetLastTagVersion() string {
|
||||
return rs.lasttag.String()
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) displayCurrentBranchName() string {
|
||||
out := rs.pb.GetCurrentBranchName()
|
||||
func (rs *RepoStatus) getCurrentBranchName() string {
|
||||
out := run(rs.repopath, "git", "branch --show-current")
|
||||
log.Warn("getCurrentBranchName() =", out)
|
||||
rs.currentBranch.SetValue(out)
|
||||
return out
|
||||
}
|
||||
|
||||
// stores the current branch name
|
||||
func (rs *RepoStatus) checkCurrentBranchName() string {
|
||||
currentname := rs.currentBranch.String()
|
||||
out := rs.pb.GetCurrentBranchName()
|
||||
if currentname == out {
|
||||
// nothing changed
|
||||
return currentname
|
||||
}
|
||||
rs.currentBranch.SetValue(out)
|
||||
if currentname == "" {
|
||||
return out // don't note if there was nothing before
|
||||
}
|
||||
rs.NoteChange("current branch has changed from " + currentname + " to " + out)
|
||||
func (rs *RepoStatus) getCurrentBranchVersion() string {
|
||||
out := run(rs.repopath, "git", "describe --tags")
|
||||
log.Warn("getCurrentBranchVersion()", out)
|
||||
rs.currentVersion.SetValue(out)
|
||||
return out
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) getLastTagVersion() string {
|
||||
out := run(rs.repopath, "git", "rev-list --tags --max-count=1")
|
||||
log.Warn("getLastTagVersion()", out)
|
||||
rs.lasttagrev = out
|
||||
|
||||
lastreal := "describe --tags " + out
|
||||
// out = run(r.path, "git", "describe --tags c871d5ecf051a7dc4e3a77157cdbc0a457eb9ae1")
|
||||
out = run(rs.repopath, "git", lastreal)
|
||||
rs.lasttag.SetValue(out)
|
||||
rs.tagsDrop.SetText(out)
|
||||
// rs.lastLabel.SetText(out)
|
||||
return out
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) populateTags() {
|
||||
tmp := fullpath(rs.repopath + "/.git/refs/tags")
|
||||
log.Warn("populateTags() path =", tmp)
|
||||
for _, tag := range listFiles(tmp) {
|
||||
if rs.tags[tag] == "" {
|
||||
log.Warn("populateTags() Adding new tag", tag)
|
||||
rs.tagsDrop.AddText(tag)
|
||||
rs.tags[tag] = "origin"
|
||||
}
|
||||
}
|
||||
// rs.tagsDrop.SetText(rs.lasttagrev)
|
||||
}
|
||||
|
||||
/*
|
||||
.git/refs/remotes
|
||||
.git/refs/remotes/github
|
||||
.git/refs/remotes/github/devel
|
||||
.git/refs/remotes/github/main
|
||||
.git/refs/remotes/origin
|
||||
.git/refs/remotes/origin/devel
|
||||
.git/refs/remotes/origin/main
|
||||
.git/refs/remotes/origin/jcarr
|
||||
.git/refs/heads
|
||||
*/
|
||||
|
||||
func (rs *RepoStatus) getBranches() []string {
|
||||
var all []string
|
||||
var heads []string
|
||||
var remotes []string
|
||||
heads = listFiles(fullpath(rs.repopath + "/.git/refs/heads"))
|
||||
remotes = listFiles(fullpath(rs.repopath + "/.git/refs/remotes"))
|
||||
|
||||
all = heads
|
||||
|
||||
all = append(all, remotes...)
|
||||
|
||||
for _, branch := range all {
|
||||
log.Warn("getBranches()", branch)
|
||||
}
|
||||
return all
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) CheckDirty() bool {
|
||||
cmd := []string{"git", "diff-index", "--quiet", "HEAD"}
|
||||
path := "/home/jcarr/go/src/" + rs.repopath
|
||||
err, b, out := RunCmd(path, cmd)
|
||||
if err != nil {
|
||||
log.Warn("CheckDirty() b =", b)
|
||||
log.Warn("CheckDirty() path =", path)
|
||||
log.Warn("CheckDirty() out =", out)
|
||||
log.Warn("CheckDirty() err =", err)
|
||||
log.Error(err, "CheckDirty() error")
|
||||
rs.dirtyLabel.SetValue("error")
|
||||
return true
|
||||
}
|
||||
if b {
|
||||
log.Warn("CheckDirty() b =", b, "path =", path, "out =", out)
|
||||
log.Warn("CheckDirty() no", rs.repopath)
|
||||
rs.dirtyLabel.SetValue("no")
|
||||
return false
|
||||
}
|
||||
log.Warn("CheckDirty() true", rs.repopath)
|
||||
rs.dirtyLabel.SetValue("dirty")
|
||||
return true
|
||||
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) CheckoutBranch(branch string) (string, string) {
|
||||
// run(rs.repopath, "git", "checkout " + branch)
|
||||
|
||||
realname := rs.getCurrentBranchName()
|
||||
realversion := rs.getCurrentBranchVersion()
|
||||
log.Warn(rs.repopath, "realname =", realname, "realversion =", realversion)
|
||||
return realname, realversion
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) checkoutBranch(level string, branch string) {
|
||||
if rs.CheckDirty() {
|
||||
log.Warn("checkoutBranch() checkDirty() == true for repo", rs.repopath, "looking for branch:", branch)
|
||||
return
|
||||
}
|
||||
out := run(rs.repopath, "git", "checkout "+branch)
|
||||
log.Warn(rs.repopath, "git checkout "+branch, "returned", out)
|
||||
|
||||
realname := rs.getCurrentBranchName()
|
||||
realversion := rs.getCurrentBranchVersion()
|
||||
log.Warn(rs.repopath, "realname =", realname, "realversion =", realversion)
|
||||
|
||||
switch level {
|
||||
case "master":
|
||||
rs.masterBranchVersion.SetValue(realversion)
|
||||
case "devel":
|
||||
rs.develBranchVersion.SetValue(realversion)
|
||||
case "user":
|
||||
rs.userBranchVersion.SetValue(realversion)
|
||||
default:
|
||||
}
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) SetMasterBranchName(s string) {
|
||||
rs.masterDrop.SetText(s)
|
||||
rs.masterBranchVersion.SetLabel(s)
|
||||
// rs.major.SetTitle(s)
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) SetDevelBranchName(s string) {
|
||||
rs.develDrop.SetText(s)
|
||||
rs.develBranchVersion.SetLabel(s)
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) SetUserBranchName(s string) {
|
||||
rs.userDrop.SetText(s)
|
||||
rs.userBranchVersion.SetLabel(s)
|
||||
}
|
||||
|
||||
// returns "master", "devel", os.Username, etc
|
||||
func (rs *RepoStatus) GetMasterBranchName() string {
|
||||
name := rs.masterDrop.String()
|
||||
log.Warn("GetMasterName() =", name)
|
||||
return name
|
||||
}
|
||||
func (rs *RepoStatus) GetDevelBranchName() string {
|
||||
name := rs.develDrop.String()
|
||||
log.Warn("GetDevelName() =", name)
|
||||
return name
|
||||
}
|
||||
func (rs *RepoStatus) GetUserBranchName() string {
|
||||
name := rs.userDrop.String()
|
||||
log.Warn("GetUserBranchName() =", name)
|
||||
return name
|
||||
}
|
||||
|
||||
// returns the git versions like "1.3-2-laksdjf" or whatever
|
||||
func (rs *RepoStatus) GetMasterVersion() string {
|
||||
name := rs.masterBranchVersion.String()
|
||||
log.Warn("GetMasterVersion() =", name)
|
||||
return name
|
||||
}
|
||||
func (rs *RepoStatus) GetDevelVersion() string {
|
||||
name := rs.develBranchVersion.String()
|
||||
log.Warn("GetBranchVersion() =", name)
|
||||
return name
|
||||
}
|
||||
func (rs *RepoStatus) GetUserVersion() string {
|
||||
name := rs.userBranchVersion.String()
|
||||
log.Warn("GetUserVersion() =", name)
|
||||
return name
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) SetMasterVersion(s string) {
|
||||
if rs.GetMasterVersion() == s {
|
||||
return
|
||||
}
|
||||
rs.changed = true
|
||||
log.Warn("git", rs.GetMasterBranchName(), "version now =", s)
|
||||
rs.masterBranchVersion.SetValue(s)
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) SetDevelVersion(s string) {
|
||||
if rs.GetDevelVersion() == s {
|
||||
return
|
||||
}
|
||||
rs.changed = true
|
||||
log.Warn("git", rs.GetDevelBranchName(), "version now =", s)
|
||||
rs.develBranchVersion.SetValue(s)
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) SetUserVersion(s string) {
|
||||
if rs.GetUserVersion() == s {
|
||||
return
|
||||
}
|
||||
rs.changed = true
|
||||
log.Warn("git", rs.GetUserBranchName(), "version now =", s)
|
||||
rs.userBranchVersion.SetValue(s)
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) GetStatus() string {
|
||||
rs.changed = false
|
||||
if rs.CheckDirty() {
|
||||
log.Warn("CheckDirty() true")
|
||||
return "dirty"
|
||||
}
|
||||
if rs.userBranchVersion.String() != rs.develBranchVersion.String() {
|
||||
return "merge to devel"
|
||||
}
|
||||
if rs.userBranchVersion.String() != rs.masterBranchVersion.String() {
|
||||
return "ready to release"
|
||||
}
|
||||
if rs.lasttag.String() != rs.masterBranchVersion.String() {
|
||||
return "ready to tag version"
|
||||
}
|
||||
|
||||
if rs.CheckBranches() {
|
||||
log.Warn("Branches are Perfect")
|
||||
return "PERFECT"
|
||||
}
|
||||
log.Warn(rs.GetPath(), "Branches are not Perfect")
|
||||
return "unknown branches"
|
||||
}
|
||||
|
||||
// TODO: make this report the error somewhere
|
||||
func (rs *RepoStatus) CheckBranches() bool {
|
||||
var hashCheck string
|
||||
var perfect bool = true
|
||||
all := rs.getBranches()
|
||||
path := fullpath(rs.repopath + "/.git/refs/")
|
||||
for _, b := range all {
|
||||
parts := strings.Split(b, "/")
|
||||
rdir := "heads"
|
||||
if len(parts) == 2 {
|
||||
rdir = "remotes"
|
||||
}
|
||||
fullfile := path + "/" + rdir + "/" + b
|
||||
|
||||
// check if the ref name is "HEAD". if so, skip
|
||||
runeCount := utf8.RuneCountInString(fullfile)
|
||||
// Convert the string to a slice of runes
|
||||
runes := []rune(fullfile)
|
||||
// Slice the last 4 runes
|
||||
lastFour := runes[runeCount-4:]
|
||||
if string(lastFour) == "HEAD" {
|
||||
log.Warn("skip HEAD fullfile", fullfile)
|
||||
continue
|
||||
}
|
||||
|
||||
content, _ := ioutil.ReadFile(fullfile)
|
||||
hash := strings.TrimSpace(string(content))
|
||||
if hashCheck == "" {
|
||||
hashCheck = hash
|
||||
}
|
||||
var cmd []string
|
||||
cmd = append(cmd, "git", "show", "-s", "--format=%ci", hash)
|
||||
_, _, output := RunCmd("/home/jcarr/go/src/"+rs.repopath, cmd)
|
||||
// git show -s --format=%ci <hash> will give you the time
|
||||
// log.Warn(fullfile)
|
||||
if hash == hashCheck {
|
||||
log.Warn(hash, output, b)
|
||||
} else {
|
||||
log.Warn("UNKNOWN BRANCHES IN THIS REPO")
|
||||
rs.versionMessage.SetText("UNKNOWN BRANCHES")
|
||||
perfect = false
|
||||
parts := strings.Split(b, "/")
|
||||
log.Warn("git push", parts)
|
||||
}
|
||||
}
|
||||
return perfect
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,16 @@
|
|||
module go.wit.com/lib/gui/repostatus
|
||||
|
||||
go 1.21.4
|
||||
|
||||
require (
|
||||
go.wit.com/gui v0.12.19
|
||||
go.wit.com/lib/gadgets v0.12.15
|
||||
go.wit.com/log v0.5.6
|
||||
go.wit.com/widget v1.1.6
|
||||
)
|
||||
|
||||
require (
|
||||
go.wit.com/dev/alexflint/arg v1.4.5 // indirect
|
||||
go.wit.com/dev/alexflint/scalar v1.2.1 // indirect
|
||||
go.wit.com/dev/davecgh/spew v1.1.4 // indirect
|
||||
)
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
go.wit.com/dev/alexflint/arg v1.4.5 h1:asDx5f9IlfpknKjPBqqb2qndE91Pbo7ZDkWUgddfMhY=
|
||||
go.wit.com/dev/alexflint/arg v1.4.5/go.mod h1:wnWc+c6z8kSdDKYriMf6RpM+FiXmo5RYp/t4FNi0MU0=
|
||||
go.wit.com/dev/alexflint/scalar v1.2.1 h1:loXOcbVnd+8YeJRLey+XXidecBiedMDO00zQ26TvKNs=
|
||||
go.wit.com/dev/alexflint/scalar v1.2.1/go.mod h1:+rYsfxqdI2cwA8kJ7GCMwWbNJvfvWUurOCXLiwdTtSs=
|
||||
go.wit.com/dev/davecgh/spew v1.1.4 h1:C9hj/rjlUpdK+E6aroyLjCbS5MFcyNUOuP1ICLWdNek=
|
||||
go.wit.com/dev/davecgh/spew v1.1.4/go.mod h1:sihvWmnQ/09FWplnEmozt90CCVqBtGuPXM811tgfhFA=
|
||||
go.wit.com/gui v0.12.19 h1:OEnsnZnec7Q2jZVjwl413V0wuVAAB4r2mGTY0IouBuw=
|
||||
go.wit.com/gui v0.12.19/go.mod h1:v2VgnOL3dlZ13KclYeedZ1cd20nQdvwjyJTNKvFX3DA=
|
||||
go.wit.com/lib/gadgets v0.12.15 h1:C9q6wc45Trh5SrizD8lOXOWoJLGq/ESWwzjCVylZrNY=
|
||||
go.wit.com/lib/gadgets v0.12.15/go.mod h1:Fxc7F8hGskpkWVAsXKhs4ilqUlAnikVXj4yzumtTYa0=
|
||||
go.wit.com/log v0.5.6 h1:rDC3ju95zfEads4f1Zm+QMkqjZ39CsYAT/UmQQs7VP4=
|
||||
go.wit.com/log v0.5.6/go.mod h1:BaJBfHFqcJSJLXGQ9RHi3XVhPgsStxSMZRlaRxW4kAo=
|
||||
go.wit.com/widget v1.1.6 h1:av2miF5vlohMfARA/QGPTPfgW/ADup1c+oeAOKgroPY=
|
||||
go.wit.com/widget v1.1.6/go.mod h1:I8tnD3x3ECbB/CRNnLCdC+uoyk7rK0AEkzK1bQYSqoQ=
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
package repostatus
|
||||
|
||||
import (
|
||||
"go.wit.com/gui"
|
||||
"go.wit.com/lib/gadgets"
|
||||
"go.wit.com/log"
|
||||
)
|
||||
|
||||
func New(p *gui.Node, path string) *RepoStatus {
|
||||
rs := &RepoStatus{
|
||||
hidden: true,
|
||||
ready: false,
|
||||
parent: p,
|
||||
repopath: path,
|
||||
}
|
||||
rs.tags = make(map[string]string)
|
||||
rs.window = gadgets.NewBasicWindow(p, "GO Repo Details "+path)
|
||||
rs.window.Horizontal()
|
||||
rs.window.Make()
|
||||
rs.ready = true
|
||||
rs.draw()
|
||||
rs.window.Custom = func() {
|
||||
// rs.hidden = true
|
||||
rs.Hide()
|
||||
log.Warn("repostatus user closed the window()")
|
||||
}
|
||||
return rs
|
||||
}
|
||||
73
structs.go
73
structs.go
|
|
@ -3,64 +3,47 @@ package repostatus
|
|||
import (
|
||||
"go.wit.com/gui"
|
||||
"go.wit.com/lib/gadgets"
|
||||
"go.wit.com/lib/protobuf/gitpb"
|
||||
)
|
||||
|
||||
type RepoStatus struct {
|
||||
ready bool
|
||||
changed bool // keeps track of changes that might have happened
|
||||
changes string
|
||||
// tags map[string]string
|
||||
InitOk bool // it takes a second or so to init these
|
||||
hidden bool
|
||||
changed bool
|
||||
|
||||
pb *gitpb.Repo // the protobuf
|
||||
repopath string
|
||||
lasttagrev string
|
||||
tags map[string]string
|
||||
|
||||
// used to temporarily tell the automation tools to
|
||||
// try to ignore this repo's changes and state
|
||||
// specifically when doing formal releases, sometimes
|
||||
// some repos are in flux and can't be changed. This
|
||||
// means attempt to overlook that situation.
|
||||
Whitelist bool
|
||||
parent *gui.Node
|
||||
|
||||
window *gadgets.BasicWindow // the main window for this repo
|
||||
Tags *GitTagBox // a box of all the git tags
|
||||
window *gadgets.BasicWindow
|
||||
// group *gui.Node
|
||||
// grid *gui.Node
|
||||
|
||||
// status *gadgets.OneLiner
|
||||
dirtyLabel *gadgets.OneLiner
|
||||
dirtyList string // the output from git status --porcelain
|
||||
readOnly *gadgets.OneLiner
|
||||
gitState *gadgets.OneLiner
|
||||
|
||||
primitive *gadgets.OneLiner // aka: doesn't have a go.sum file
|
||||
private *gadgets.OneLiner // it's not possible to publish this to pkg.go.dev
|
||||
protobuf *gadgets.OneLiner // is this repo a protobuf repo?
|
||||
|
||||
path *gadgets.OneLiner
|
||||
goSrcPath *gadgets.OneLiner
|
||||
goPath *gadgets.OneLiner
|
||||
realPath *gadgets.OneLiner
|
||||
isGoLang *gadgets.OneLiner
|
||||
|
||||
currentBranch *gadgets.OneLiner
|
||||
currentVersion *gadgets.OneLiner
|
||||
tagsDrop *gadgets.BasicDropdown
|
||||
|
||||
mainWorkingName *gadgets.OneLiner // the actual name of the primary branch
|
||||
develWorkingName *gadgets.OneLiner // the actual name of the devel branch
|
||||
userWorkingName *gadgets.OneLiner // the actual name of the user branch
|
||||
develMergeB *gui.Node // button to merge from user to devel
|
||||
mainMergeB *gui.Node // button to merge from devel to master
|
||||
releaseVersion *gui.Node // the release version
|
||||
minor *gadgets.BasicCombobox // the '3' in version v3.1.4
|
||||
major *gadgets.BasicCombobox // the '1' in version v3.1.4
|
||||
revision *gadgets.BasicCombobox // the '4' in version v3.1.4
|
||||
lasttag *gadgets.OneLiner // the last tag version
|
||||
mainBranchVersion *gadgets.OneLiner // the primary branch version
|
||||
develBranchVersion *gadgets.OneLiner // the devel branch version
|
||||
userBranchVersion *gadgets.OneLiner // the user branch version
|
||||
lasttag *gadgets.OneLiner
|
||||
masterBranchVersion *gadgets.OneLiner
|
||||
develBranchVersion *gadgets.OneLiner
|
||||
userBranchVersion *gadgets.OneLiner
|
||||
|
||||
develMerge *gui.Node
|
||||
releaseVersion *gui.Node
|
||||
|
||||
// vgroup *gui.Node
|
||||
minor *gadgets.BasicCombobox
|
||||
major *gadgets.BasicCombobox
|
||||
revision *gadgets.BasicCombobox
|
||||
|
||||
versionMessage *gadgets.BasicEntry
|
||||
versionCmds [][]string
|
||||
versionCmdOutput *gadgets.OneLiner
|
||||
targetReleaseVersion *gadgets.OneLiner
|
||||
|
||||
newversion *gui.Node
|
||||
|
||||
|
|
@ -68,15 +51,13 @@ type RepoStatus struct {
|
|||
gitStatusGroup *gui.Node
|
||||
gitCommandsGroup *gui.Node
|
||||
|
||||
masterDrop *gadgets.BasicDropdown
|
||||
develDrop *gadgets.BasicDropdown
|
||||
userDrop *gadgets.BasicDropdown
|
||||
|
||||
showBranchesButton *gui.Node
|
||||
checkBranchesButton *gui.Node
|
||||
|
||||
speed *gadgets.OneLiner
|
||||
speedActual *gadgets.OneLiner
|
||||
|
||||
// gitConfig *GitConfig
|
||||
// goConfig GoConfig
|
||||
|
||||
switchBranchB *gui.Node
|
||||
targetBranch *gui.Node
|
||||
}
|
||||
|
|
|
|||
388
tagWindow.go
388
tagWindow.go
|
|
@ -1,388 +0,0 @@
|
|||
package repostatus
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"go.wit.com/gui"
|
||||
"go.wit.com/lib/gui/shell"
|
||||
"go.wit.com/log"
|
||||
)
|
||||
|
||||
type Tag struct {
|
||||
// tracks if the tag is displayed
|
||||
hidden bool
|
||||
|
||||
// the tag "v0.1.3"
|
||||
tag *gui.Node
|
||||
|
||||
// the .git/ref hash
|
||||
ref *gui.Node
|
||||
|
||||
// the .git/ref date
|
||||
date *gui.Node
|
||||
duration *gui.Node
|
||||
|
||||
// the tag comment
|
||||
subject *gui.Node
|
||||
|
||||
// a button to delete the tag
|
||||
deleteB *gui.Node
|
||||
}
|
||||
|
||||
// a GUI box of all the tags in a repo
|
||||
type GitTagBox struct {
|
||||
// the box to list all the tags in
|
||||
box *gui.Node
|
||||
group *gui.Node
|
||||
grid *gui.Node
|
||||
|
||||
// all the tags
|
||||
tags []*Tag
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) makeTagBox(box *gui.Node) error {
|
||||
if rs.Tags != nil {
|
||||
log.Log(WARN, "already scanned tags")
|
||||
return errors.New("already scanned tags")
|
||||
}
|
||||
tagB := new(GitTagBox)
|
||||
rs.Tags = tagB
|
||||
tagB.group = box.NewGroup(".git tags for " + rs.Path())
|
||||
|
||||
// tagB.group.NewButton("prune tags", func() {
|
||||
// tagB.Prune()
|
||||
// })
|
||||
var dups *gui.Node
|
||||
|
||||
dups = tagB.group.NewCheckbox("Show duplicate tags").SetChecked(false)
|
||||
dups.Custom = func() {
|
||||
if dups.Checked() {
|
||||
tagB.Prune()
|
||||
} else {
|
||||
for _, t := range tagB.tags {
|
||||
t.Show()
|
||||
}
|
||||
}
|
||||
}
|
||||
tagB.group.NewButton("delete all", func() {
|
||||
/*
|
||||
for i, t := range tagB.tags {
|
||||
if t.hidden {
|
||||
// log.Info("tag is hidden", i, t.tag.String())
|
||||
continue
|
||||
}
|
||||
log.Info("tag is shown", i, t.tag.String())
|
||||
// rs.DeleteTag(t)
|
||||
}
|
||||
*/
|
||||
})
|
||||
|
||||
grid := tagB.group.NewGrid("tags", 0, 0)
|
||||
tagB.grid = grid
|
||||
|
||||
grid.NewLabel("version")
|
||||
grid.NewLabel("ref")
|
||||
grid.NewLabel("date")
|
||||
grid.NewLabel("release subject")
|
||||
grid.NextRow() // works like a typerwriter newline
|
||||
|
||||
loop := rs.pb.Tags.SortByAge()
|
||||
for loop.Scan() {
|
||||
tag := loop.Next()
|
||||
|
||||
rTag := new(Tag)
|
||||
rTag.tag = grid.NewLabel(tag.GetRefname())
|
||||
rTag.ref = grid.NewEntrybox(tag.GetHash())
|
||||
|
||||
ctime := tag.GetAuthordate().AsTime()
|
||||
dur := shell.GetDurationStamp(ctime)
|
||||
rTag.date = grid.NewLabel(ctime.Format("YYYY/MM/DD"))
|
||||
rTag.duration = grid.NewLabel(dur)
|
||||
|
||||
rTag.subject = grid.NewLabel(tag.GetSubject())
|
||||
rTag.deleteB = grid.NewButton("delete", func() {
|
||||
/*
|
||||
tagversion := tag.GetRefname()
|
||||
log.Info("remove tag", tagversion)
|
||||
var all [][]string
|
||||
all = append(all, []string{"git", "tag", "--delete", tagversion})
|
||||
all = append(all, []string{"git", "push", "--delete", "origin", tagversion})
|
||||
|
||||
if rs.DoAll(all) {
|
||||
log.Info("TAG DELETED", rs.Path(), tagversion)
|
||||
} else {
|
||||
log.Info("TAG DELETE FAILED", rs.Path(), tagversion)
|
||||
}
|
||||
*/
|
||||
})
|
||||
|
||||
tagB.tags = append(tagB.tags, rTag)
|
||||
// works like a typerwriter
|
||||
grid.NextRow()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rtags *GitTagBox) ListAll() []*Tag {
|
||||
var tags []*Tag
|
||||
for _, t := range rtags.tags {
|
||||
tags = append(tags, t)
|
||||
}
|
||||
return tags
|
||||
}
|
||||
|
||||
func (rtags *GitTagBox) List() []*Tag {
|
||||
var tags []*Tag
|
||||
for _, t := range rtags.tags {
|
||||
if t.hidden {
|
||||
// log.Info("tag is hidden", i, t.tag.String())
|
||||
continue
|
||||
}
|
||||
// log.Info("tag is shown", t.tag.String(), rtags.rs.String())
|
||||
tags = append(tags, t)
|
||||
}
|
||||
return tags
|
||||
}
|
||||
|
||||
func (rtags *GitTagBox) Prune() {
|
||||
dups := make(map[string]*Tag)
|
||||
for i, t := range rtags.tags {
|
||||
if t == nil {
|
||||
log.Info("tag empty:", i)
|
||||
continue
|
||||
}
|
||||
ref := t.ref.String()
|
||||
_, ok := dups[ref]
|
||||
if ok {
|
||||
log.Info("tag is duplicate:", i, t.tag.String())
|
||||
} else {
|
||||
log.Info("new tag", i, t.tag.String())
|
||||
dups[ref] = t
|
||||
t.Hide()
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// hide tags worth keeping
|
||||
func (rtags *GitTagBox) PruneSmart() {
|
||||
// always keep the first tag
|
||||
var first bool = true
|
||||
|
||||
dups := make(map[string]*Tag)
|
||||
for i, t := range rtags.tags {
|
||||
if t == nil {
|
||||
log.Info("tag empty:", i)
|
||||
continue
|
||||
}
|
||||
|
||||
// check for duplicate tags
|
||||
ref := t.ref.String()
|
||||
_, ok := dups[ref]
|
||||
if ok {
|
||||
log.Info("tag is duplicate:", i, t.tag.String())
|
||||
continue
|
||||
}
|
||||
dups[ref] = t
|
||||
|
||||
// dump any tags that don't start with 'v'
|
||||
//if !strings.HasPrefix(t.tag.String(), "v") {
|
||||
// log.Info("tag does not start with v", i, t.tag.String())
|
||||
// continue
|
||||
//}
|
||||
|
||||
isVersion := regexp.MustCompile("v[0-9]+.[0-9]+.[0-9]+").MatchString
|
||||
if isVersion(t.tag.String()) {
|
||||
if first {
|
||||
log.Info("keep first tag", i, t.tag.String())
|
||||
t.Hide()
|
||||
first = false
|
||||
continue
|
||||
}
|
||||
log.Info("valid tag", i, t.tag.String())
|
||||
t.Hide()
|
||||
continue
|
||||
}
|
||||
|
||||
if first {
|
||||
log.Info("keep first tag", i, t.tag.String())
|
||||
t.Hide()
|
||||
first = false
|
||||
continue
|
||||
}
|
||||
|
||||
log.Info("keep tag", i, t.tag.String())
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
// deleting it locally triggers some but when
|
||||
// the git server was uncontactable (over IPv6 if that matters, probably it doesn't)
|
||||
// and then the local delete re-added it into the tag
|
||||
func (rs *RepoStatus) DeleteTag(rt *Tag) {
|
||||
cmd := []string{"git", "push", "--delete", "origin", rt.tag.String()}
|
||||
log.Info("RUN:", cmd)
|
||||
r := rs.Run(cmd)
|
||||
output := strings.Join(r.Stdout, "\n")
|
||||
if r.Error != nil {
|
||||
log.Info("cmd failed", r.Error)
|
||||
log.Info("output:", output)
|
||||
}
|
||||
log.Info("output:", output)
|
||||
|
||||
cmd = []string{"git", "tag", "--delete", rt.tag.String()}
|
||||
log.Info("RUN:", cmd)
|
||||
r = rs.Run(cmd)
|
||||
output = strings.Join(r.Stdout, "\n")
|
||||
if r.Error != nil {
|
||||
log.Info("cmd failed", r.Error)
|
||||
log.Info("output:", output)
|
||||
}
|
||||
log.Info("output:", output)
|
||||
|
||||
}
|
||||
*/
|
||||
|
||||
func (rt *Tag) TagString() string {
|
||||
return rt.tag.String()
|
||||
}
|
||||
|
||||
func (rt *Tag) Hide() {
|
||||
rt.hidden = true
|
||||
rt.tag.Hide()
|
||||
rt.ref.Hide()
|
||||
rt.date.Hide()
|
||||
rt.duration.Hide()
|
||||
rt.subject.Hide()
|
||||
rt.deleteB.Hide()
|
||||
}
|
||||
|
||||
func (rt *Tag) Show() {
|
||||
rt.hidden = false
|
||||
rt.tag.Show()
|
||||
rt.ref.Show()
|
||||
rt.date.Show()
|
||||
rt.duration.Show()
|
||||
rt.subject.Show()
|
||||
rt.deleteB.Show()
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) TagExists(findname string) bool {
|
||||
allTags := rs.Tags.ListAll()
|
||||
for _, t := range allTags {
|
||||
tagname := t.TagString()
|
||||
_, filename := filepath.Split(tagname)
|
||||
if filename == findname {
|
||||
// log.Info("found tag:", path, filename, "from", rs.Path())
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) LocalTagExists(findname string) bool {
|
||||
allTags := rs.Tags.ListAll()
|
||||
for _, t := range allTags {
|
||||
tagname := t.TagString()
|
||||
if strings.HasPrefix(tagname, "refs/remotes") {
|
||||
continue
|
||||
}
|
||||
path, filename := filepath.Split(tagname)
|
||||
log.Log(INFO, "tag:", path, filename, "from", rs.Path())
|
||||
if filename == findname {
|
||||
log.Log(INFO, "found tag:", path, filename, "from", rs.Path())
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// returns true if 'taggy' is _ONLY_ a local tag
|
||||
// this means you can not do a git pull or git push on it
|
||||
func (rs *RepoStatus) IsOnlyLocalTag(taggy string) bool {
|
||||
// first make sure the tag is actually even local
|
||||
if !rs.LocalTagExists(taggy) {
|
||||
// this means it's not even local now.
|
||||
return false
|
||||
}
|
||||
// okay, taggy exists, does it exist in a remote repo?
|
||||
for _, t := range rs.Tags.ListAll() {
|
||||
tagname := t.TagString()
|
||||
if strings.HasPrefix(tagname, "refs/remotes") {
|
||||
path, filename := filepath.Split(tagname)
|
||||
if filename == taggy {
|
||||
log.Log(REPOWARN, "found tag:", path, filename, "from", rs.Path())
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
// we couldn't find the local tag anywhere remote, so it's probably only local
|
||||
return true
|
||||
}
|
||||
|
||||
func (t *Tag) Age() time.Duration {
|
||||
const gitLayout = "Mon Jan 2 15:04:05 2006 -0700"
|
||||
tagTime, _ := time.Parse(gitLayout, t.date.String())
|
||||
return time.Since(tagTime)
|
||||
}
|
||||
|
||||
func (t *Tag) Name() string {
|
||||
return t.tag.String()
|
||||
}
|
||||
|
||||
func (t *Tag) GetDate() (time.Time, error) {
|
||||
const gitLayout = "Mon Jan 2 15:04:05 2006 -0700"
|
||||
tagTime, err := time.Parse(gitLayout, t.date.String())
|
||||
|
||||
if err != nil {
|
||||
log.Log(REPOWARN, "tag date err", t.ref.String(), t.tag.String(), err)
|
||||
return time.Now(), err
|
||||
}
|
||||
return tagTime, nil
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) NewestTag() *Tag {
|
||||
var newest *Tag
|
||||
var newestTime time.Time
|
||||
var tagTime time.Time
|
||||
var err error
|
||||
var allTags []*Tag
|
||||
var mu sync.Mutex
|
||||
|
||||
allTags = make([]*Tag, 0, 0)
|
||||
junk := rs.Tags.ListAll()
|
||||
allTags = append(allTags, junk...)
|
||||
for _, t := range allTags {
|
||||
mu.Lock()
|
||||
if tagTime, err = t.GetDate(); err != nil {
|
||||
mu.Unlock()
|
||||
continue
|
||||
}
|
||||
|
||||
// log.Log(REPOWARN, "tag", t.ref.String(), t.date.String(), t.tag.String())
|
||||
// if this is the first tag, use it
|
||||
if newest == nil {
|
||||
newestTime = tagTime
|
||||
newest = t
|
||||
}
|
||||
|
||||
// if the tag date is after the newest date, it's newer so use this tag
|
||||
if tagTime.After(newestTime) {
|
||||
newestTime = tagTime
|
||||
newest = t
|
||||
}
|
||||
mu.Unlock()
|
||||
}
|
||||
return newest
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) DumpTags() {
|
||||
for _, t := range rs.Tags.ListAll() {
|
||||
log.Log(REPOWARN, "tag", t.ref.String(), t.date.String(), t.tag.String())
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
package repostatus
|
||||
|
||||
import (
|
||||
"time"
|
||||
)
|
||||
|
||||
// timeFunction takes a function as an argument and returns the execution time.
|
||||
func timeFunction(f func()) time.Duration {
|
||||
startTime := time.Now() // Record the start time
|
||||
f() // Execute the function
|
||||
return time.Since(startTime) // Calculate the elapsed time
|
||||
}
|
||||
|
||||
func (ls *RepoStatus) SetSpeedActual(s string) {
|
||||
if !ls.Ready() {
|
||||
return
|
||||
}
|
||||
ls.speedActual.SetValue(s)
|
||||
}
|
||||
|
|
@ -0,0 +1,194 @@
|
|||
// This is a simple example
|
||||
package repostatus
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"os"
|
||||
"os/exec"
|
||||
"os/user"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"strings"
|
||||
|
||||
"go.wit.com/log"
|
||||
)
|
||||
|
||||
func fullpath(repo string) string {
|
||||
return "/home/jcarr/go/src/" + repo
|
||||
}
|
||||
|
||||
func run(path string, thing string, cmdline string) string {
|
||||
parts := strings.Split(cmdline, " ")
|
||||
// Create the command
|
||||
cmd := exec.Command(thing, parts...)
|
||||
|
||||
// Set the working directory
|
||||
cmd.Dir = fullpath(path)
|
||||
|
||||
// Execute the command
|
||||
output, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
log.Error(err, "cmd error'd out", parts)
|
||||
return ""
|
||||
}
|
||||
|
||||
tmp := string(output)
|
||||
tmp = strings.TrimSpace(tmp)
|
||||
|
||||
// Print the output
|
||||
log.Log(WARN, "run()", path, thing, cmdline, "=", tmp)
|
||||
return tmp
|
||||
}
|
||||
|
||||
// goes in one directory so it gets remote branch names
|
||||
func listFiles(directory string) []string {
|
||||
var files []string
|
||||
fileInfo, err := os.ReadDir(directory)
|
||||
if err != nil {
|
||||
log.Error(err)
|
||||
return nil
|
||||
}
|
||||
|
||||
for _, file := range fileInfo {
|
||||
if file.IsDir() {
|
||||
dirname := file.Name()
|
||||
newdir, _ := os.ReadDir(directory + "/" + dirname)
|
||||
for _, file := range newdir {
|
||||
if !file.IsDir() {
|
||||
files = append(files, dirname+"/"+file.Name())
|
||||
}
|
||||
}
|
||||
} else {
|
||||
files = append(files, file.Name())
|
||||
}
|
||||
}
|
||||
|
||||
return files
|
||||
}
|
||||
|
||||
/*
|
||||
// string handling examples that might be helpful for normalizeInt()
|
||||
isAlpha := regexp.MustCompile(`^[A-Za-z]+$`).MatchString
|
||||
|
||||
for _, username := range []string{"userone", "user2", "user-three"} {
|
||||
if !isAlpha(username) {
|
||||
log.Log(GUI, "%q is not valid\n", username)
|
||||
}
|
||||
}
|
||||
|
||||
const alpha = "abcdefghijklmnopqrstuvwxyz"
|
||||
|
||||
func alphaOnly(s string) bool {
|
||||
for _, char := range s {
|
||||
if !strings.Contains(alpha, strings.ToLower(string(char))) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
*/
|
||||
|
||||
func normalizeVersion(s string) string {
|
||||
// reg, err := regexp.Compile("[^a-zA-Z0-9]+")
|
||||
parts := strings.Split(s, "-")
|
||||
if len(parts) == 0 {
|
||||
return ""
|
||||
}
|
||||
reg, err := regexp.Compile("[^0-9.]+")
|
||||
if err != nil {
|
||||
log.Log(WARN, "normalizeVersion() regexp.Compile() ERROR =", err)
|
||||
return parts[0]
|
||||
}
|
||||
clean := reg.ReplaceAllString(parts[0], "")
|
||||
log.Log(WARN, "normalizeVersion() s =", clean)
|
||||
return clean
|
||||
}
|
||||
|
||||
func splitVersion(version string) (a, b, c string) {
|
||||
tmp := normalizeVersion(version)
|
||||
parts := strings.Split(tmp, ".")
|
||||
switch len(parts) {
|
||||
case 1:
|
||||
return parts[0], "", ""
|
||||
case 2:
|
||||
return parts[0], parts[1], ""
|
||||
default:
|
||||
return parts[0], parts[1], parts[2]
|
||||
}
|
||||
}
|
||||
|
||||
// temp hack. fix this
|
||||
func runCmd(path string, parts []string) (error, bool, string) {
|
||||
fulldir := fullpath(path)
|
||||
return RunCmd(fulldir, parts)
|
||||
}
|
||||
|
||||
func RunCmd(workingpath string, parts []string) (error, bool, string) {
|
||||
if len(parts) == 0 {
|
||||
log.Warn("command line was empty")
|
||||
return errors.New("empty"), false, ""
|
||||
}
|
||||
if parts[0] == "" {
|
||||
log.Warn("command line was empty")
|
||||
return errors.New("empty"), false, ""
|
||||
}
|
||||
thing := parts[0]
|
||||
parts = parts[1:]
|
||||
|
||||
log.Warn("working path =", workingpath, "thing =", thing, "cmdline =", parts)
|
||||
// Create the command
|
||||
cmd := exec.Command(thing, parts...)
|
||||
|
||||
// Set the working directory
|
||||
cmd.Dir = workingpath
|
||||
|
||||
// Execute the command
|
||||
output, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
log.Error(err)
|
||||
log.Warn("output was", string(output))
|
||||
log.Warn("cmd exited with error", err)
|
||||
return err, false, string(output)
|
||||
}
|
||||
|
||||
tmp := string(output)
|
||||
tmp = strings.TrimSpace(tmp)
|
||||
|
||||
// Print the output
|
||||
return nil, true, tmp
|
||||
}
|
||||
|
||||
// Set the path to the package
|
||||
// Replace this with the actual path to the github.com/coredns/coredns directory
|
||||
func getfiles(pathToPackage string) {
|
||||
// List files in the directory
|
||||
err := filepath.Walk(pathToPackage, nil) // compiles but crashes
|
||||
if err == nil {
|
||||
log.Warn("directory ok", pathToPackage)
|
||||
} else {
|
||||
log.Warn("directory wrong", pathToPackage)
|
||||
}
|
||||
}
|
||||
|
||||
func IsDirectory(path string) bool {
|
||||
info, err := os.Stat(path)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
return info.IsDir()
|
||||
}
|
||||
|
||||
func VerifyLocalGoRepo(gorepo string) bool {
|
||||
// Get current user
|
||||
usr, err := user.Current()
|
||||
if err != nil {
|
||||
log.Error(err, "VerifyLocalGoRepo() thinks you should switch to Ultrix")
|
||||
return false
|
||||
}
|
||||
|
||||
// Form the path to the home Git directory
|
||||
gitDir := filepath.Join(usr.HomeDir, "go/src/", gorepo, ".git")
|
||||
|
||||
log.Warn("go directory:", gitDir)
|
||||
return IsDirectory(gitDir)
|
||||
}
|
||||
138
update.go
138
update.go
|
|
@ -2,6 +2,8 @@ package repostatus
|
|||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"go.wit.com/log"
|
||||
)
|
||||
|
|
@ -12,38 +14,112 @@ func (rs *RepoStatus) Update() {
|
|||
log.Error(errors.New("Update() is not ready yet"))
|
||||
return
|
||||
}
|
||||
log.Log(WARN, "Update() START")
|
||||
duration := timeFunction(func() {
|
||||
// do things that are safe even if the git tree is dirty
|
||||
rs.path.SetValue(rs.repopath)
|
||||
rs.getCurrentBranchName()
|
||||
rs.window.SetTitle(rs.repopath + " GO repo Details")
|
||||
rs.getCurrentBranchVersion()
|
||||
rs.getLastTagVersion()
|
||||
rs.populateTags()
|
||||
rs.CheckDirty()
|
||||
|
||||
pb := rs.pb
|
||||
|
||||
// store the current checked out branch name and version
|
||||
rs.checkCurrentBranchName()
|
||||
out := rs.pb.GetCurrentVersion()
|
||||
rs.currentVersion.SetValue(out)
|
||||
|
||||
// read in the tags
|
||||
// rs.populateTags()
|
||||
|
||||
// record if the repo is dirty
|
||||
pb.CheckDirty()
|
||||
|
||||
// display the last tag version
|
||||
name := rs.pb.GetLastTagVersion()
|
||||
rs.lasttag.SetText(name)
|
||||
|
||||
// store the master branch version
|
||||
ver := pb.GetMasterVersion()
|
||||
rs.mainBranchVersion.SetValue(ver)
|
||||
|
||||
rs.develBranchVersion.SetValue(pb.GetDevelVersion())
|
||||
rs.userBranchVersion.SetValue(pb.GetUserVersion())
|
||||
|
||||
// populates a string into the rs.gitState widget
|
||||
// todo: make the values from this function a bit cleaner
|
||||
rs.CheckGitState()
|
||||
if rs.dirtyLabel.String() != "no" {
|
||||
log.Warn("dirty label != no. actual value:", rs.dirtyLabel.String())
|
||||
rs.DisableEverything()
|
||||
rs.CheckBranches()
|
||||
return
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) CheckGitState() string {
|
||||
state := rs.pb.GetState()
|
||||
rs.gitState.SetText(state)
|
||||
return state
|
||||
master := rs.masterDrop.String()
|
||||
devel := rs.develDrop.String()
|
||||
user := rs.userDrop.String()
|
||||
|
||||
// rs.CheckDirty() this runs
|
||||
log.Log(WARN, "")
|
||||
log.Log(WARN, "checkoutBranch", master)
|
||||
rs.checkoutBranch("master", master)
|
||||
log.Log(WARN, "")
|
||||
log.Log(WARN, "checkoutBranch", devel)
|
||||
rs.checkoutBranch("devel", devel)
|
||||
log.Log(WARN, "")
|
||||
log.Log(WARN, "checkoutBranch", user)
|
||||
rs.checkoutBranch("user", user)
|
||||
|
||||
rs.recommend()
|
||||
rs.CheckBranches()
|
||||
})
|
||||
rs.setSpeed(duration)
|
||||
log.Log(WARN, "Update() END")
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) setSpeed(duration time.Duration) {
|
||||
s := fmt.Sprint(duration)
|
||||
if rs.speedActual == nil {
|
||||
log.Log(WARN, "can't actually warn")
|
||||
return
|
||||
}
|
||||
rs.speedActual.SetValue(s)
|
||||
|
||||
if duration > 500*time.Millisecond {
|
||||
rs.speed.SetValue("SLOW")
|
||||
} else if duration > 100*time.Millisecond {
|
||||
rs.speed.SetValue("OK")
|
||||
} else {
|
||||
rs.speed.SetValue("FAST")
|
||||
}
|
||||
}
|
||||
|
||||
// disable all things besides Update() button
|
||||
func (rs *RepoStatus) DisableEverything() {
|
||||
log.Warn("DisableEverything()")
|
||||
|
||||
// choosing a major, minor or revision
|
||||
rs.major.Disable()
|
||||
rs.minor.Disable()
|
||||
rs.revision.Disable()
|
||||
|
||||
// disable adding a tag message
|
||||
rs.versionMessage.Disable()
|
||||
|
||||
// disable the merge devel to master button
|
||||
rs.develMerge.Disable()
|
||||
|
||||
// disable the tag a new version button
|
||||
rs.releaseVersion.Disable()
|
||||
}
|
||||
|
||||
// this means devel needs to be merged to master
|
||||
func (rs *RepoStatus) EnableMergeDevel() {
|
||||
rs.DisableEverything()
|
||||
|
||||
rs.develMerge.Enable()
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) Disable() {
|
||||
rs.window.Disable()
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) Enable() {
|
||||
rs.window.Enable()
|
||||
}
|
||||
|
||||
// this means you need to release a new version of the master repository
|
||||
func (rs *RepoStatus) EnableSelectTag() {
|
||||
rs.DisableEverything()
|
||||
|
||||
// choosing a major, minor or revision
|
||||
rs.major.Enable()
|
||||
rs.minor.Enable()
|
||||
rs.revision.Enable()
|
||||
|
||||
// disable adding a tag message
|
||||
rs.versionMessage.Enable()
|
||||
rs.versionMessage.SetText("")
|
||||
|
||||
rs.develMerge.SetLabel("ready to release")
|
||||
|
||||
// force there to be a commit message
|
||||
rs.releaseVersion.Disable()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,127 +0,0 @@
|
|||
package repostatus
|
||||
|
||||
import (
|
||||
"go.wit.com/lib/gadgets"
|
||||
"go.wit.com/lib/protobuf/gitpb"
|
||||
"go.wit.com/log"
|
||||
|
||||
"go.wit.com/gui"
|
||||
)
|
||||
|
||||
type repoBranchesWindow struct {
|
||||
repo *gitpb.Repo // the repo protobuf
|
||||
win *gadgets.BasicWindow // the patches window
|
||||
stack *gui.Node // the top box set as vertical
|
||||
//shelf *gui.Node // the first box in the stack, set as horizontal
|
||||
//grid *gui.Node // the list of available patches
|
||||
//setgrid *gui.Node // the list of each patchset
|
||||
}
|
||||
|
||||
// todo: autogenerate these or make them standared 'gui' package functions
|
||||
// make this an go interface somehow
|
||||
|
||||
// is the window hidden right now?
|
||||
func (w *repoBranchesWindow) Hidden() bool {
|
||||
return w.win.Hidden()
|
||||
}
|
||||
|
||||
// switches between the window being visable or hidden on the desktop
|
||||
func (w *repoBranchesWindow) Toggle() {
|
||||
if w.Hidden() {
|
||||
w.Show()
|
||||
} else {
|
||||
w.Hide()
|
||||
}
|
||||
}
|
||||
|
||||
// hides the window completely
|
||||
func (w *repoBranchesWindow) Show() {
|
||||
w.win.Show()
|
||||
}
|
||||
|
||||
func (w *repoBranchesWindow) Hide() {
|
||||
w.win.Hide()
|
||||
}
|
||||
|
||||
// should be the first box/widget in the window
|
||||
// greys out the window to the user
|
||||
func (w *repoBranchesWindow) Disable() {
|
||||
w.stack.Disable()
|
||||
}
|
||||
|
||||
func (w *repoBranchesWindow) Enable() {
|
||||
w.stack.Enable()
|
||||
}
|
||||
|
||||
// you can only have one of these
|
||||
func MakeRepoBranchesWindow(repo *gitpb.Repo) *repoBranchesWindow {
|
||||
pw := new(repoBranchesWindow)
|
||||
|
||||
// sync.Once()
|
||||
pw.win = gadgets.RawBasicWindow("Branches for " + repo.GetGoPath())
|
||||
pw.win.Make()
|
||||
|
||||
pw.stack = pw.win.Box().NewBox("bw vbox", false)
|
||||
// me.reposwin.Draw()
|
||||
pw.win.Custom = func() {
|
||||
log.Info("Got close. setting win.Hide()")
|
||||
// sets the hidden flag to false so Toggle() works
|
||||
pw.win.Hide()
|
||||
}
|
||||
|
||||
grid := pw.stack.NewGrid("", 0, 0)
|
||||
|
||||
grid.NewGroup("Branches")
|
||||
grid.NextRow()
|
||||
|
||||
grid.NewGroup("Name")
|
||||
grid.NewGroup("Forge use")
|
||||
grid.NewGroup("Ref Version")
|
||||
grid.NewGroup("Type")
|
||||
grid.NewGroup("Hash")
|
||||
grid.NextRow()
|
||||
|
||||
/*
|
||||
for _, b := range repo.GetLocalBranches() {
|
||||
hash := repo.GetBranchHash(b)
|
||||
grid.NewLabel(b)
|
||||
grid.NewLabel(repo.GetBranchVersion(b))
|
||||
if s, err := repo.GetHashName(hash); err == nil {
|
||||
grid.NewLabel(s)
|
||||
} else {
|
||||
grid.NewLabel("err")
|
||||
}
|
||||
grid.NewLabel("local")
|
||||
|
||||
grid.NewLabel(hash)
|
||||
grid.NewButton("Delete", func() {
|
||||
repo.RunVerbose([]string{"git", "branch", "-D", b})
|
||||
})
|
||||
grid.NextRow()
|
||||
}
|
||||
|
||||
for _, b := range repo.GetRemoteBranches() {
|
||||
hash := repo.GetBranchHash(b)
|
||||
grid.NewLabel(b)
|
||||
forgeuse := repo.GetBranchVersion(b)
|
||||
grid.NewLabel(forgeuse)
|
||||
if s, err := repo.GetHashName(hash); err == nil {
|
||||
grid.NewLabel(s)
|
||||
} else {
|
||||
grid.NewLabel("")
|
||||
}
|
||||
grid.NewLabel("remote")
|
||||
|
||||
grid.NewLabel(hash)
|
||||
if b == "origin/HEAD" || forgeuse == "remote master" {
|
||||
// can't delete these
|
||||
} else {
|
||||
grid.NewButton("Delete Remote", func() {
|
||||
})
|
||||
}
|
||||
grid.NextRow()
|
||||
}
|
||||
*/
|
||||
|
||||
return pw
|
||||
}
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
package repostatus
|
||||
|
||||
import (
|
||||
"go.wit.com/lib/gadgets"
|
||||
"go.wit.com/lib/protobuf/gitpb"
|
||||
"go.wit.com/log"
|
||||
)
|
||||
|
||||
var windowMap map[string]*RepoStatus
|
||||
|
||||
func init() {
|
||||
windowMap = make(map[string]*RepoStatus)
|
||||
}
|
||||
|
||||
// makes a window of the status of the repo
|
||||
// don't worry, you can think of it like Sierpinski carpet
|
||||
// it's doesn't need to be displayed so it'll work fine even in an embedded space
|
||||
func NewRepoStatusWindow(repo *gitpb.Repo) (*RepoStatus, error) {
|
||||
path := repo.GetGoPath()
|
||||
if windowMap[path] == nil {
|
||||
log.Log(INFO, "NewRepoStatusWindow() adding new", path)
|
||||
} else {
|
||||
log.Warn("This already exists for path", path)
|
||||
log.Warn("should return windowMap[path] here")
|
||||
return windowMap[path], nil
|
||||
}
|
||||
|
||||
rs := &RepoStatus{
|
||||
ready: false,
|
||||
}
|
||||
rs.pb = repo
|
||||
// realpath := repo.FullPath
|
||||
// isGoLang := true
|
||||
|
||||
// rs.tags = make(map[string]string)
|
||||
rs.window = gadgets.RawBasicWindow("GO Repo Details " + path)
|
||||
rs.window.Horizontal()
|
||||
rs.window.Make()
|
||||
basebox := rs.window.Box()
|
||||
group := basebox.NewGroup("stuff")
|
||||
primarybox := group.Box()
|
||||
primarybox.Horizontal()
|
||||
// box2 := group.Box()
|
||||
rs.ready = true
|
||||
rs.window.Custom = func() {
|
||||
rs.Hide()
|
||||
log.Warn("repostatus user closed the window()")
|
||||
}
|
||||
|
||||
// display the status of the git repository
|
||||
rs.drawGitStatus(primarybox)
|
||||
|
||||
// display the git branches and options
|
||||
rs.makeBranchesBox(primarybox)
|
||||
|
||||
// var win *gadgets.BasicWindow
|
||||
// show standard git commit and merge controls
|
||||
rs.drawGitCommands(primarybox)
|
||||
|
||||
windowMap[path] = rs
|
||||
return rs, nil
|
||||
}
|
||||
216
windowMerge.go
216
windowMerge.go
|
|
@ -1,216 +0,0 @@
|
|||
package repostatus
|
||||
|
||||
import (
|
||||
"go.wit.com/lib/gadgets"
|
||||
"go.wit.com/lib/protobuf/gitpb"
|
||||
"go.wit.com/log"
|
||||
|
||||
"go.wit.com/gui"
|
||||
)
|
||||
|
||||
type repoMergeWindow struct {
|
||||
repo *gitpb.Repo // the repo protobuf
|
||||
win *gadgets.BasicWindow // the patches window
|
||||
stack *gui.Node // the top box set as vertical
|
||||
lasttag *gadgets.OneLiner // the last tag version
|
||||
mainBranchVersion *gadgets.OneLiner // the primary branch version
|
||||
develBranchVersion *gadgets.OneLiner // the devel branch version
|
||||
userBranchVersion *gadgets.OneLiner // the user branch version
|
||||
currentVersion *gadgets.OneLiner // the devel branch version
|
||||
currentBranch *gadgets.OneLiner // the user branch version
|
||||
mergeD *gui.Node // the merge button
|
||||
mergeM *gui.Node // the merge button
|
||||
}
|
||||
|
||||
// todo: autogenerate these or make them standared 'gui' package functions
|
||||
// make this an go interface somehow
|
||||
|
||||
// is the window hidden right now?
|
||||
func (w *repoMergeWindow) Hidden() bool {
|
||||
return w.win.Hidden()
|
||||
}
|
||||
|
||||
// switches between the window being visable or hidden on the desktop
|
||||
func (w *repoMergeWindow) Toggle() {
|
||||
if w.Hidden() {
|
||||
w.Show()
|
||||
} else {
|
||||
w.Hide()
|
||||
}
|
||||
}
|
||||
|
||||
// hides the window completely
|
||||
func (w *repoMergeWindow) Show() {
|
||||
w.win.Show()
|
||||
w.Update()
|
||||
}
|
||||
|
||||
func (w *repoMergeWindow) Hide() {
|
||||
w.win.Hide()
|
||||
}
|
||||
|
||||
// should be the first box/widget in the window
|
||||
// greys out the window to the user
|
||||
func (w *repoMergeWindow) Disable() {
|
||||
w.stack.Disable()
|
||||
}
|
||||
|
||||
func (w *repoMergeWindow) Enable() {
|
||||
w.stack.Enable()
|
||||
}
|
||||
|
||||
func (w *repoMergeWindow) Update() {
|
||||
w.lasttag.SetText(w.repo.GetLastTag())
|
||||
w.mainBranchVersion.SetText(w.repo.GetMasterVersion())
|
||||
w.develBranchVersion.SetText(w.repo.GetDevelVersion())
|
||||
w.userBranchVersion.SetText(w.repo.GetUserVersion())
|
||||
|
||||
w.currentBranch.SetText(w.repo.GetCurrentBranchName())
|
||||
w.currentVersion.SetText(w.repo.GetCurrentVersion())
|
||||
|
||||
if w.repo.GetCurrentBranchName() == w.repo.GetDevelBranchName() {
|
||||
w.mergeD.Enable()
|
||||
} else {
|
||||
w.mergeD.Disable()
|
||||
}
|
||||
|
||||
if w.repo.GetCurrentBranchName() == w.repo.GetMasterBranchName() {
|
||||
w.mergeM.Enable()
|
||||
} else {
|
||||
w.mergeM.Disable()
|
||||
}
|
||||
}
|
||||
|
||||
func (rs *RepoStatus) MakeRepoMergeWindow(repo *gitpb.Repo) *repoMergeWindow {
|
||||
w := new(repoMergeWindow)
|
||||
w.repo = repo
|
||||
|
||||
// sync.Once()
|
||||
w.win = gadgets.RawBasicWindow("Merge controls for " + repo.GetGoPath())
|
||||
w.win.Make()
|
||||
|
||||
w.stack = w.win.Box().NewBox("bw vbox", false)
|
||||
// me.reposwin.Draw()
|
||||
w.win.Custom = func() {
|
||||
log.Info("Got close. setting win.Hide()")
|
||||
// sets the hidden flag to false so Toggle() works
|
||||
w.win.Hide()
|
||||
}
|
||||
|
||||
grid := w.stack.NewGrid("", 0, 0)
|
||||
|
||||
grid.NewGroup("Merge Options")
|
||||
grid.NextRow()
|
||||
|
||||
grid.NewButton("checkout user", func() {
|
||||
w.Disable()
|
||||
defer w.Enable()
|
||||
if err := repo.CheckoutUser(); err != nil {
|
||||
log.Info(repo.GetFullPath(), err)
|
||||
}
|
||||
w.repo.Reload()
|
||||
w.Update()
|
||||
})
|
||||
grid.NextRow()
|
||||
grid.NewButton("checkout devel", func() {
|
||||
w.Disable()
|
||||
defer w.Enable()
|
||||
repo.CheckoutDevel()
|
||||
w.repo.Reload()
|
||||
w.Update()
|
||||
})
|
||||
w.mergeD = grid.NewButton("merge to devel", func() {
|
||||
w.Disable()
|
||||
defer w.Enable()
|
||||
log.Info("repo:", repo.GetGoPath())
|
||||
if result, err := repo.MergeToDevel(); err == nil {
|
||||
log.Warn("THINGS SEEM OK", repo.GetFullPath())
|
||||
for _, line := range result.Stdout {
|
||||
log.Warn("stdout:", line)
|
||||
}
|
||||
for _, line := range result.Stderr {
|
||||
log.Warn("stderr:", line)
|
||||
}
|
||||
} else {
|
||||
log.Warn("THINGS FAILED ", repo.GetFullPath())
|
||||
log.Warn("err", err)
|
||||
for _, line := range result.Stdout {
|
||||
log.Warn("stdout:", line)
|
||||
}
|
||||
for _, line := range result.Stderr {
|
||||
log.Warn("stderr:", line)
|
||||
}
|
||||
}
|
||||
w.repo.Reload()
|
||||
w.Update()
|
||||
})
|
||||
grid.NextRow()
|
||||
grid.NewButton("checkout master", func() {
|
||||
w.Disable()
|
||||
defer w.Enable()
|
||||
repo.CheckoutMaster()
|
||||
w.repo.Reload()
|
||||
w.Update()
|
||||
})
|
||||
w.mergeM = grid.NewButton("merge to master", func() {
|
||||
w.Disable()
|
||||
defer w.Enable()
|
||||
log.Info("repo:", repo.GetGoPath())
|
||||
if result, err := repo.MergeToMaster(); err == nil {
|
||||
log.Warn("THINGS SEEM OK", repo.GetFullPath())
|
||||
for _, line := range result.Stdout {
|
||||
log.Warn("stdout:", line)
|
||||
}
|
||||
for _, line := range result.Stderr {
|
||||
log.Warn("stderr:", line)
|
||||
}
|
||||
} else {
|
||||
log.Warn("THINGS FAILED ", repo.GetFullPath())
|
||||
log.Warn("err", err)
|
||||
for _, line := range result.Stdout {
|
||||
log.Warn("stdout:", line)
|
||||
}
|
||||
for _, line := range result.Stderr {
|
||||
log.Warn("stderr:", line)
|
||||
}
|
||||
}
|
||||
w.repo.Reload()
|
||||
w.Update()
|
||||
})
|
||||
grid.NextRow()
|
||||
|
||||
w.lasttag = gadgets.NewOneLiner(grid, "last tag") // `progname:"LASTTAG"`
|
||||
grid.NextRow()
|
||||
|
||||
w.mainBranchVersion = gadgets.NewOneLiner(grid, "master") // `progname:"MASTERBRANCH"`
|
||||
grid.NextRow()
|
||||
w.develBranchVersion = gadgets.NewOneLiner(grid, "devel") // `progname:"DEVELBRANCH"`
|
||||
grid.NextRow()
|
||||
w.userBranchVersion = gadgets.NewOneLiner(grid, "user") // `progname:"USERBRANCH"`
|
||||
grid.NextRow()
|
||||
|
||||
w.currentBranch = gadgets.NewOneLiner(grid, "current branch") // `progname:"CURRENTBRANCH"`
|
||||
grid.NextRow()
|
||||
w.currentVersion = gadgets.NewOneLiner(grid, "current version") // `progname:"CURRENTVERSION"`
|
||||
grid.NextRow()
|
||||
|
||||
w.Update()
|
||||
|
||||
return w
|
||||
}
|
||||
|
||||
/*
|
||||
rs.showBranchesButton = newgrid.NewButton("find user and devel", func() {
|
||||
log.Info("redo this")
|
||||
})
|
||||
newgrid.NextRow()
|
||||
|
||||
rs.checkBranchesButton = newgrid.NewButton("CheckBranches()", func() {
|
||||
log.Info("redo this")
|
||||
})
|
||||
newgrid.NextRow()
|
||||
|
||||
newgrid.NewButton("Revert master to devel", func() {
|
||||
log.Info("redo this")
|
||||
})
|
||||
*/
|
||||
123
windowModify.go
123
windowModify.go
|
|
@ -1,123 +0,0 @@
|
|||
package repostatus
|
||||
|
||||
import (
|
||||
"go.wit.com/gui"
|
||||
"go.wit.com/lib/gadgets"
|
||||
"go.wit.com/log"
|
||||
)
|
||||
|
||||
func (rs *RepoStatus) drawGitCommands(box *gui.Node) {
|
||||
rs.gitCommandsGroup = box.NewGroup("modify")
|
||||
newgrid := rs.gitCommandsGroup.NewGrid("gridnuts", 0, 0)
|
||||
|
||||
newgrid.NewButton("Rescan Repo", func() {
|
||||
rs.Update()
|
||||
})
|
||||
|
||||
newgrid.NewButton("CheckDirty()", func() {
|
||||
if rs.pb.CheckDirty() {
|
||||
log.Log(WARN, "is dirty")
|
||||
} else {
|
||||
log.Log(WARN, "is not dirty")
|
||||
}
|
||||
})
|
||||
|
||||
newgrid.NewButton("show .git/config", func() {
|
||||
if rs.pb.GitConfig == nil {
|
||||
log.Log(WARN, "Nonexistant or damaged .git/config", rs.Path())
|
||||
return
|
||||
}
|
||||
log.Log(WARN, ".git/config:", rs.realPath.String())
|
||||
|
||||
// The info:
|
||||
for name, remote := range rs.pb.GitConfig.Remotes {
|
||||
log.Log(WARN, " ", name, "url:", remote.Url)
|
||||
}
|
||||
for name, branch := range rs.pb.GitConfig.Branches {
|
||||
log.Log(WARN, " ", name, "remote:", branch.Remote, "merge", branch.Merge)
|
||||
}
|
||||
})
|
||||
newgrid.NextRow()
|
||||
|
||||
newgrid.NewButton("git pull", func() {
|
||||
rs.pb.GitPull()
|
||||
})
|
||||
newgrid.NextRow()
|
||||
|
||||
label := "merge " + rs.userWorkingName.String() + " to " + rs.develWorkingName.String()
|
||||
rs.develMergeB = newgrid.NewButton(label, func() {
|
||||
rs.Disable()
|
||||
if result, err := rs.pb.MergeToDevel(); err == nil {
|
||||
log.Warn("THINGS SEEM OK fullAutomation() returned true.")
|
||||
} else {
|
||||
log.Warn("THINGS FAILED fullAutomation() returned false", result.Error)
|
||||
}
|
||||
rs.Enable()
|
||||
})
|
||||
|
||||
label = "merge " + rs.develWorkingName.String() + " to " + rs.mainWorkingName.String()
|
||||
rs.mainMergeB = newgrid.NewButton(label, func() {
|
||||
rs.Disable()
|
||||
if result, err := rs.pb.MergeToMaster(); err == nil {
|
||||
log.Warn("THINGS SEEM OK fullAutomation() returned true.")
|
||||
} else {
|
||||
log.Warn("THINGS FAILED fullAutomation() returned false", result.Error)
|
||||
}
|
||||
rs.Enable()
|
||||
})
|
||||
newgrid.NewButton("increment version", func() {
|
||||
log.Info("broken")
|
||||
// rs.IncrementVersion()
|
||||
})
|
||||
newgrid.NextRow()
|
||||
|
||||
rs.major = gadgets.NewBasicCombobox(newgrid, "major")
|
||||
rs.major.Custom = func() {
|
||||
// rs.setTag()
|
||||
// rs.generateCmd()
|
||||
}
|
||||
// rs.major.Hide()
|
||||
newgrid.NextRow()
|
||||
|
||||
rs.minor = gadgets.NewBasicCombobox(newgrid, "minor")
|
||||
rs.minor.Custom = func() {
|
||||
// rs.setTag()
|
||||
// rs.generateCmd()
|
||||
}
|
||||
// rs.minor.Hide()
|
||||
newgrid.NextRow()
|
||||
|
||||
rs.revision = gadgets.NewBasicCombobox(newgrid, "revision")
|
||||
rs.revision.Custom = func() {
|
||||
// rs.setTag()
|
||||
// rs.generateCmd()
|
||||
}
|
||||
// rs.revision.Hide()
|
||||
newgrid.NextRow()
|
||||
|
||||
// newgrid.NewLabel("new tag version")
|
||||
rs.newversion = newgrid.NewLabel("0.0.1")
|
||||
// rs.newversion.Hide()
|
||||
newgrid.NextRow()
|
||||
|
||||
rs.versionMessage = gadgets.NewBasicEntry(newgrid, "tag message")
|
||||
rs.versionMessage.Custom = func() {
|
||||
// rs.generateCmd()
|
||||
}
|
||||
// rs.versionMessage.Hide()
|
||||
newgrid.NextRow()
|
||||
|
||||
rs.versionCmdOutput = gadgets.NewOneLiner(newgrid, "tag cmd")
|
||||
// rs.versionCmdOutput.Hide()
|
||||
newgrid.NextRow()
|
||||
|
||||
rs.releaseVersion = newgrid.NewButton("tag and release new version", func() {
|
||||
rs.Disable()
|
||||
rs.pb.MergeToMaster()
|
||||
})
|
||||
// rs.releaseVersion.Hide()
|
||||
newgrid.NextRow()
|
||||
|
||||
newgrid.Margin()
|
||||
newgrid.Pad()
|
||||
}
|
||||
|
|
@ -1,73 +0,0 @@
|
|||
package repostatus
|
||||
|
||||
import (
|
||||
"go.wit.com/lib/gadgets"
|
||||
"go.wit.com/lib/protobuf/gitpb"
|
||||
|
||||
"go.wit.com/gui"
|
||||
)
|
||||
|
||||
type repoWindow struct {
|
||||
repo *gitpb.Repo // the repo protobuf
|
||||
win *gadgets.BasicWindow // the patches window
|
||||
stack *gui.Node // the top box set as vertical
|
||||
//shelf *gui.Node // the first box in the stack, set as horizontal
|
||||
//grid *gui.Node // the list of available patches
|
||||
//setgrid *gui.Node // the list of each patchset
|
||||
}
|
||||
|
||||
// todo: autogenerate these or make them standared 'gui' package functions
|
||||
// make this an go interface somehow
|
||||
|
||||
// is the window hidden right now?
|
||||
func (w *repoWindow) Hidden() bool {
|
||||
return w.win.Hidden()
|
||||
}
|
||||
|
||||
// switches between the window being visable or hidden on the desktop
|
||||
func (w *repoWindow) Toggle() {
|
||||
if w.Hidden() {
|
||||
w.Show()
|
||||
} else {
|
||||
w.Hide()
|
||||
}
|
||||
}
|
||||
|
||||
// hides the window completely
|
||||
func (w *repoWindow) Show() {
|
||||
w.win.Show()
|
||||
}
|
||||
|
||||
func (w *repoWindow) Hide() {
|
||||
w.win.Hide()
|
||||
}
|
||||
|
||||
// should be the first box/widget in the window
|
||||
// greys out the window to the user
|
||||
func (w *repoWindow) Disable() {
|
||||
w.stack.Disable()
|
||||
}
|
||||
|
||||
func (w *repoWindow) Enable() {
|
||||
w.stack.Enable()
|
||||
}
|
||||
|
||||
// you can only have one of these
|
||||
func MakeRepoWindow(repo *gitpb.Repo) *repoWindow {
|
||||
pw := new(repoWindow)
|
||||
|
||||
// sync.Once()
|
||||
pw.win = gadgets.RawBasicWindow("Patcheset for " + repo.GetGoPath())
|
||||
pw.win.Make()
|
||||
|
||||
pw.stack = pw.win.Box().NewBox("bw vbox", false)
|
||||
// me.reposwin.Draw()
|
||||
pw.win.Custom = func() {
|
||||
// sets the hidden flag to false so Toggle() works
|
||||
pw.win.Hide()
|
||||
}
|
||||
|
||||
// grid := pw.stack.NewGrid("", 0, 0)
|
||||
|
||||
return pw
|
||||
}
|
||||
Loading…
Reference in New Issue