gitpb/checkout.go

package gitpb

import (
	"fmt"
	"path/filepath"

	"go.wit.com/log"
)

func (repo *Repo) CheckoutMaster() bool {
	bName := repo.GetMasterBranchName()
	if repo.checkoutBranch(bName) {
		return true
	}
	return false
}

func (repo *Repo) CheckoutDevel() bool {
	bName := repo.GetDevelBranchName()
	if repo.checkoutBranch(bName) {
		repo.DevelBranchName = bName
		return true
		// switch ok
	}
	return false
}

func (repo *Repo) CheckoutUser() error {
	bName := repo.GetUserBranchName()
	// log.Info("attempting checkout user", repo.GetGoPath(), bName)
	err := repo.checkoutBranchNew(bName)
	if err != nil {
		log.Info("attempting checkout user error", repo.GetGoPath(), bName, err)
	}
	return err
}

func (repo *Repo) BranchExists(bName string) bool {
	// fixme after move to protobuf
	return true
}

func (repo *Repo) checkoutBranch(bName string) bool {
	if !repo.BranchExists(bName) {
		return false
	}
	if bName == "" {
		return false
	}
	if repo.CheckDirty() {
		log.Log(INFO, repo.GetFullPath(), "is dirty")
		return false
	}
	cmd := []string{"git", "checkout", bName}
	r := repo.Run(cmd)
	if r.Error != nil {
		log.Log(INFO, "git checkout error:", r.Error)
	}

	realname := repo.GetCurrentBranchName()
	realversion := repo.GetCurrentBranchVersion()
	log.Log(INFO, repo.GetFullPath(), "realname =", realname, "realversion =", realversion)

	if realname != bName {
		log.Log(INFO, "git checkout failed", repo.GetFullPath(), bName, "!=", realname)
		return false
	}
	return true
}

func (repo *Repo) checkoutBranchNew(branch string) error {
	if branch == "" || branch == "uerr" {
		log.Info("forge.gitpb logic err. branch name was:", branch)
		return nil
	}
	if repo.IsDirty() {
		// never change repos on dirty branches
		return nil
	}
	// log.Info("forge.gitpb look for branch name was:", branch, repo.GetGoPath())

	if repo.Exists(filepath.Join(".git/refs/heads", branch)) {
		var err error
		// there is already a local user branch
		cmd := []string{"git", "checkout", branch}
		if _, err = repo.RunVerboseOnError(cmd); err == nil {
			return nil
		}
		log.Log(INFO, "git checkout error:", err)
	}

	if repo.Exists(filepath.Join(".git/refs/remote/origin", branch)) {
		var err error
		// there is a remote user branch
		// todo: check other remotes
		cmd := []string{"git", "checkout", branch}
		if _, err = repo.RunVerboseOnError(cmd); err == nil {
			return nil
		}
		log.Log(INFO, "git checkout error:", err)
	}

	if repo.GetCurrentBranchName() != repo.GetDevelBranchName() {
		return fmt.Errorf("repo must be on devel branch %s", repo.GetGoPath())
	}

	// log.Info("forge.gitpb try to create", branch, repo.GetGoPath())

	// create the branch from devel
	cmd := []string{"git", "branch", branch}
	if _, err := repo.RunVerboseOnError(cmd); err != nil {
		return err
	}
	cmd = []string{"git", "checkout", branch}
	if _, err := repo.RunVerboseOnError(cmd); err != nil {
		return err
	}
	return nil
}