repostatus/windowMerge.go

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")
	})
*/