gitpb/reloadBranches.go

package gitpb

import (
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"unicode/utf8"

	"go.wit.com/lib/gui/shell"
	"go.wit.com/log"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

// TODO: make this report the error somewhere
// This is supposed to check all the branches to make sure
// they are the same. that was originally what this was for
// now I think it's jsut probably dumb old code that doesn't
// need to be here

// actually, this is to attempt to verify absolutely everything
// is pushed upstream before doing a rm -rf ~/go/src
// TODO: revisit this code in the autotypist later
func (repo *Repo) CheckBranches() bool {
	var hashCheck string
	var perfect bool = true
	all := repo.GetBranches()
	path := filepath.Join(repo.FullPath, ".git/refs/")
	for _, b := range all {
		parts := strings.Split(b, "/")
		rdir := "heads"
		if len(parts) == 2 {
			rdir = "remotes"
		}
		fullfile := filepath.Join(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" {
			// assume HEAD is always a valid branch
			// log.Info("skip HEAD. always valid branch name", 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)
		r := shell.PathRunLog(repo.GetFullPath(), cmd, INFO)
		if r.Error != nil {
			log.Log(WARN, "CheckBranches() git show error:", r.Error)
		}
		// git show -s --format=%ci <hash> will give you the time
		// log.Log(REPO, fullfile)
		if hash == hashCheck {
			// log.Info("notsure why this git show is here", hash)
		} else {
			log.Printf("UNKNOWN BRANCH %-50s %s %s %s\n", repo.GetFullPath(), r.Stdout, cmd, b)
			perfect = false
		}
	}
	return perfect
}

func (repo *Repo) GetBranches() []string {
	var all []string
	var heads []string
	var remotes []string
	heads = ListFiles(filepath.Join(repo.GetFullPath(), "/.git/refs/heads"))
	remotes = ListFiles(filepath.Join(repo.GetFullPath(), "/.git/refs/remotes"))

	all = heads

	all = append(all, remotes...)

	// for _, branch := range all {
	//	log.Info("getBranches()", branch)
	// }
	return all
}

// goes in one directory so it gets remote branch names
// old code. todo: modernize it
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
}

// forge doesn't want a remote user branch
// this will make sure the user branch is only local
func (repo *Repo) checkUserBranch() error {
	ubn := repo.GetUserBranchName()
	log.Info("user branch name:", ubn, repo.GetGoPath())
	if repo.GitConfig == nil {
		return fmt.Errorf("GitConfig == nil")
	}

	for _, l := range repo.GitConfig.Local {
		log.Info("local branch name:", l.Name)
	}

	return nil
}

func (repo *Repo) ExamineBranches() *GitTag {
	var hashCheck string
	all := repo.GetBranches()
	path := filepath.Join(repo.FullPath, ".git/refs/")
	for _, b := range all {
		parts := strings.Split(b, "/")
		rdir := "heads"
		if len(parts) == 2 {
			rdir = "remotes"
		}
		fullfile := filepath.Join(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" {
			// assume HEAD is always a valid branch
			// log.Info("skip HEAD. always valid branch name", 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)
		r := shell.PathRunLog(repo.GetFullPath(), cmd, INFO)
		if r.Error != nil {
			log.Log(WARN, "CheckBranches() git show error:", r.Error)
		}
		// git show -s --format=%ci <hash> will give you the time
		// log.Log(REPO, fullfile)
		if hash == hashCheck {
			// log.Info("notsure why this git show is here", hash)
		} else {
			log.Printf("UNKNOWN BRANCH %-50s %s %s %s\n", repo.GetFullPath(), r.Stdout, cmd, b)
			tag := new(GitTag)
			tag.Refname = b
			tag.Hash = hash
			if len(r.Stdout) > 0 {
				tagtime := parseDateRFC3339(r.Stdout[0])
				tag.Creatordate = timestamppb.New(tagtime)
			}
			return tag
		}
	}
	return nil
}