guireleaser/findNext.go

// This is a simple example
package main

import (
	"fmt"

	"go.wit.com/log"

	"go.wit.com/lib/protobuf/gitpb"
)

var findCounter int
var findFix bool = false
var findOk bool = true

func checkDeps(repo *gitpb.Repo) error {
	if repo.GoDeps == nil {
		return fmt.Errorf("%s has GoDeps == nil", repo.GetGoPath())
	}
	all := repo.GoDeps.All()
	for all.Scan() {
		dep := all.Next()
		// log.Info(repo.GetGoPath(), dep.GoPath, dep.Version)

		// check if the package in question is waiting for another package to publish
		found := me.forge.FindByGoPath(dep.GoPath)
		if found == nil {
			return fmt.Errorf("%s has dep == nil", repo.GetGoPath(), dep.GoPath)
		}
		all := me.found.SortByFullPath()
		for all.Scan() {
			check := all.Next()
			if found.GetGoPath() == check.GetGoPath() {
				// this package is waiting on other packages to publish
				return fmt.Errorf("%s is waiting on %s", repo.GetGoPath(), found.GetGoPath())
			}
		}
		// found package isn't being published. is the version correct?
		// never check this? we are done?
		/*
			if found.GetLastTag() == dep.Version {
				// everything is normal
			} else {
				return fmt.Errorf("%s version mismatch on %s (%s vs %s)", repo.GetGoPath(), found.GetGoPath(), found.GetLastTag(), dep.Version)
			}
		*/
	}
	// everything might be cool?
	return nil
}

// trys to figure out if there is still something to update
// todo: redo this logic as it is terrible
// rename this findNext()
func findNext() bool {
	findCounter = 0
	all := me.found.SortByFullPath()
	for all.Scan() {
		check := all.Next()
		if check.GetMasterBranchName() != check.GetCurrentBranchName() {
			log.Info("YOU MUST BE ON THE MASTER BRANCH", check.GetGoPath())
			continue
		}
		if check.IsDirty() {
			log.Info("CAN NOT RELEASE DIRTY REPO", check.GetGoPath())
			continue
		}
		if alreadyDone(check) {
			log.Info("findNext() alreadyDone. WHY IS THIS STILL CHECKING?", check.GetGoPath())
			continue
		}
		log.Info("CHECKING:", check.GetGoPath())
		// _, err := check.RunVerboseOnError([]string{"go-mod-clean", "--strict"})
		_, err := check.RunQuiet([]string{"go-mod-clean", "--smart"})
		if err != nil {
			log.Info("FAILED: findNext() go-mod-clean --smart", check.GetGoPath(), err)
			continue
		}

		findCounter += 1
		if !check.ParseGoSum() {
			log.Info("ParseGoSum() failed", check.GetGoPath())
			log.Info("ParseGoSum() failed", check.GetGoPath())
			log.Info("ParseGoSum() failed", check.GetGoPath())
			continue
		}

		/*
			if err := me.forge.CleanGoDepsCheckOk(check); err != nil {
				log.Info("CleanGoDepsCheckOk() failed", check.GetGoPath(), err)
				log.Info("CleanGoDepsCheckOk() failed", check.GetGoPath(), err)
				continue
			}
		*/

		/*
			if err := checkDeps(check); err != nil {
				log.Info("CHECK DEPS FAILED", check.GetGoPath(), err)
				log.Info("CHECK DEPS FAILED", check.GetGoPath(), err)
				log.Info("CHECK DEPS FAILED", check.GetGoPath(), err)
				continue
			} else {
				log.Info("Might be ok?", check.GetGoPath())
			}
		*/
		fixGodeps(check)
		/*
			} else {
				log.Info("SKIPPING FIX", check.GetGoPath())
				log.Info("SKIPPING FIX", check.GetGoPath())
				log.Info("SKIPPING FIX", check.GetGoPath())
			}
		*/

		if err := me.forge.FinalGoDepsCheckOk(check, argv.Verbose); err != nil {
			// if err := me.forge.FinalGoDepsCheckOk(check, false); err != nil {
			log.Info("FinalGoDepsCheckOk() repo=", check.GetGoPath(), "err:", err)
			log.Info("CHECKING END:", check.GetGoPath())
			log.Info("")
			continue
		}
		log.Info("GOOD TO GO ON", check.GetGoPath())
		setCurrentRepo(check, "should be good to release", "pretty sure")
		return true
	}
	if findCounter == 0 {
		log.Info("NOTHING TO UPDATE. findCounter =", findCounter, "found len =", me.found.Len())
		if me.found.Len() == 0 {
			okExit("")
		}
	} else {
		log.Info("me.current is nil findCounter =", findCounter, "so set findFix =", findFix)
	}
	log.Info("tried to findNext() but not sure what to do next counter =", findCounter, "findFix =", findFix)
	setCurrentRepo(nil, "findNext found nothing", "crap")
	me.release.status.SetText("ALL DONE?")
	return false
}

// tries to fix the go.mod and go.sum files
func fixGodeps(check *gitpb.Repo) bool {
	var good bool = true

	check.GoDeps = nil

	if result, err := check.RunQuiet([]string{"go-mod-clean", "--strict"}); err != nil {
		for _, line := range result.Stdout {
			log.Warn("stdout:", line)
		}
		for _, line := range result.Stderr {
			log.Warn("stderr:", line)
		}
		return false
	}
	if check.ParseGoSum() {
		return true
	} else {
		log.Info("ParseGoSum() failed but go-mod-clean --strict worked", check.GetGoPath())
		return false
	}
	// skip primative ones
	if check.GetGoPrimitive() {
		if check.Exists("go.sum") {
			log.Info("fixGoDeps() has go.sum but says it is primitive", check.GetGoPath())
			return false
		}
		log.Info("fixGoDeps() skipping primitive", check.GetGoPath())
		return true
	}
	log.Printf("current repo %s go dependancy count: %d\n", check.GetGoPath(), check.GoDepsLen())
	log.Printf("current repo %s go dependancy count: %d\n", check.GetGoPath(), check.GoDepsLen())
	log.Printf("current repo %s go dependancy count: %d\n", check.GetGoPath(), check.GoDepsLen())
	deps := check.GoDeps.SortByGoPath()
	for deps.Scan() {
		depRepo := deps.Next()
		// log.Info("found dep", depRepo.GetGoPath())
		if me.forge.Config.IsReadOnly(depRepo.GetGoPath()) {
			log.Info("IsReadOnly = true", depRepo.GetGoPath())
			continue
		} else {
			// log.Info("IsReadOnly = false", depRepo.GetGoPath())
		}
		found := me.forge.FindByGoPath(depRepo.GetGoPath())
		if found == nil {
			log.Info("not found:", depRepo.GetGoPath())
			continue
		}
		log.Printf("%-48s  dep ver=%10s repo ver=%10s target ver=%10s\n", found.GetGoPath(), depRepo.GetVersion(), found.GetMasterVersion(), found.GetTargetVersion())
		if depRepo.GetVersion() != found.GetMasterVersion() {
			log.Printf("%-48s  %10s (gitpb depRepo)\n", depRepo.GetGoPath(), depRepo.GetVersion())
			log.Printf("%-48s  %10s (gitpb found)\n", found.GetGoPath(), found.GetMasterVersion())
			cmd := []string{"go", "get", depRepo.GetGoPath() + "@latest"}
			check.RunVerbose(cmd)
		}
	}
	return good
}

func setCurrentRepo(check *gitpb.Repo, s string, note string) bool {
	me.current = check
	if check == nil {
		me.release.repo.SetText("")
		me.release.version.SetText("")
		me.release.releaseVersionB.SetText("nope")
		me.release.version.SetText("badver")
	} else {
		me.release.repo.SetText(check.GetGoPath())
		me.release.version.SetText(check.GetTargetVersion())
		me.release.releaseVersionB.SetText("release version " + check.GetTargetVersion())
		me.release.version.SetText(check.GetTargetVersion())
	}
	me.release.status.SetText(s)
	me.release.notes.SetText(note)
	me.release.openrepo.Enable()

	return true
}