go-mod-clean/main.go

package main

import (
	"os"
	"strings"

	"go.wit.com/dev/alexflint/arg"
	"go.wit.com/lib/protobuf/forgepb"
	"go.wit.com/lib/protobuf/gitpb"
	"go.wit.com/log"
)

// sent via -ldflags
var VERSION string
var BUILDTIME string

var golangVersion string = "1.21"

var pp *arg.Parser
var forge *forgepb.Forge

// var check *gitpb.Repo
var configSave bool

func main() {
	var check *gitpb.Repo
	log.Info("go-mod-clean version", VERSION, "built on", BUILDTIME)
	pp = arg.MustParse(&argv)

	// load the ~/.config/forge/ config
	// this lets you configure repos you have read/write access too
	forge = forgepb.Init()

	// figure out what directory we are running in
	check = findPwdRepo()
	if check == nil {
		log.Info("this directory isn't in a golang project (not in ~/go/src nor a go.work file)")
		badExit(nil, nil)
	}

	// deletes all the git notes
	if argv.Purge {
		purgeNotes(check)
		okExit(check, "notes gone")
	}

	if argv.Restore {
		// attempt to restore from ~/go/pkg/mod/
		if err := restoreFromGoPkg(check); err != nil {
			badExit(check, err)
		}
		okExit(check, "go.mod and go.sum restored from ~/go/pkg/mod/")
	}

	if argv.Strict {
		if err := doStrict(check); err != nil {
			badExit(check, err)
		}
		okExit(check, "go.mod seems clean")
	}

	if err := doMain(check); err != nil {
		badExit(check, err)
	}
	if argv.Force {
		if err := doForce(check); err != nil {
			badExit(check, err)
		}
	} else {
		if err := doSmart(check); err != nil {
			badExit(check, err)
		}
	}

	if configSave {
		forge.ConfigSave()
	}

	log.Info("forge.FinalGoDepsCheck() worked :", check.GetGoPath())
	okExit(check, "go.sum seems clean")
}

func findPwdRepo() *gitpb.Repo {
	var check *gitpb.Repo
	// attempt to use the working directory
	// this is probably what happens most of the time
	pwd, _ := os.Getwd()
	if strings.HasPrefix(pwd, forge.GetGoSrc()) {
		gopath := strings.TrimPrefix(pwd, forge.GetGoSrc())
		gopath = strings.Trim(gopath, "/")
		log.Info("findRepo() trying gopath", gopath)
		check = forge.FindByGoPath(gopath)
		if check != nil {
			log.Info("findRepo() worked", check.GetGoPath())
			return check
		}
	}
	return nil
}

func saveAsMetadata(repo *gitpb.Repo) error {
	cname := repo.GetCurrentBranchName()
	if repo.GetGoPrimitive() {
		if err := repo.AutogenSave([]string{"go.mod"}, cname, true); err != nil {
			return err
		}
	} else {
		if err := repo.AutogenSave([]string{"go.mod", "go.sum"}, cname, true); err != nil {
			return err
		}
	}
	return nil
}

func doMain(repo *gitpb.Repo) error {
	if argv.Force {
		err := doForce(repo)
		return err
	}

	// if --force or --strict is not set, fall back to a "smart" guess
	// at what the user probably would want
	return doSmart(repo)
}