git: wrap upstream gitutil cli

Signed-off-by: CrazyMax <1951866+crazy-max@users.noreply.github.com>

Author: crazy-max

util/gitutil/gitutil.go

@@ -1,122 +1,125 @@
 package gitutil
 
 import (
-	"bytes"
 	"context"
 	"net/url"
-	"os"
-	"os/exec"
-	"path/filepath"
 	"strings"
 
 	"github.com/docker/buildx/util/osutil"
+	bkgitutil "github.com/moby/buildkit/util/gitutil"
 	"github.com/pkg/errors"
 )
 
-// Git represents an active git object
+// Git represents an active git object.
 type Git struct {
-	ctx     context.Context
-	wd      string
-	gitpath string
+	ctx context.Context
+	cli *bkgitutil.GitCLI
 }
 
 // Option provides a variadic option for configuring the git client.
-type Option func(b *Git)
+type Option func(*Git)
 
 // WithContext sets context.
 func WithContext(ctx context.Context) Option {
-	return func(b *Git) {
-		b.ctx = ctx
+	return func(g *Git) {
+		g.ctx = ctx
 	}
 }
 
 // WithWorkingDir sets working directory.
 func WithWorkingDir(wd string) Option {
-	return func(b *Git) {
-		b.wd = wd
+	return func(g *Git) {
+		if g.cli == nil {
+			g.cli = bkgitutil.NewGitCLI()
+		}
+		g.cli = g.cli.New(bkgitutil.WithDir(wd))
 	}
 }
 
-// New initializes a new git client
+// New initializes a new git client.
 func New(opts ...Option) (*Git, error) {
-	var err error
-	c := &Git{
+	g := &Git{
 		ctx: context.Background(),
+		cli: bkgitutil.NewGitCLI(),
 	}
 
 	for _, opt := range opts {
-		opt(c)
+		opt(g)
 	}
 
-	c.gitpath, err = gitPath(c.wd)
+	gitpath, err := gitPath(g.cli.Dir())
 	if err != nil {
 		return nil, err
 	}
 
-	return c, nil
+	g.cli = g.cli.New(
+		bkgitutil.WithGitBinary(gitpath),
+		bkgitutil.WithArgs("-c", "log.showSignature=false"),
+	)
+	return g, nil
 }
 
-func (c *Git) IsInsideWorkTree() bool {
-	out, err := c.Run("rev-parse", "--is-inside-work-tree")
+func (g *Git) IsInsideWorkTree() bool {
+	out, err := g.Run("rev-parse", "--is-inside-work-tree")
 	return out == "true" && err == nil
 }
 
-func (c *Git) IsDirty() bool {
-	out, err := c.Run("status", "--porcelain", "--ignored")
+func (g *Git) IsDirty() bool {
+	out, err := g.Run("status", "--porcelain", "--ignored")
 	return strings.TrimSpace(out) != "" || err != nil
 }
 
-func (c *Git) RootDir() (string, error) {
-	root, err := c.Run("rev-parse", "--show-toplevel")
+func (g *Git) RootDir() (string, error) {
+	root, err := g.cli.WorkTree(g.ctx)
 	if err != nil {
 		return "", err
 	}
 	return osutil.SanitizePath(root), nil
 }
 
-func (c *Git) GitDir() (string, error) {
-	dir, err := c.RootDir()
+func (g *Git) GitDir() (string, error) {
+	dir, err := g.cli.GitDir(g.ctx)
 	if err != nil {
 		return "", err
 	}
-	return filepath.Join(dir, ".git"), nil
+	return osutil.SanitizePath(dir), nil
 }
 
-func (c *Git) RemoteURL() (string, error) {
-	// Try default remote based on remote tracking branch
-	if remote, err := c.currentRemote(); err == nil && remote != "" {
-		if ru, err := c.clean(c.run("remote", "get-url", remote)); err == nil && ru != "" {
+func (g *Git) RemoteURL() (string, error) {
+	// Try default remote based on remote tracking branch.
+	if remote, err := g.currentRemote(); err == nil && remote != "" {
+		if ru, err := g.Run("remote", "get-url", remote); err == nil && ru != "" {
 			return stripCredentials(ru), nil
 		}
 	}
-	// Next try to get the remote URL from the origin remote first
-	if ru, err := c.clean(c.run("remote", "get-url", "origin")); err == nil && ru != "" {
+	// Next try to get the remote URL from the origin remote first.
+	if ru, err := g.Run("remote", "get-url", "origin"); err == nil && ru != "" {
 		return stripCredentials(ru), nil
 	}
-	// If that fails, try to get the remote URL from the upstream remote
-	if ru, err := c.clean(c.run("remote", "get-url", "upstream")); err == nil && ru != "" {
+	// If that fails, try to get the remote URL from the upstream remote.
+	if ru, err := g.Run("remote", "get-url", "upstream"); err == nil && ru != "" {
 		return stripCredentials(ru), nil
 	}
 	return "", errors.New("no remote URL found for either origin or upstream")
 }
 
-func (c *Git) FullCommit() (string, error) {
-	return c.clean(c.run("show", "--format=%H", "HEAD", "--quiet", "--"))
+func (g *Git) FullCommit() (string, error) {
+	return g.Run("show", "--format=%H", "HEAD", "--quiet", "--")
 }
 
-func (c *Git) ShortCommit() (string, error) {
-	return c.clean(c.run("show", "--format=%h", "HEAD", "--quiet", "--"))
+func (g *Git) ShortCommit() (string, error) {
+	return g.Run("show", "--format=%h", "HEAD", "--quiet", "--")
 }
 
-func (c *Git) Tag() (string, error) {
+func (g *Git) Tag() (string, error) {
 	var tag string
 	var err error
 	for _, fn := range []func() (string, error){
 		func() (string, error) {
-			return c.clean(c.run("tag", "--points-at", "HEAD", "--sort", "-version:creatordate"))
+			return g.Run("tag", "--points-at", "HEAD", "--sort", "-version:creatordate")
 		},
 		func() (string, error) {
-			return c.clean(c.run("describe", "--tags", "--abbrev=0"))
+			return g.Run("describe", "--tags", "--abbrev=0")
 		},
 	} {
 		tag, err = fn()
@@ -127,53 +130,34 @@ func (c *Git) Tag() (string, error) {
 	return tag, err
 }
 
-func (c *Git) Run(args ...string) (string, error) {
-	return c.clean(c.run(args...))
-}
-
-func (c *Git) run(args ...string) (string, error) {
-	var extraArgs = []string{
-		"-c", "log.showSignature=false",
-	}
-
-	args = append(extraArgs, args...)
-	cmd := exec.CommandContext(c.ctx, c.gitpath, args...)
-	if c.wd != "" {
-		cmd.Dir = c.wd
-	}
-
-	// Override the locale to ensure consistent output
-	cmd.Env = append(os.Environ(), "LC_ALL=C")
-
-	stdout := bytes.Buffer{}
-	stderr := bytes.Buffer{}
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-
-	if err := cmd.Run(); err != nil {
-		return "", errors.New(stderr.String())
-	}
-	return stdout.String(), nil
+func (g *Git) Run(args ...string) (string, error) {
+	return g.clean(g.cli.Run(g.ctx, args...))
 }
 
-func (c *Git) clean(out string, err error) (string, error) {
-	out = strings.ReplaceAll(strings.Split(out, "\n")[0], "'", "")
+func (g *Git) clean(dt []byte, err error) (string, error) {
+	out := strings.ReplaceAll(strings.Split(string(dt), "\n")[0], "'", "")
 	if err != nil {
-		err = errors.New(strings.TrimSuffix(err.Error(), "\n"))
+		msg := strings.TrimSuffix(err.Error(), "\n")
+		if stderr, ok := strings.CutPrefix(msg, "git stderr:\n"); ok {
+			if idx := strings.LastIndex(stderr, ": exit status "); idx != -1 {
+				stderr = stderr[:idx]
+			}
+			msg = strings.TrimSuffix(stderr, "\n")
+		}
+		err = errors.New(msg)
 	}
 	return out, err
 }
 
-func (c *Git) currentRemote() (string, error) {
-	symref, err := c.Run("symbolic-ref", "-q", "HEAD")
+func (g *Git) currentRemote() (string, error) {
+	symref, err := g.Run("symbolic-ref", "-q", "HEAD")
 	if err != nil {
 		return "", err
 	}
 	if symref == "" {
 		return "", nil
 	}
-	// git for-each-ref --format='%(upstream:remotename)'
-	remote, err := c.Run("for-each-ref", "--format=%(upstream:remotename)", symref)
+	remote, err := g.Run("for-each-ref", "--format=%(upstream:remotename)", symref)
 	if err != nil {
 		return "", err
 	}