api change

.gitignore

@@ -3,4 +3,4 @@ go.mod
 go.sum
 /files/*
 /work/*
-go-clone
+go-clone*

Makefile

@@ -1,14 +1,14 @@
 VERSION = $(shell git describe --tags)
 BUILDTIME = $(shell date +%Y.%m.%d_%H%M)
 
-run: build
-	./go-clone --version
+run: install
+	go-clone --version
 
 vet:
 	@GO111MODULE=off go vet
 	@echo this go binary package builds okay
 
-no-gui: build
+no-gui: install build-darwin build-windows
 	./go-clone --no-gui
 
 build: goimports
@@ -16,11 +16,16 @@ build: goimports
 		-ldflags "-X main.VERSION=${VERSION} -X main.BUILDTIME=${BUILDTIME} -X gui.GUIVERSION=${VERSION}"
 
 build-darwin:
-	GOOS=darwin GOARCH=amd64 GO111MODULE=off go build -v -o go-clone-darwin \
+	GOOS=darwin GOARCH=amd64 GO111MODULE=off go build -v -o go-clone-darwin.x86 \
 		-ldflags "-X main.VERSION=${VERSION} -X main.BUILDTIME=${BUILDTIME} -X gui.GUIVERSION=${VERSION}"
+
+build-darwin-arm64:
+	GOOS=darwin GOARCH=arm64 GO111MODULE=off go build -v -o go-clone-darwin.arm \
+		-ldflags "-X main.VERSION=${VERSION} -X main.BUILDTIME=${BUILDTIME} -X gui.GUIVERSION=${VERSION}"
+
 build-windows:
-	GOOS=windows GOARCH=amd64 GO111MODULE=off go build -v go-clone.exe \
-		-ldflags "-X main.VERSION=${VERSION} -X main.BUILDTIME=${BUILDTIME} -X gui.GUIVERSION=${VERSION}"
+	GOOS=windows GOARCH=amd64 GO111MODULE=off go build -v -o go-clone.exe \
+		-ldflags "-X main.VERSION=v0.7.46 -X main.BUILDTIME=2025.02.22_0643 -X gui.GUIVERSION=v0.7.46"
 
 install: goimports
 	GO111MODULE=off go install \
@@ -45,7 +50,9 @@ nocui: build
 	./go-clone --gui nocui
 
 clean:
-	-rm go-clone
+	rm -f go.*
+	-rm go-clone*
+	go-mod-clean purge
 
 # this will test the golang.org/x -> googlesource override
 git-clone:

argv.go

@@ -1,5 +1,10 @@
 package main
 
+import (
+	"fmt"
+	"os"
+)
+
 /*
 	this parses the command line arguements
 
@@ -12,10 +17,10 @@ type args struct {
 	Repo      string `arg:"positional"                     help:"go import path"`
 	AutoWork  bool   `arg:"--work"       default:"false"   help:"recreate the go.work file"`
 	DryRun    bool   `arg:"--dry-run"                      help:"show what would be run"`
-	Recursive bool   `arg:"--recursive"  default:"false"   help:"recursively clone all dependencies"`
-	Pull      bool   `arg:"--git-pull"   default:"false"   help:"run 'git pull'"`
-	Build     bool   `arg:"--build"      default:"true"    help:"try to build it after clone"`
-	Install   bool   `arg:"--install"    default:"false"   help:"try to install it after clone"`
+	Recursive bool   `arg:"--recursive"  default:"true"    help:"recursively clone all dependencies"`
+	Build     bool   `arg:"--build"                        help:"try to build it after clone"`
+	Install   bool   `arg:"--install"                      help:"try to install it after clone"`
+	Ignore    bool   `arg:"--ignore"     default:"false"   help:"ignore weird clone errors from non-standard repos"`
 	// Fetch     bool   `arg:"--git-fetch"      default:"false" help:"run 'git fetch' on all your repos"`
 }
 
@@ -25,15 +30,24 @@ func (args) Version() string {
 
 func (a args) Description() string {
 	return `
-git clone go repositories
+git clone go repositories recursively
 
 Examples:
-	go-clone go.wit.com/apps/go-clone              # simply try to git clone this
-	go-clone --recursive go.wit.com/apps/go-clone  # recursively clone all the dependencies
-	go-clone --auto-work go.wit.com/apps/go-clone  # if you are using a go.work file, recreate the go.work file
-	go-clone --go-reset                            # recreate every go.mod and go.sum file
-	go-clone --git-pull                            # run 'git pull' in every repo
-	go-clone --build                               # build every binary package
-	go-clone --install                             # install every binary package
+	go-clone go.wit.com/apps/go-clone              # 'git clone' go-clone
 `
 }
+
+func (a args) DoAutoComplete(argv []string) {
+	switch argv[0] {
+	case "checkout":
+		fmt.Println("user devel master ")
+	case "--recursive":
+		fmt.Println("true false")
+	default:
+		if argv[0] == ARGNAME {
+			// list the subcommands here
+			fmt.Println("--dry-run --recursive --work")
+		}
+	}
+	os.Exit(0)
+}

clone.go

@@ -2,14 +2,62 @@ package main
 
 import (
 	"errors"
+	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 
-	"go.wit.com/lib/gui/shell"
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
 )
 
+/*
+# to support distributed 'git bug'
+
+# create a new user:
+git bug user new -e "jcarr@wit.com" -n "Jeff Carr"
+
+git pull origin +refs/bugs/\*:refs/bugs/\*
+git pull origin +refs/identities/\*:refs/identities/\*
+
+git show-ref | grep refs/bugs/
+
+git log refs/bugs/<some-id>
+
+git config --add remote.origin.fetch '+refs/bugs/*:refs/bugs/*'
+git config --add remote.origin.fetch '+refs/identities/*:refs/identities/*'
+
+git config --get-all remote.origin.fetch
+
+[remote "origin"]
+	url = ...
+	fetch = +refs/heads/*:refs/remotes/origin/*
+	fetch = +refs/bugs/*:refs/bugs/*
+	fetch = +refs/identities/*:refs/identities/*
+
+# remove the caches
+rm -rf .git/git-bug
+
+# rebuild the cache with any command
+git bug user
+
+*/
+
+// CleanRepoURL removes http://, https://, and .git suffix from the given URL if present.
+func CleanRepoURL(url string) string {
+	// Trim protocol prefix
+	if strings.HasPrefix(url, "http://") {
+		url = strings.TrimPrefix(url, "http://")
+	} else if strings.HasPrefix(url, "https://") {
+		url = strings.TrimPrefix(url, "https://")
+	}
+
+	// Trim trailing .git
+	url = strings.TrimSuffix(url, ".git")
+
+	return url
+}
+
 func clone(gopath string) (*gitpb.Repo, error) {
 	// if the user defined a repo, attempt to download it now
 	if gopath == "" {
@@ -17,32 +65,28 @@ func clone(gopath string) (*gitpb.Repo, error) {
 		// user probably wants to --recursive on current working dir
 		return nil, errors.New("gopath was blank")
 	}
+	gopath = CleanRepoURL(gopath)
 	os.Setenv("REPO_AUTO_CLONE", "true")
 	// pb, _ := forge.NewGoPath(gopath)
-	check := forge.Repos.FindByGoPath(gopath)
+	check := forge.FindAnyPath(filepath.Join(forge.Config.ReposDir, gopath))
 	if check != nil {
-		if check.IsValid() {
+		if check.IsValidDir() {
 			// repo already exists and is valid
 			return check, nil
 		}
 	}
-	pb, err := forge.Clone(gopath)
+	pb, err := forge.GoClone(gopath)
 	if err != nil {
 		log.Info("clone() could not download err:", err)
 		return nil, err
 	}
 
+	autoWork()
 	if err := makeValidGoSum(pb); err != nil {
 		return nil, err
 	}
 
-	// double check it actually downloaded
-	fullgitdir := filepath.Join(forge.GetGoSrc(), gopath, ".git")
-	if !shell.IsDir(fullgitdir) {
-		log.Info("repo cloned failed", filepath.Join(forge.GetGoSrc(), gopath))
-		return nil, errors.New(fullgitdir + " was not created")
-	}
-	log.Info("onward and upward")
+	log.Info("go-clone clone() onward and upward")
 	return pb, nil
 }
 
@@ -59,82 +103,94 @@ func recursiveClone(check *gitpb.Repo) error {
 	if check == nil {
 		return errors.New("repo was nil")
 	}
-	log.Info("STARTING RECURSIVE CLONE", check.GoPath)
-	log.Info("STARTING RECURSIVE CLONE", check.GoPath)
-	if check.GoPrimitive {
-		log.Info("repo is a primitive", check.GoPath)
-		// go primitive repos are "pure"
-		return nil
+	log.Info("STARTING RECURSIVE CLONE", check.Namespace)
+	log.Info("STARTING RECURSIVE CLONE", check.Namespace)
+	// if just cloned, parse the go.sum file for deps
+	if check.ParseGoSum() {
+	} else {
+		makeValidGoSum(check)
 	}
 
-	// if just cloned, parse the go.sum file for deps
-	check.ParseGoSum()
+	check.ReloadForce()
 
 	if check.GoDeps == nil {
-		log.Info("repo godeps == nil", check.GoPath)
-		return errors.New("go.sum is missing?")
+		log.Info("repo godeps == nil", check.Namespace)
+		return errors.New("no go deps?")
 	}
 
 	// probably this should never be 0 because GoPrimitive should have been true otherwise
 	if check.GoDeps.Len() == 0 {
-		log.Info("repo len(godeps) == 0", check.GoPath)
+		log.Info("repo len(godeps) == 0", check.Namespace)
 		return errors.New("go.sum never parsed?")
 	}
 
-	log.Info("deps for", check.GoPath, "len()", check.GoDeps.Len())
+	log.Info("deps for", check.Namespace, "len()", check.GoDeps.Len())
 	deps := check.GoDeps.SortByGoPath()
 	for deps.Scan() {
 		depRepo := deps.Next()
-		log.Info("download:", depRepo.GoPath)
-		_, err := clone(depRepo.GoPath)
+		log.Info("download:", depRepo.GetGoPath())
+		_, err := clone(depRepo.GetGoPath())
 		if err != nil {
-			log.Info("recursiveClone() could not download", depRepo.GoPath)
+			log.Info("recursiveClone() could not download", depRepo.GetGoPath())
 			log.Info("err:", err)
 			bad += 1
-			badmap[depRepo.GoPath] = err
+			badmap[depRepo.GetGoPath()] = err
 		} else {
-			log.Info("downloaded", depRepo.GoPath)
+			log.Info("downloaded", depRepo.GetGoPath())
 			good += 1
 		}
 	}
 	log.Info("got", good, "repos", "failed on", bad, "repos")
 	if bad != 0 {
+		log.Info("clone() ERROR len(badmap)", len(badmap))
 		for gopath, err := range badmap {
-			log.Info("clone() error", gopath, err)
+			log.Info("clone() ERROR", gopath, err)
 		}
+		if !argv.Ignore {
 			return errors.New("clone failed on some repos")
 		}
+	}
 	return nil
 }
 
 func makeValidGoSum(check *gitpb.Repo) error {
-	// first try to generate go.mod & go.sum with go-mod-clean
-	if err := check.ValidGoSum(); err != nil {
-		log.Info("try running go-mod-clean")
-		// update go.sum and go.mod
-		if err := check.RunStrict([]string{"go-mod-clean"}); err != nil {
+	// attempt to grab the notes
+	check.RunQuiet([]string{"git", "fetch", "origin", "refs/notes/*:refs/notes/*"})
+
+	if err := check.RunVerbose([]string{"forge", "list"}); err != nil {
 		log.Info("")
 		log.Info("Do you have go-mod-clean? Otherwise:")
 		log.Info("  go install go.wit.com/apps/go-mod-clean@latest")
 		log.Info("")
 	}
+
+	log.Info("try running go-mod-clean")
+	// update go.sum and go.mod
+	if err := check.RunVerbose([]string{"go-mod-clean", "lax"}); err != nil {
+		log.Info("")
+		log.Info("Do you have go-mod-clean? Otherwise:")
+		log.Info("  go install go.wit.com/apps/go-mod-clean@latest")
+		log.Info("")
 	}
+
+	if check.ParseGoSum() {
+		return nil
+	}
+
 	// if this fails, just use go mod
 	if err := check.ValidGoSum(); err != nil {
-		cmd := []string{"go", "mod", "init", check.GoPath}
+		cmd := []string{"go", "mod", "init", check.Namespace}
 		log.Info("try running", cmd)
-		if err := check.RunStrict(cmd); err != nil {
+		if _, err := check.RunQuiet(cmd); err != nil {
 			log.Info("go mod init failed", err)
 		}
-		if err := check.RunStrict([]string{"go", "mod", "tidy"}); err != nil {
+		if _, err := check.RunQuiet([]string{"go", "mod", "tidy"}); err != nil {
 			log.Info("go mod tidy failed", err)
 		}
 	}
-	if err := check.ValidGoSum(); err != nil {
-		// have to give up. can't recursive clone without go.mod file
-		log.Info("could not generate valid go.sum file")
-		return err
-	}
-	check.ParseGoSum()
+	if check.ParseGoSum() {
 		return nil
+	}
+
+	return fmt.Errorf("could not make a valid go.mod")
 }

gitPull.go

@@ -1,30 +0,0 @@
-package main
-
-import (
-	"go.wit.com/lib/gui/shell"
-	"go.wit.com/log"
-)
-
-func gitPull() {
-	log.Info("Total repositories:", forge.Repos.Len())
-	log.Info("Going to run git pull in each one. TODO: use rill here")
-	pull := []string{"git", "pull"}
-
-	var trycount, errcount int
-	repos := forge.Repos.SortByGoPath()
-	for repos.Scan() {
-		repo := repos.Next()
-		if argv.DryRun {
-			log.Info("git pull --dry-run", repo.GoPath)
-			continue
-		}
-		log.Info("git pull:", repo.FullPath)
-		trycount += 1
-		log.Info("actually run: git pull:", repo.GoPath)
-		if result := shell.PathRunRealtime(repo.FullPath, pull); result.Error != nil {
-			log.Info("git pull error:", result.Error)
-			errcount += 1
-		}
-	}
-	log.Info("Total repositories:", forge.Repos.Len(), "Total attempted:", trycount, "Errors:", errcount)
-}

main.go

@@ -4,6 +4,7 @@ import (
 	"os"
 
 	"go.wit.com/dev/alexflint/arg"
+	"go.wit.com/lib/gui/prep"
 	"go.wit.com/lib/protobuf/forgepb"
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
@@ -13,6 +14,8 @@ import (
 var VERSION string
 var BUILDTIME string
 
+var ARGNAME string = "go-clone"
+
 var pp *arg.Parser
 var forge *forgepb.Forge
 
@@ -20,19 +23,11 @@ var workingRepo *gitpb.Repo
 
 func main() {
 	log.Info("go-clone version", VERSION, "built on", BUILDTIME)
+	// command line parsing & handling
+	prep.Bash(ARGNAME, argv.DoAutoComplete) // todo: make this: prep.Bash(argv)
+
 	pp = arg.MustParse(&argv)
 
-	// for very new users or users unfamilar with the command line, this may help them
-	if argv.Repo == "help" || argv.Repo == "?" {
-		pp.WriteHelp(os.Stdout)
-		os.Exit(0)
-	}
-	if argv.Repo == "version" {
-		log.Info(argv.Version())
-		os.Exit(0)
-	}
-
-	// this package helps scan git repos
 	forge = forgepb.Init()
 
 	var err error
@@ -42,34 +37,40 @@ func main() {
 		badExit(err)
 	}
 	if argv.Recursive {
-		log.Info("STARTING RECURSIVE CLONE", workingRepo.GoPath)
+		log.Info("STARTING RECURSIVE CLONE", workingRepo.GetGoPath())
 		if err := recursiveClone(workingRepo); err != nil {
 			badExit(err)
 		}
 	}
 	autoWork()
 	if argv.Build {
+		log.Info("STARTING BUILD", workingRepo.GetGoPath())
+		/*
 			if err := makeValidGoSum(workingRepo); err != nil {
 				badExit(err)
 			}
 			if err := build(); err != nil {
 				badExit(err)
 			}
+		*/
+		if workingRepo.GetRepoType() == "binary" || workingRepo.GetRepoType() == "plugin" {
+			log.Info("build will probably fail", workingRepo.GetGoPath(), "is", workingRepo.GetRepoType())
 		}
-	if argv.Install {
-		// can only install binary or plugin go packages
-		if workingRepo.RepoType() == "binary" || workingRepo.RepoType() == "plugin" {
-			log.Info("install will probably fail", workingRepo.GoPath, "is", workingRepo.RepoType())
-		}
-		if err := forge.Install(workingRepo, nil); err != nil {
-			log.Warn("INSTALL FAILED", workingRepo.GoPath, err)
+		if err := forge.Build(workingRepo, nil); err != nil {
+			log.Warn("BUILD FAILED", workingRepo.GetGoPath(), err)
 			badExit(err)
 		}
 	}
-
-	if argv.Pull {
-		// run 'git pull' if argv --git-pull
-		gitPull()
+	if argv.Install {
+		log.Info("STARTING INSTALL", workingRepo.GetGoPath())
+		// can only install binary or plugin go packages
+		if workingRepo.GetRepoType() == "binary" || workingRepo.GetRepoType() == "plugin" {
+			log.Info("install will probably fail", workingRepo.GetGoPath(), "is", workingRepo.GetRepoType())
+		}
+		if err := forge.Install(workingRepo, nil); err != nil {
+			log.Warn("INSTALL FAILED", workingRepo.GetGoPath(), err)
+			badExit(err)
+		}
 	}
 	okExit("")
 }
@@ -85,6 +86,6 @@ func okExit(thing string) {
 
 func badExit(err error) {
 	log.Info("Total repositories:", forge.Repos.Len())
-	log.Info("Finished go-clone with error", err, forge.GetGoSrc())
+	log.Info("Finished go-clone with error", err, forge.Config.ReposDir)
 	os.Exit(-1)
 }

work.go

@@ -10,10 +10,10 @@ func autoWork() {
 	if !argv.AutoWork {
 		return
 	}
-	log.Info("About to re-create", forge.GetGoSrc()+"/go.work")
-	shell.PathRun(forge.GetGoSrc(), []string{"mv", "go.work", "go.work.last"})
+	log.Info("About to re-create", forge.Config.ReposDir+"/go.work")
+	shell.PathRun(forge.Config.ReposDir, []string{"mv", "go.work", "go.work.last"})
 	forge.MakeGoWork()
-	shell.PathRun(forge.GetGoSrc(), []string{"go", "work", "use"})
+	shell.PathRun(forge.Config.ReposDir, []string{"go", "work", "use"})
 	log.Info("")
 	log.Info("original go.work file saved as go.work.last")
 	log.Info("")