path: root/common.go

package repostatus

import (
	"errors"
	"os"
	"path/filepath"
	"strings"
	"unicode"

	"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) {
	if !rs.Ready() {
		return "", false
	}

	return rs.getChanges(), 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) NoteChange(s string) {
	log.Log(REPOWARN, "NoteChange() got", rs.String(), s)
	rs.changed = true
	rs.changes += s + "\n"
}

// deprecate this. returns the gopath right now
func (rs *RepoStatus) String() string {
	// log.Warn("RepoStatus.String() is to be deprecated")
	return rs.path.String()
}

// returns the go path for the repo. "go.wit.com/apps/autotypist"
func (rs *RepoStatus) GoName() string {
	return rs.GoPath()
}

// not sure which name is easier to remember. probably this one
func (rs *RepoStatus) GoPath() string {
	return rs.goPath.String()
}

// full path
func (rs *RepoStatus) FullPath() string {
	return rs.realPath.String()
}

func (rs *RepoStatus) IsPrimitive() bool {
	if rs.primitive.String() == "true" {
		return true
	}
	return false
}

func (rs *RepoStatus) IsProtobuf() (bool, []string, error) {
	fullp, fullc, err := ScanForProtobuf(rs.Path())
	protos := make(map[string]string)
	protoc := make(map[string]string)
	var anyfound bool = false
	var allc []string
	for _, s := range fullp {
		filebase := filepath.Base(s)
		name := strings.TrimSuffix(filebase, ".proto")
		anyfound = true
		protos[name] = s
	}
	for pname, _ := range protos {
		var found bool = false
		for _, s := range fullc {
			cfilebase := filepath.Base(s)
			cname := strings.TrimSuffix(cfilebase, ".pb.go")
			protoc[cname] = s
			if cname == pname {
				found = true
				allc = append(allc, cfilebase)
			}
		}
		if found {
			// log.Info("found ok")
		} else {
			log.Info("missing compiled proto file:", pname + "pb.go")
			err = errors.New("compiled file " + pname + ".pb.go missing")
		}
	}
	return anyfound, allc, err
}

// returns the filesystem path to the repo
func (rs *RepoStatus) Path() string {
	if rs == nil {
		log.Warn("rs == nil")
		return ""
	}
	if rs.realPath == nil {
		log.Warn("rs.realPath == nil")
		return ""
	}
	return rs.realPath.String()
}

func (rs *RepoStatus) Show() {
	if !rs.Ready() {
		return
	}
	log.Log(CHANGE, "Show() window ready =", rs.ready)
	rs.window.Show()
}

func (rs *RepoStatus) Hide() {
	if !rs.Ready() {
		return
	}
	log.Log(CHANGE, "Hide() window ready =", rs.ready)
	rs.window.Hide()
}

func (rs *RepoStatus) Toggle() {
	if !rs.Ready() {
		return
	}
	log.Log(CHANGE, "Toggle() window ready =", rs.ready)
	if rs.window.Hidden() {
		rs.Show()
	} else {
		rs.Hide()
	}
}

func (rs *RepoStatus) Ready() bool {
	if rs == nil {
		return false
	}
	if rs.window == nil {
		return false
	}
	return rs.ready
}

func (rs *RepoStatus) IsGoLang() bool {
	if !rs.Ready() {
		return false
	}
	if rs.isGoLang.String() == "true" {
		return true
	}
	return false
}

// experiment to go package type
func (rs *RepoStatus) RepoType() string {
	if !rs.IsGoLang() {
		return ""
	}
	if !rs.Exists("go.mod") {
		return ""
	}
	os.Setenv("GO111MODULE", "off")
	err, output := rs.RunCmd([]string{"go", "list", "-f", "'{{if eq .Name \"main\"}}binary{{else}}library{{end}}'"})
	if err == nil {
		output = strings.Trim(output, "'")
		// log.Info("go package is:", output)
		return output
	}
	// log.Info("package is: unknown", err)
	return ""
}

func (rs *RepoStatus) BinaryName() string {
	// get the package name from the repo name
	path := rs.String()
	parts := strings.Split(path, "/")
	name := parts[len(parts)-1]
	return name
}

func (rs *RepoStatus) Build() bool {
	if !rs.IsGoLang() {
		return false
	}
	name := rs.BinaryName()
	// removes the binary if it already exists
	rs.RunCmd([]string{"rm", "-f", name})
	if rs.Exists(name) {
		log.Warn("file could not be removed filename =", name)
		return false
	}
	log.Info("need to build here", rs.String())
	// rs.RunCmd([]string{"go", "build", "-v", "-x"})
	rs.XtermBash([]string{"go", "build", "-v", "-x"})
	if rs.Exists(name) {
		log.Warn("build worked", name)
		return true
	}
	log.Warn("build failed", name)
	return false
}

func (rs *RepoStatus) GetTargetVersion() string {
	return rs.targetReleaseVersion.String()
}

func (rs *RepoStatus) GetCurrentVersion() string {
	return rs.currentVersion.String()
}

func (rs *RepoStatus) LastTag() string {
	return rs.lasttag.String()
}

func (rs *RepoStatus) IncrementVersion() bool {
	rs.incrementRevision()
	rs.EnableSelectTag()
	rs.setTag()
	newtag := "v" + rs.newversion.String()
	log.Log(REPOWARN, rs.GoPath(), "old version:", rs.LastTag(), "new version:", newtag)
	rs.targetReleaseVersion.SetText(newtag)
	return true
}

// TODO: run this through the sanity check!
func (rs *RepoStatus) SetTargetVersion(s string) {
	// todo: redo setTag to do increment logic
	// func (rs *RepoStatus) setTag() bool {
	rs.targetReleaseVersion.SetText(s)
}

func (rs *RepoStatus) IsPrivate() bool {
	if rs.private.String() == "true" {
		return true
	}
	return false
}

func (rs *RepoStatus) SetPrivate(b bool) {
	if b {
		rs.private.SetText("true")
	} else {
		rs.private.SetText("false")
	}
}

// returns a name for human consuption only
// todo: implement nicknames
func (rs *RepoStatus) Name() string {
	if rs.IsGoLang() {
		return rs.GoPath()
	}
	return rs.Path()
}

func trimNonNumericFromStart(s string) string {
	for i, r := range s {
		if unicode.IsDigit(r) {
			return s[i:]
		}
	}
	return ""
}

func (rs *RepoStatus) DebianReleaseVersion() string {
	lasttag := rs.GetLastTagVersion()
	newv := trimNonNumericFromStart(lasttag)
	if newv == "" {
		newv = "0.0"
		if lasttag != "" {
			newv += "-" + lasttag
		}
	}
	return newv
}

func (rs *RepoStatus) DebianCurrentVersion() string {
	cbversion := rs.GetCurrentBranchVersion()

	newv := trimNonNumericFromStart(cbversion)
	if newv == "" {
		newv = "0.0"
	}
	if rs.CheckDirty() {
		newv += "-dirty"
	}
	return newv
}