path: root/currentVersions.go

package gitpb

// runs git, parses output
// types faster than you can

import (
	"errors"
	"fmt"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"
	"unicode"

	"go.wit.com/log"
)

func (repo *Repo) reloadVersions() {
	repo.setMasterVersion()
	repo.setDevelVersion()
	repo.setUserVersion()
	repo.setLastTag()
	repo.setCurrentBranchName()
	repo.setCurrentBranchVersion()
}

func (repo *Repo) setMasterVersion() {
	bname := repo.GetMasterBranchName()
	v, err := repo.gitVersionByName(bname)
	/*
		count := repo.LenGitTags()
		log.Info(repo.GetGoPath(), "tag count", count)
		repo.UpdateGitTags()
		count = repo.LenGitTags()
		log.Info(repo.GetGoPath(), "tag count", count)
	*/

	if err == nil {
		repo.MasterVersion = v
	} else {
		// this is dumb
		// log.Log(WARN, "gitpb.GitMasterVersion() error:", err)
	}
}

func (repo *Repo) setDevelVersion() {
	bname := repo.GetDevelBranchName()
	v, err := repo.gitVersionByName(bname)
	if err == nil {
		repo.DevelVersion = v
	} else {
		// log.Log(WARN, "gitpb.GitDevelVersion() error:", err)
		repo.DevelVersion = ""
	}
}

func (repo *Repo) setUserVersion() {
	bname := repo.GetUserBranchName()
	if !repo.Exists(filepath.Join(".git/refs/heads", bname)) {
		// the user branch does not exist at this time
		repo.UserVersion = ""
		return
	}
	v, err := repo.gitVersionByName(bname)
	if err == nil {
		repo.UserVersion = v
	} else {
		// log.Log(WARN, "gitpb.GitUserVersion() error:", err)
		repo.UserVersion = ""
	}
}

// this is used often. probably move everything to this
// returns things like
// v0.2.2
// v0.22.39-1-g2141737
// v0.23-dirty
// mystuff
func (repo *Repo) GetCurrentVersion() string {
	if repo == nil {
		return ""
	}
	bver := repo.GetCurrentBranchVersion()
	if repo.CheckDirty() {
		bver = bver + "-dirty"
	}
	return bver
}

func (repo *Repo) gitDescribeByHash(hash string) (string, error) {
	if hash == "" {
		return "", errors.New("hash was blank")
	}
	r, err := repo.RunQuiet([]string{"git", "describe", "--tags", hash})
	out := strings.Join(r.Stdout, "\n")
	if err != nil {
		// log.Warn("not in a git repo or bad hash?", err, repo.GetGoPath())
		return "gitpb err", err
	}
	return out, err
}

// this should get the most recent tag
func (repo *Repo) GetLastTagVersion() string {
	return repo.LastTag
}

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

func (repo *Repo) DebianCurrentVersion(buildnum int) string {
	curver := repo.GetCurrentBranchVersion()

	// takes off the GO 'v'
	curver = trimNonNumericFromStart(curver)
	if curver == "" {
		// need something for debian or it won't accept it
		curver = "0.0"
	}

	// .deb files don't like "v0.0.90-1-g778234j"
	// so remove the end so it's "0.0.90-1"
	parts := strings.Split(curver, "-")
	if len(parts) == 1 {
		curver = curver + "-0" // patches then show up as "-1", "-2", etc
	}
	if len(parts) > 1 {
		curver = strings.Join(parts[0:2], "-")
	}

	// removing the checks for '0' and doing this everytime
	// TODO: verify apt behavior without it (probably not worth it however. always add +bXXX
	// TODO: verify "+b3" vs "+b20" behavior
	curver += fmt.Sprintf("+b%d", buildnum)

	return curver
}

func (repo *Repo) gitVersionByName(name string) (string, error) {
	name = strings.TrimSpace(name)

	if name == "" {
		// git will return the current tag
		cmd := []string{"git", "describe", "--tags"}
		r, err := repo.RunQuiet(cmd)
		output := strings.Join(r.Stdout, "\n")
		if err != nil {
			// log.Log(WARN, repo.FullPath, "gitDescribeByName() ", output, err, cmd)
			return "", err
		}
		return strings.TrimSpace(output), nil
	}
	if !repo.IsBranch(name) {
		// branch does not exist
		return "", errors.New("gitDescribeByName() git fatal: Not a valid object name: " + name)
	}
	cmd := []string{"git", "describe", "--tags", name}
	result, err := repo.RunQuiet(cmd)
	output := strings.Join(result.Stdout, "\n")
	if err != nil {
		//log.Log(WARN, "cmd =", cmd)
		//log.Log(WARN, "err =", err)
		//log.Log(WARN, "output (might have worked with error?) =", output)
		//log.Log(WARN, "not in a git repo or bad tag?", repo.GetGoPath())
		return "", result.Error
	}

	return strings.TrimSpace(output), nil
}

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

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(INFO, "normalizeVersion() s =", clean)
	return clean
}

// golang doesn't seem to really support v0.1 and seems to want v0.1.0
// TODO: confirm this. (as of Dec 2024, this appears to be the case -- jcarr )
//
//	personally I hope GO stays with the vX.X.X version scheme. it's a good system.
//
// if the version is "57", convert it to v0.0.57 for GO
func splitVersion(version string) (a, b, c string) {
	tmp := normalizeVersion(version)
	parts := strings.Split(tmp, ".")
	switch len(parts) {
	case 1:
		return "", "", parts[0] // converts someone using version "57" to "v0.0.57"
	case 2:
		return parts[0], parts[1], "" // converts someone using version "1.2" to "v1.2.0"
	default:
		return parts[0], parts[1], parts[2]
	}
}

func splitInts(ver string) (int, int, int) {
	major, minor, revision := splitVersion(ver)
	a, _ := strconv.Atoi(major)
	b, _ := strconv.Atoi(minor)
	c, _ := strconv.Atoi(revision)
	return a, b, c
}

// changes the target minor. v0.1.3 becomes v0.2.0
func (repo *Repo) IncrementTargetMinor() {
	lasttag := repo.GetLastTag()
	// var major, minor, revision string
	major, minor, revision := splitInts(lasttag)

	minor += 1
	revision = 0

	newa := strconv.Itoa(major)
	newb := strconv.Itoa(minor)
	newc := strconv.Itoa(revision)

	repo.SetTargetVersion("v" + newa + "." + newb + "." + newc)
}

// changes the target revision. v0.1.3 becomes v0.1.4
func (repo *Repo) IncrementTargetRevision() {
	// first try just going from the last tag
	repo.incrementRevision(repo.GetLastTag())

	if !isNewerVersion(repo.GetMasterVersion(), repo.GetTargetVersion()) {
		// log.Printf("tag error. master version() %s was higher than target version %s\n", repo.GetMasterVersion(), repo.GetTargetVersion())
		repo.incrementRevision(repo.GetMasterVersion())
	}
	/*
		if !isNewerVersion(repo.GetLastTag(), repo.GetTargetVersion()) {
			log.Printf("last tag versn() %s is higher than target version %s\n", repo.GetLastTag(), repo.GetTargetVersion())
			return false
		}
		if !isNewerVersion(repo.GetMasterVersion(), repo.GetTargetVersion()) {
			log.Printf("master version() %s is higher than target version %s\n", repo.GetMasterVersion(), repo.GetTargetVersion())
			return false
		}
		return true
	*/
}

func (repo *Repo) incrementRevision(lasttag string) {
	major, minor, revision := splitInts(lasttag)

	revision += 1

	newa := strconv.Itoa(major)
	newb := strconv.Itoa(minor)
	newc := strconv.Itoa(revision)

	repo.SetTargetVersion("v" + newa + "." + newb + "." + newc)
}

// makes sure the new target version to be released is greater
// than the current master version
// this is just a sanity check, but this can actually fail sometimes
// if other things failed terribly in prior cases
// gitpb v.3.1.4
// A = major = 3
// B = minor = 1
// C = revision = 4
func isNewerVersion(oldver, newver string) bool {
	olda, oldb, oldc := splitInts(oldver)
	newa, newb, newc := splitInts(newver)

	if newa < olda {
		return false
	}
	if newb < oldb {
		return false
	}
	if newc <= oldc {
		return false
	}
	return true
}