forge/doExamine.go

package main

import (
	"fmt"
	"slices"
	"strings"
	"time"

	"go.wit.com/lib/gui/shell"
	"go.wit.com/lib/protobuf/gitpb"
	"go.wit.com/log"
)

func doExamine() bool {
	me.found = new(gitpb.Repos)
	all := me.forge.Repos.SortByFullPath()
	for all.Scan() {
		repo := all.Next()
		if tag := repo.ExamineBranches(); tag != nil {
			me.found.AppendByGoPath(repo)
			// ctime := tag.Creatordate.AsTime()
			// dur := time.Since(ctime)
			// log.Printf("UNKNOWN BRANCH %-50s %s %4s %s\n", repo.GetFullPath(), tag.Hash, shell.FormatDuration(dur), tag.Refname)
			repo.CurrentTag = tag
		} else {
			repo.CurrentTag = nil
		}
	}
	if len(me.found.Repos) == 0 {
		return true
	}
	// slices.Reverse(me.found.Repos)
	slices.SortFunc(me.found.Repos, func(a, b *gitpb.Repo) int {
		atime := a.CurrentTag.Creatordate.AsTime()
		btime := b.CurrentTag.Creatordate.AsTime()
		if atime.Before(btime) {
			// log.Info("atime vs btime is 0", atime, btime)
			return 1
		}
		// log.Info("atime vs btime is 1", atime, btime)
		return -1
	})
	all = me.found.All()
	me.found = new(gitpb.Repos)
	for all.Scan() {
		repo := all.Next()
		if isNormal(repo) {
			continue
		}

		tag := repo.CurrentTag
		ctime := tag.Creatordate.AsTime()
		dur := time.Since(ctime)
		log.Printf("UNKNOWN BRANCH %-50s %s %4s %s\n", repo.GetFullPath(), tag.Hash, shell.FormatDuration(dur), tag.Refname)
		err := examineBranch(repo)
		if argv.Examine.Fix != nil {
			if err != nil {
				badExit(err)
			}
		}

		me.found.AppendByGoPath(repo)
	}
	me.forge.PrintHumanTableDirty(me.found)
	return false
}

func isNormal(repo *gitpb.Repo) bool {
	if repo.IsDirty() {
		return true
	}
	if repo.GetUserVersion() != repo.GetDevelVersion() {
		return true
	}
	return false
}

func examineBranch(repo *gitpb.Repo) error {
	dcount, err := showNotDevel(repo)
	if err != nil {
		return err
	}
	if repo.CurrentTag == nil {
		return fmt.Errorf("repo.CurrentTag == nil")
	}

	if repo.CurrentTag.Refname == "jcarr" {
		return requiresGitPush(repo, "jcarr")
	}

	if repo.CurrentTag.Refname == "origin/jcarr" {
		return requiresGitPush(repo, "jcarr")
	}

	err = fmt.Errorf("examineBranch() branch differs, but not sure how to fix it yet == %d", len(dcount))
	log.Info(err)
	return nil
}

func checkJcarr(repo *gitpb.Repo) int {
	b1 := countDiffObjects(repo, "jcarr", "origin/jcarr")
	b2 := countDiffObjects(repo, "origin/jcarr", "jcarr")
	log.Info("jcarr vs origin count", b1, b2)
	if b1 == 0 && b2 == 0 {
		return 0
	}
	if b1 != 0 {
		log.Info("jcarr vs origin count b1 != 0, b2 ==", b1, b2)
		log.Info("THIS MEANS THE LOCAL BRANCH NEEDS GIT PUSH TO ORIGIN BRANCH ==", b1, b2)
		return b1
	}
	if b2 != 0 {
		log.Info("jcarr vs origin count b2 != 0, b1 ==", b2, b1)
		return b2
	}
	return -1
}

func showNotDevel(repo *gitpb.Repo) ([]string, error) {
	var cmd []string
	cmd = append(cmd, "git")
	cmd = append(cmd, "log")
	cmd = append(cmd, "--format=\"%H\"")
	cmd = append(cmd, repo.CurrentTag.Hash)
	cmd = append(cmd, "--not")
	cmd = append(cmd, "devel")
	r, err := repo.RunStrictNew(cmd)
	if err != nil {
		log.Info("Error", cmd, err)
		return r.Stdout, err
	}
	if r == nil {
		log.Info("Error r == nil", cmd, err)
		return nil, fmt.Errorf("r == nil")
	}
	/*
		if len(r.Stdout) != 0 {
			for i, line := range r.Stdout {
				log.Info(i, line)
			}
		}
	*/
	return r.Stdout, nil
}

// count all objects only in branch1
func countDiffObjects(repo *gitpb.Repo, branch1, branch2 string) int {
	var cmd []string
	cmd = append(cmd, "git")
	cmd = append(cmd, "log")
	cmd = append(cmd, "--format=\"%H\"")
	cmd = append(cmd, branch1)
	cmd = append(cmd, "--not")
	cmd = append(cmd, branch2)
	r, err := repo.RunStrictNew(cmd)
	if err != nil {
		log.Info("Error", cmd, err)
		return -1
	}
	if r == nil {
		log.Info("Error r == nil", cmd, err)
		return -1
	}
	/*
		if len(r.Stdout) != 0 {
			for i, line := range r.Stdout {
				log.Info(i, line)
			}
		}
	*/
	log.Info("countDiffObjects()", cmd, len(r.Stdout), strings.Join(r.Stdout, " "))
	return len(r.Stdout)
}

// count all objects only in branch1
func gitPushStrict(repo *gitpb.Repo, branchName string) error {
	var cmd []string
	cmd = append(cmd, "git")
	cmd = append(cmd, "push")
	err := gitRun(repo, cmd)
	if err != nil {
		cmd = []string{"git", "whatchanged", repo.CurrentTag.Hash, "-1"}
		gitRun(repo, cmd)
	}
	return err
}

func gitPushStrictExit(repo *gitpb.Repo, branchName string) {
	err := gitPushStrict(repo, branchName)
	if err == nil {
		return
	}
	badExit(err)
}

func requiresGitPush(repo *gitpb.Repo, branchName string) error {
	b1 := countDiffObjects(repo, branchName, "origin/"+branchName)
	b2 := countDiffObjects(repo, "origin/"+branchName, branchName)
	log.Info("jcarr vs origin count", b1, b2)
	if b1 == 0 && b2 == 0 {
		return nil
	}
	if b1 != 0 {
		log.Info("jcarr vs origin count b1 != 0, b2 ==", b1, b2)
		log.Info("THIS MEANS THE LOCAL BRANCH NEEDS GIT PUSH TO ORIGIN BRANCH ==", b1)
		if argv.Examine.Fix != nil {
			return gitPushStrict(repo, branchName)
		}
		return nil
	}
	return nil
}

func gitRun(repo *gitpb.Repo, cmd []string) error {
	log.Info("Run:", repo.GetGoPath(), cmd)
	r, err := repo.RunStrictNew(cmd)
	if err != nil {
		log.Info("Error", cmd, err)
	}
	for _, line := range r.Stdout {
		log.Info(line)
	}
	for _, line := range r.Stderr {
		log.Info(line)
	}
	return err
}