Use new git command

Author: tothszabi

gitclone/checkout.go

@@ -5,8 +5,8 @@ package gitclone
 import (
 	"fmt"
 
-	"github.com/bitrise-io/go-utils/command/git"
 	"github.com/bitrise-io/go-utils/log"
+	"github.com/bitrise-io/go-utils/v2/git"
 	"github.com/bitrise-steplib/steps-git-clone/gitclone/bitriseapi"
 )
 
@@ -65,7 +65,7 @@ func NewParameterValidationError(msg string) error {
 
 // checkoutStrategy is the interface an actual checkout strategy implements
 type checkoutStrategy interface {
-	do(gitCmd git.Git, fetchOptions fetchOptions, fallback fallbackRetry) error
+	do(gitFactory git.Factory, fetchOptions fetchOptions, fallback fallbackRetry) error
 
 	// getBuildTriggerRef returns ref to the commit/branch/tag that triggered the build.
 	// For simple checkout strategies the returned ref will be HEAD (after running 'do').
@@ -250,7 +250,7 @@ func createCheckoutStrategy(checkoutMethod CheckoutMethod, cfg Config, patchFile
 
 			return checkoutPRMergeRef{
 				params: *params,
-				fallbackCheckout: func(gitCmd git.Git) error {
+				fallbackCheckout: func(gitFactory git.Factory) error {
 					log.Warnf("Using manual merge strategy with PR source branch")
 
 					manualMergeFallbackFetchOpts := selectFetchOptions(CheckoutPRManualMergeMethod, cfg.CloneDepth, cfg.FetchTags, cfg.UpdateSubmodules, len(cfg.SparseDirectories) != 0)
@@ -267,7 +267,7 @@ func createCheckoutStrategy(checkoutMethod CheckoutMethod, cfg Config, patchFile
 					}
 
 					// PR merge branch checkout falls back to PR manual merge strategy using the PR source branch
-					return fallbackManualMergeWithSourceBranch.do(gitCmd, manualMergeFallbackFetchOpts, manualMergeFallbackFallback)
+					return fallbackManualMergeWithSourceBranch.do(gitFactory, manualMergeFallbackFetchOpts, manualMergeFallbackFallback)
 				},
 			}, nil
 		}
@@ -314,7 +314,7 @@ func createCheckoutStrategy(checkoutMethod CheckoutMethod, cfg Config, patchFile
 
 			return checkoutCommit{
 				params: *params,
-				fallbackCheckout: func(gitCmd git.Git) error {
+				fallbackCheckout: func(gitFactory git.Factory) error {
 					log.Warnf("Using commit checkout strategy with PR source branch")
 
 					if cfg.Branch == "" || cfg.Commit == "" {
@@ -339,7 +339,7 @@ func createCheckoutStrategy(checkoutMethod CheckoutMethod, cfg Config, patchFile
 						params: *params,
 					}
 
-					return commitCheckoutFallbackCheckoutMethod.do(gitCmd, commitCheckoutFallbackFetchOpts, commitCheckoutFallbackFallback)
+					return commitCheckoutFallbackCheckoutMethod.do(gitFactory, commitCheckoutFallbackFetchOpts, commitCheckoutFallbackFallback)
 				},
 			}, nil
 		}

gitclone/checkout_helper.go

@@ -5,9 +5,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/bitrise-io/go-utils/command"
-	"github.com/bitrise-io/go-utils/command/git"
 	"github.com/bitrise-io/go-utils/log"
+	"github.com/bitrise-io/go-utils/v2/git"
 )
 
 type fetchOptions struct {
@@ -38,7 +37,7 @@ const (
 	refsHeadsPrefix = "refs/heads/"
 )
 
-func fetch(gitCmd git.Git, remote string, ref string, options fetchOptions) error {
+func fetch(gitFactory git.Factory, remote string, ref string, options fetchOptions) error {
 	var opts []string
 	opts = append(opts, jobsFlag)
 
@@ -67,11 +66,11 @@ func fetch(gitCmd git.Git, remote string, ref string, options fetchOptions) erro
 		branch = strings.TrimPrefix(ref, refsHeadsPrefix)
 	}
 
-	if err := runner.RunWithRetry(func() *command.Model {
-		return gitCmd.Fetch(opts...)
+	if err := runner.RunWithRetry(func() git.Template {
+		return gitFactory.Fetch(opts...)
 	}); err != nil {
 		return handleCheckoutError(
-			listBranches(gitCmd),
+			listBranches(gitFactory),
 			fetchFailedTag,
 			err,
 			"Fetching repository has failed",
@@ -82,15 +81,15 @@ func fetch(gitCmd git.Git, remote string, ref string, options fetchOptions) erro
 	return nil
 }
 
-func checkoutWithCustomRetry(gitCmd git.Git, arg string, retry fallbackRetry) error {
-	if cErr := runner.Run(gitCmd.Checkout(arg)); cErr != nil {
+func checkoutWithCustomRetry(gitFactory git.Factory, arg string, retry fallbackRetry) error {
+	if cErr := runner.Run(gitFactory.Checkout(arg)); cErr != nil {
 		if retry != nil {
 			log.Warnf("Checkout failed (%s): %v", arg, cErr)
-			if err := retry.do(gitCmd); err != nil {
+			if err := retry.do(gitFactory); err != nil {
 				return err
 			}
 
-			return runner.Run(gitCmd.Checkout(arg))
+			return runner.Run(gitFactory.Checkout(arg))
 		}
 
 		return fmt.Errorf("checkout failed (%s): %w", arg, cErr)
@@ -99,21 +98,21 @@ func checkoutWithCustomRetry(gitCmd git.Git, arg string, retry fallbackRetry) er
 	return nil
 }
 
-func forceCheckoutRemoteBranch(gitCmd git.Git, remote string, branchRef string, fetchTraits fetchOptions) error {
+func forceCheckoutRemoteBranch(gitFactory git.Factory, remote string, branchRef string, fetchTraits fetchOptions) error {
 	branch := strings.TrimPrefix(branchRef, refsHeadsPrefix)
-	if err := fetch(gitCmd, remote, branchRef, fetchTraits); err != nil {
+	if err := fetch(gitFactory, remote, branchRef, fetchTraits); err != nil {
 		wErr := fmt.Errorf("fetch branch %s: %w", branchRef, err)
 		return fmt.Errorf("%v: %w", wErr, errors.New("please make sure the branch still exists"))
 	}
-	
+
 	remoteBranch := fmt.Sprintf("%s/%s", remote, branch)
 	// -B: create the branch if it doesn't exist, reset if it does
 	// The latter is important in persistent environments because shallow-fetching only fetches 1 commit,
 	// so the next run would see unrelated histories after shallow-fetching another single commit.
-	err := runner.Run(gitCmd.Checkout("-B", branch, remoteBranch))
+	err := runner.Run(gitFactory.Checkout("-B", branch, remoteBranch))
 	if err != nil {
 		return handleCheckoutError(
-			listBranches(gitCmd),
+			listBranches(gitFactory),
 			checkoutFailedTag,
 			err,
 			"Checkout has failed",
@@ -124,15 +123,15 @@ func forceCheckoutRemoteBranch(gitCmd git.Git, remote string, branchRef string,
 	return nil
 }
 
-func mergeWithCustomRetry(gitCmd git.Git, arg string, retry fallbackRetry) error {
-	if mErr := runner.Run(gitCmd.Merge(arg)); mErr != nil {
+func mergeWithCustomRetry(gitFactory git.Factory, arg string, retry fallbackRetry) error {
+	if mErr := runner.Run(gitFactory.Merge(arg)); mErr != nil {
 		if retry != nil {
 			log.Warnf("Merge failed (%s): %v", arg, mErr)
-			if err := retry.do(gitCmd); err != nil {
+			if err := retry.do(gitFactory); err != nil {
 				return err
 			}
 
-			return runner.Run(gitCmd.Merge(arg))
+			return runner.Run(gitFactory.Merge(arg))
 		}
 
 		wErr := fmt.Errorf("merge failed (%s): %w", arg, mErr)
@@ -142,8 +141,8 @@ func mergeWithCustomRetry(gitCmd git.Git, arg string, retry fallbackRetry) error
 	return nil
 }
 
-func detachHead(gitCmd git.Git) error {
-	if err := runner.Run(gitCmd.Checkout("--detach")); err != nil {
+func detachHead(gitFactory git.Factory) error {
+	if err := runner.Run(gitFactory.Checkout("--detach")); err != nil {
 		return newStepError(
 			"detach_head_failed",
 			fmt.Errorf("detaching head failed: %w", err),
@@ -154,6 +153,6 @@ func detachHead(gitCmd git.Git) error {
 	return nil
 }
 
-func deleteRef(gitCmd git.Git, ref string) error {
-	return runner.Run(gitCmd.UpdateRef("-d", ref))
+func deleteRef(gitFactory git.Factory, ref string) error {
+	return runner.Run(gitFactory.UpdateRef("-d", ref))
 }

gitclone/checkout_method_pr_auto_diff.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/bitrise-io/go-utils/command/git"
 	"github.com/bitrise-io/go-utils/log"
+	"github.com/bitrise-io/go-utils/v2/git"
 )
 
 // PRDiffFileParams are parameters to check out a Merge/Pull Request (when a diff file is available)
@@ -35,28 +35,28 @@ type checkoutPRDiffFile struct {
 	patchFile string
 }
 
-func (c checkoutPRDiffFile) do(gitCmd git.Git, fetchOptions fetchOptions, fallback fallbackRetry) error {
+func (c checkoutPRDiffFile) do(gitFactory git.Factory, fetchOptions fetchOptions, fallback fallbackRetry) error {
 	destBranchRef := refsHeadsPrefix + c.params.DestinationBranch
-	if err := fetch(gitCmd, originRemoteName, destBranchRef, fetchOptions); err != nil {
+	if err := fetch(gitFactory, originRemoteName, destBranchRef, fetchOptions); err != nil {
 		return fmt.Errorf("failed to fetch base branch: %w", err)
 	}
 
-	if err := checkoutWithCustomRetry(gitCmd, c.params.DestinationBranch, fallback); err != nil {
+	if err := checkoutWithCustomRetry(gitFactory, c.params.DestinationBranch, fallback); err != nil {
 		return err
 	}
 
-	if err := runner.Run(gitCmd.Apply(c.patchFile)); err != nil {
+	if err := runner.Run(gitFactory.Apply(c.patchFile)); err != nil {
 		log.Warnf("Could not apply patch (%s): %v", c.patchFile, err)
 		log.Warnf("Falling back to manual merge...")
 
-		if err := c.params.PRManualMergeStrategy.do(gitCmd, fetchOptions, fallback); err != nil {
+		if err := c.params.PRManualMergeStrategy.do(gitFactory, fetchOptions, fallback); err != nil {
 			return fmt.Errorf("fallback failed for applying patch (%s): %v", c.patchFile, err)
 		}
 
 		return nil
 	}
 
-	return detachHead(gitCmd)
+	return detachHead(gitFactory)
 }
 
 func (c checkoutPRDiffFile) getBuildTriggerRef() string {

gitclone/checkout_method_pr_auto_merge_branch.go

@@ -3,9 +3,9 @@ package gitclone
 import (
 	"fmt"
 	"strings"
-	
-	"github.com/bitrise-io/go-utils/command/git"
+
 	"github.com/bitrise-io/go-utils/log"
+	"github.com/bitrise-io/go-utils/v2/git"
 )
 
 // PRMergeRefParams are parameters to check out a Merge/Pull Request's merge ref (the result of merging the 2 branches)
@@ -38,20 +38,20 @@ type checkoutPRMergeRef struct {
 	fallbackCheckout fallbackCheckoutFunc
 }
 
-type fallbackCheckoutFunc func(gitCmd git.Git) error
+type fallbackCheckoutFunc func(gitFactory git.Factory) error
 
-func (c checkoutPRMergeRef) do(gitCmd git.Git, fetchOpts fetchOptions, fallback fallbackRetry) error {
-	if err := c.performCheckout(gitCmd, fetchOpts, fallback); err != nil {
+func (c checkoutPRMergeRef) do(gitFactory git.Factory, fetchOpts fetchOptions, fallback fallbackRetry) error {
+	if err := c.performCheckout(gitFactory, fetchOpts, fallback); err != nil {
 		if c.fallbackCheckout != nil {
 			log.Warnf("Failed to checkout PR merge branch: %s", err)
-			return c.fallbackCheckout(gitCmd)
+			return c.fallbackCheckout(gitFactory)
 		}
 		return err
 	}
 	return nil
 }
 
-func (c checkoutPRMergeRef) performCheckout(gitCmd git.Git, fetchOpts fetchOptions, fallback fallbackRetry) error {
+func (c checkoutPRMergeRef) performCheckout(gitFactory git.Factory, fetchOpts fetchOptions, fallback fallbackRetry) error {
 	// https://git-scm.com/book/en/v2/Git-Internals-The-Refspec
 	refSpec := fmt.Sprintf("%s:%s", c.remoteMergeRef(), c.localMergeRef())
 
@@ -62,33 +62,33 @@ func (c checkoutPRMergeRef) performCheckout(gitCmd git.Git, fetchOpts fetchOptio
 	// This is caused by the remote merge and head branches being "force-pushed" by GitHub.
 	// To solve it we remove merge and head branch refs.
 	// $ git update-ref -d refs/remotes/pull/7/merge
-	err := deleteRef(gitCmd, c.localMergeRef())
+	err := deleteRef(gitFactory, c.localMergeRef())
 	if err != nil {
 		return fmt.Errorf("failed to delete ref: %w", err)
 	}
 
 	// $ git update-ref -d refs/remotes/pull/7/head
 	// If the ref does not exist, the command still exits with 0 exit code.
-	err = deleteRef(gitCmd, c.localHeadRef())
+	err = deleteRef(gitFactory, c.localHeadRef())
 	if err != nil {
 		return fmt.Errorf("failed to delete ref: %w", err)
 	}
 
 	//$ git fetch origin refs/remotes/pull/7/merge:refs/pull/7/merge
-	err = fetch(gitCmd, originRemoteName, refSpec, fetchOpts)
+	err = fetch(gitFactory, originRemoteName, refSpec, fetchOpts)
 	if err != nil {
 		return fmt.Errorf("failed to fetch merge ref: %w", err)
 	}
 
 	// Also fetch the PR head ref because the step exports outputs based on the PR head commit (see output.go)
 	// $ git fetch origin refs/remotes/pull/7/head:refs/pull/7/head
-	err = c.fetchPRHeadRef(gitCmd, fetchOpts)
+	err = c.fetchPRHeadRef(gitFactory, fetchOpts)
 	if err != nil {
 		return err
 	}
 
 	// $ git checkout refs/remotes/pull/7/merge
-	err = checkoutWithCustomRetry(gitCmd, c.localMergeRef(), nil)
+	err = checkoutWithCustomRetry(gitFactory, c.localMergeRef(), nil)
 	if err != nil {
 		return err
 	}
@@ -116,7 +116,7 @@ func (c checkoutPRMergeRef) remoteHeadRef() string {
 	return fmt.Sprintf("refs/%s", c.params.HeadRef)
 }
 
-func (c checkoutPRMergeRef) fetchPRHeadRef(gitCmd git.Git, fetchOpts fetchOptions) error {
+func (c checkoutPRMergeRef) fetchPRHeadRef(gitFactory git.Factory, fetchOpts fetchOptions) error {
 	refSpec := fmt.Sprintf("%s:%s", c.remoteHeadRef(), c.localHeadRef())
-	return fetch(gitCmd, originRemoteName, refSpec, fetchOpts)
+	return fetch(gitFactory, originRemoteName, refSpec, fetchOpts)
 }

gitclone/checkout_method_pr_manual.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/bitrise-io/go-utils/command/git"
 	"github.com/bitrise-io/go-utils/log"
+	"github.com/bitrise-io/go-utils/v2/git"
 )
 
 // PRManualMergeParams are parameters to check out a Merge Request using manual merge
@@ -58,14 +58,14 @@ type checkoutPRManualMerge struct {
 	params PRManualMergeParams
 }
 
-func (c checkoutPRManualMerge) do(gitCmd git.Git, fetchOptions fetchOptions, fallback fallbackRetry) error {
+func (c checkoutPRManualMerge) do(gitFactory git.Factory, fetchOptions fetchOptions, fallback fallbackRetry) error {
 	// Fetch and checkout destinations branch
 	destBranchRef := refsHeadsPrefix + c.params.DestinationBranch
-	if err := forceCheckoutRemoteBranch(gitCmd, originRemoteName, destBranchRef, fetchOptions); err != nil {
+	if err := forceCheckoutRemoteBranch(gitFactory, originRemoteName, destBranchRef, fetchOptions); err != nil {
 		return fmt.Errorf("failed to fetch base branch: %w", err)
 	}
 
-	commitHash, err := runner.RunForOutput(gitCmd.Log("%H"))
+	commitHash, err := runner.RunForOutput(gitFactory.Log("%H"))
 	if err != nil {
 		log.Errorf("log commit hash: %v", err)
 	}
@@ -76,7 +76,7 @@ func (c checkoutPRManualMerge) do(gitCmd git.Git, fetchOptions fetchOptions, fal
 		remoteName = forkRemoteName
 
 		// Add fork remote
-		if err := runner.Run(gitCmd.RemoteAdd(forkRemoteName, c.params.SourceRepoURL)); err != nil {
+		if err := runner.Run(gitFactory.RemoteAdd(forkRemoteName, c.params.SourceRepoURL)); err != nil {
 			return fmt.Errorf("adding remote fork repository failed (%s): %w", c.params.SourceRepoURL, err)
 		}
 
@@ -86,15 +86,15 @@ func (c checkoutPRManualMerge) do(gitCmd git.Git, fetchOptions fetchOptions, fal
 
 	// Fetch and merge
 	sourceBranchRef := refsHeadsPrefix + c.params.SourceBranch
-	if err := fetch(gitCmd, remoteName, sourceBranchRef, fetchOptions); err != nil {
+	if err := fetch(gitFactory, remoteName, sourceBranchRef, fetchOptions); err != nil {
 		return fmt.Errorf("failed to fetch compare branch: %w", err)
 	}
 
-	if err := mergeWithCustomRetry(gitCmd, c.params.SourceMergeArg, fallback); err != nil {
+	if err := mergeWithCustomRetry(gitFactory, c.params.SourceMergeArg, fallback); err != nil {
 		return err
 	}
 
-	return detachHead(gitCmd)
+	return detachHead(gitFactory)
 }
 
 func (c checkoutPRManualMerge) getBuildTriggerRef() string {