path: root/doClean.go

// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
// Use of this source code is governed by the GPL 3.0

package main

import (
	"errors"
	"fmt"
	"path/filepath"

	"go.wit.com/lib/fhelp"
	"go.wit.com/lib/protobuf/forgepb"
	"go.wit.com/lib/protobuf/gitpb"
	"go.wit.com/log"
)

func checkRemoteBranches(repo *gitpb.Repo) error {
	if err := repo.ReloadCheck(); err != nil {
		log.Info("need to reload", repo.FullPath)
	}
	if repo.VerifyRemoteAndLocalBranches(repo.GetDevelBranchName()) {
	} else {
		return log.Errorf("remote devel is out of sync with local: todo: git pull or git fetch")
	}
	if repo.VerifyRemoteAndLocalBranches(repo.GetMasterBranchName()) {
	} else {
		return log.Errorf("remote master is out of sync with local: todo: git pull or git fetch")
	}
	return nil
}

/*
if repo.DevelSubsetOfUser() {
	repo.DeleteDevel()
}

if repo.UserSubsetOfDevel() {
	repo.DeleteUser()
}

if repo.MasterSubsetOfDevel() {
}

if "user".IsSubset("devel") {
if repo("user") >= repo("devel") {

if repo.FirstIsIncludedInSecond("devel", "user") {

if repo.IsSubset("user", "devel") {
	// delete user
} else {
	// figure out what to do
}
*/

// reverts all repos back to the original master branches
// automatically deletes local devel and user branches
func doClean() error {
	setForgeMode(forgepb.ForgeMode_CLEAN)

	/*
		if argv.Clean.Verify != nil {
			stats := me.forge.RillRepos(checkRemoteBranches)
			for path, stat := range stats {
				if stat.Err == nil {
					continue
				}
				dur := stat.End.Sub(stat.Start)
				if dur > time.Second {
					log.Infof("%s checkRemoteBranches() took a long time (%s) (err=%v)\n", path, shell.FormatDuration(dur), stat.Err)
				}
			}
			// log.Infof("%-60s, %-60s %v %s\n", stat.Start, stat.End.String(), dur, path)
			// log.Infof("%-30v %s %v\n", dur, path, stat.Err)
			return nil
		}
	*/

	// fix this to work, then delete all the other options for "forge clean'
	if err := me.forge.DoAllCheckoutMaster(); err != nil {
		// badExit(err)
	}

	all := me.forge.Repos.SortByFullPath()
	for all.Scan() {
		repo := all.Next()
		if repo.GetCurrentBranchName() != repo.GetMasterBranchName() {
			continue
		}
		if repo.IsDirty() {
			continue
		}

		// when publishing, clean out the details of that if it's still there
		if repo.GetTargetVersion() != "" {
			repo.SetTargetVersion("")
		}

		// try to delete user
		if err := doRepoCleanUser(repo); err != nil {
			if err == ErrorBranchUnique {
				if argv.Clean.Fix != nil {
					bname := repo.GetUserBranchName()
					s := fmt.Sprintf("delete this odd user (%s) branch %s?", bname, repo.FullPath)
					if fhelp.QuestionUser(s) {
						repo.RunVerbose([]string{"git", "branch", "-D", bname})
						// repo.RunVerbose([]string{"git", "checkout", bname})
					}
				}
			} else {
				log.Info(repo.GetGoPath(), err)
			}
		}

		// try to delete devel
		doRepoCleanDevel(repo)
	}

	found := gitpb.NewRepos()

	total := 0
	// find all repos that aren't "clean"
	all = me.forge.Repos.SortByFullPath()
	for all.Scan() {
		repo := all.Next()
		total += 1

		// find repos not on master branch
		if repo.GetCurrentBranchName() != repo.GetMasterBranchName() {
			found.AppendByFullPath(repo)
			continue
		}

		// find dirty repos
		if repo.IsDirty() {
			found.AppendByFullPath(repo)
			continue
		}

		// find repos that still have a local user branch
		if repo.IsLocalBranch(repo.GetUserBranchName()) {
			found.AppendByFullPath(repo)
			continue
		}

		// find repos that still have a local devel branch
		if repo.IsLocalBranch(repo.GetDevelBranchName()) {
			found.AppendByFullPath(repo)
			continue
		}
	}

	// display all the repos that aren't clean to the user
	log.Printf("\n") // padding for now
	if argv.Verbose {
		me.forge.PrintHumanTableDirty(found)
	} else {
		me.forge.PrintHumanTable(found)
	}
	log.Printf("\n") // padding for now

	var hmm int
	hmm = found.Len()
	if hmm == 0 {
		log.Printf("%d repos are not clean\n", hmm)
	} else {
		log.Info("All repos are clean", total, hmm)
	}
	return nil
}

/*
	func doesLocalBranchExist(repo *gitpb.Repo, branch string) bool {
		return repo.Exists(filepath.Join(".git/refs/heads", branch))
	}
*/
func doRepoCleanDevel(repo *gitpb.Repo) error {
	if !repo.IsLocalBranch(repo.GetDevelBranchName()) {
		// there is no local branch named 'devel'
		return nil
	}

	if repo.GetCurrentBranchName() != repo.GetMasterBranchName() {
		return log.Errorf("%s not on master branch:", repo.GetFullPath())
	}
	if repo.IsDirty() {
		return log.Errorf("%s is dirty:", repo.GetFullPath())
	}
	if err := justDeleteTheDevelBranchAlready(repo); err != nil {
		log.Info("justDeleteTheDevel() err", repo.GetGoPath(), err)
		if argv.Clean.Fix != nil {
			bname := repo.GetDevelBranchName()
			s := fmt.Sprintf("delete this odd devel (%s) branch %s?", bname, repo.FullPath)
			if fhelp.QuestionUser(s) {
				repo.RunVerbose([]string{"git", "branch", "-D", bname})
				// repo.RunVerbose([]string{"git", "checkout", bname})
			}
		}
		return err
	}
	return nil
}

// removes all local user branches
func doRepoCleanUser(repo *gitpb.Repo) error {
	if repo.IsDirty() {
		return nil
	}

	bruser := repo.GetUserBranchName()
	brdevel := repo.GetDevelBranchName()

	if repo.IsBranchRemote(bruser) {
		log.Info("forge is designed to always have local only user branches", bruser)
		return fmt.Errorf("forge is designed to always have local only user branches")
	}

	if !repo.IsLocalBranch(bruser) {
		// there is no local user branch
		return nil
	}

	// will you loose work if you delete your user branch?
	// if DevelBranchExists()
	//	then if UserBranchCommits exist in DevelBranch
	//		DeleteUserBranch is safe
	if repo.IsLocalBranch(brdevel) {
		b1 := repo.CountDiffObjects(bruser, "refs/heads/"+brdevel) // should be zero
		if b1 == 0 {
			// every user branch exists in devel. delete user branch
			cmd := []string{"git", "branch", "-D", bruser}
			// log.Info("USER IS IN DEVEL", repo.GetGoPath(), cmd)
			_, err := repo.RunVerboseOnError(cmd)
			return err
		}
	}

	brmaster := repo.GetMasterBranchName()

	// will you loose work if you delete your user branch?
	// if master branch exists()
	//	then if all user commits exist in master
	//		delete user branch is safe
	if repo.IsLocalBranch(brmaster) {
		b1 := repo.CountDiffObjects(bruser, "refs/heads/"+brmaster) // should be zero
		if b1 == 0 {
			cmd := []string{"git", "branch", "-D", bruser}
			// log.Info("USER IS IN DEVEL", repo.GetGoPath(), cmd)
			_, err := repo.RunVerboseOnError(cmd)
			return err
		}
	}

	if argv.Clean.Fix != nil {
	}

	return ErrorBranchUnique
}

var ErrorBranchUnique error = errors.New("branch has unique commits")

// if you call this, there is no going back. no checks anymore. nothing
// it deletes the 'devel' branch. git branch -D "devel". END OF STORY
func justDeleteTheDevelBranchAlready(repo *gitpb.Repo) error {
	branch := repo.GetDevelBranchName()
	remote := filepath.Join("origin", branch)

	if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
		if repo.IsDevelRemote() {
			// just make sure the remote & local branches are the same
			return repo.DeleteLocalDevelBranch()
		}
	}

	// check against remote if it exists
	if repo.IsDevelRemote() {
		b1 := repo.CountDiffObjects(branch, remote) // should be zero
		if b1 == 0 {
			cmd := []string{"git", "branch", "-D", repo.GetDevelBranchName()}
			// log.Info("DEVEL IS IN REMOTE", repo.GetGoPath(), cmd)
			_, err := repo.RunVerboseOnError(cmd)
			return err
		}
		cmd := []string{"git", "push"}
		log.Info("DEVEL LOCAL NEEDS GIT PUSH TO REMOTE", repo.GetGoPath(), cmd)
		err := repo.RunVerbose(cmd)
		return err
	}

	// remote doesn't exist, check against master
	master := repo.GetMasterBranchName()
	b1 := repo.CountDiffObjects(branch, "refs/heads/"+master) // should be zero
	if b1 == 0 {
		cmd := []string{"git", "branch", "-D", repo.GetDevelBranchName()}
		// log.Info("DEVEL IS IN REMOTE", repo.GetGoPath(), cmd)
		_, err := repo.RunVerboseOnError(cmd)
		return err
	}
	cmd := []string{"git", "merge something somehow"}
	log.Info("devel local, remote and master branches are wrong", repo.GetGoPath(), cmd, b1)
	// _, err := repo.RunVerbose(cmd)
	return nil
}

func doGitReset() {
	all := me.forge.Repos.SortByFullPath()
	for all.Scan() {
		repo := all.Next()
		if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
			// log.Info("is readonly", repo.GetGoPath())
			if repo.CheckDirty() {
				log.Info("is readonly and dirty", repo.GetGoPath())
				cmd := []string{"git", "reset", "--hard"}
				repo.RunRealtime(cmd)
			}
		} else {
			// log.Info("is not readonly", repo.GetGoPath())
		}
	}
}