go.fuchsia.dev/infra@v0.0.0-20240507153436-9b593402251b/cmd/submodule_update/gitutil/git.go

// Copyright 2023 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Package gitutil is a wrapper layer for handing calls to the git tool.
package gitutil

import (
	"bytes"
	"fmt"
	"io"
	"os"
	"os/exec"
	"sort"
	"strconv"
	"strings"

	"github.com/golang/glog"
)

// GitError structure for returning git process state.
type GitError struct {
	Root        string
	Args        []string
	Output      string
	ErrorOutput string
	err         error
}

func gitError(output, errorOutput string, err error, root string, args ...string) GitError {
	return GitError{
		Root:        root,
		Args:        args,
		Output:      output,
		ErrorOutput: errorOutput,
		err:         err,
	}
}

// Error outputs GitError struct as a string.
func (ge GitError) Error() string {
	lines := []string{
		fmt.Sprintf("(%s) 'git %s' failed:", ge.Root, strings.Join(ge.Args, " ")),
		"stdout:",
		ge.Output,
		"stderr:",
		ge.ErrorOutput,
		"command fail error: " + ge.err.Error(),
	}
	return strings.Join(lines, "\n")
}

// Git structure for environmental options passed to git tool.
type Git struct {
	opts         map[string]string
	rootDir      string
	submoduleDir string
	userName     string
	userEmail    string
}

type gitOpt interface {
	gitOpt()
}

// AuthorDateOpt is the git author date.
type AuthorDateOpt string

// CommitterDateOpt is the git committer date.
type CommitterDateOpt string

// RootDirOpt is the git root directory.
type RootDirOpt string

// SubmoduleDirOpt is the relative path (from git root) to a submodule.
type SubmoduleDirOpt string

// UserNameOpt is the git username.
type UserNameOpt string

// UserEmailOpt is the git user email.
type UserEmailOpt string

func (AuthorDateOpt) gitOpt()    {}
func (CommitterDateOpt) gitOpt() {}
func (RootDirOpt) gitOpt()       {}
func (SubmoduleDirOpt) gitOpt()  {}
func (UserNameOpt) gitOpt()      {}
func (UserEmailOpt) gitOpt()     {}

// Reference structure is a branch reference information.
type Reference struct {
	Name     string
	Revision string
	IsHead   bool
}

// Branch structure tracks the state of a branch.
type Branch struct {
	*Reference
	Tracking *Reference
}

// Revision is a git revision.
type Revision string

// BranchName is a git branch name.
type BranchName string

// New is the Git factory.
func New(opts ...gitOpt) *Git {
	rootDir := ""
	submoduleDir := ""
	userName := ""
	userEmail := ""
	env := map[string]string{}
	for _, opt := range opts {
		switch typedOpt := opt.(type) {
		case AuthorDateOpt:
			env["GIT_AUTHOR_DATE"] = string(typedOpt)
		case CommitterDateOpt:
			env["GIT_COMMITTER_DATE"] = string(typedOpt)
		case RootDirOpt:
			rootDir = string(typedOpt)
		case SubmoduleDirOpt:
			submoduleDir = string(typedOpt)
		case UserNameOpt:
			userName = string(typedOpt)
		case UserEmailOpt:
			userEmail = string(typedOpt)
		}
	}
	return &Git{
		opts:         env,
		rootDir:      rootDir,
		submoduleDir: submoduleDir,
		userName:     userName,
		userEmail:    userEmail,
	}
}

// RootDir returns the root directory of the Git object.
func (g *Git) RootDir() string {
	return g.rootDir
}

// Update allows updating of an existing Git object.
func (g *Git) Update(opts ...gitOpt) {
	for _, opt := range opts {
		switch typedOpt := opt.(type) {
		case AuthorDateOpt:
			g.opts["GIT_AUTHOR_DATE"] = string(typedOpt)
		case CommitterDateOpt:
			g.opts["GIT_COMMITTER_DATE"] = string(typedOpt)
		case RootDirOpt:
			g.rootDir = string(typedOpt)
		case SubmoduleDirOpt:
			g.submoduleDir = string(typedOpt)
		case UserNameOpt:
			g.userName = string(typedOpt)
		case UserEmailOpt:
			g.userEmail = string(typedOpt)
		}
	}
}

// AddAllFiles adds/updates all file in working tree to staging.
func (g *Git) AddAllFiles() error {
	return g.run("add", "-A")
}

// CheckoutBranch checks out the given branch.
func (g *Git) CheckoutBranch(branch string, gitSubmodules bool, opts ...CheckoutOpt) error {
	args := []string{"checkout"}
	var force ForceOpt = false
	var detach DetachOpt = false
	for _, opt := range opts {
		switch typedOpt := opt.(type) {
		case ForceOpt:
			force = typedOpt
		case DetachOpt:
			detach = typedOpt
		}
	}
	if force {
		args = append(args, "-f")
	}
	if detach {
		args = append(args, "--detach")
	}

	if gitSubmodules {
		args = append(args, "--recurse-submodules")
	}

	args = append(args, branch)
	if err := g.run(args...); err != nil {
		return err
	}
	// After checkout with submodules update/checkout submodules.
	if gitSubmodules {
		return g.SubmoduleUpdate(nil, InitOpt(true))
	}
	return nil
}

// SubmoduleAdd adds submodule to current branch.
func (g *Git) SubmoduleAdd(remote string, path string) error {
	// Use -f to add submodules even if in .gitignore.
	return g.run("submodule", "add", "-f", remote, path)
}

// SubmoduleStatus returns current current status of submodules in a superproject.
func (g *Git) SubmoduleStatus(opts ...SubmoduleStatusOpt) (string, error) {
	args := []string{"submodule", "status"}
	for _, opt := range opts {
		switch typedOpt := opt.(type) {
		case CachedOpt:
			if typedOpt {
				args = append(args, "--cached")
			}
		}
	}
	out, err := g.runOutput(args...)
	if err != nil {
		return "", err
	}
	return strings.Join(out, "\n"), nil
}

// SubmoduleUpdate updates submodules for current branch.
func (g *Git) SubmoduleUpdate(paths []string, opts ...SubmoduleUpdateOpt) error {
	args := []string{"submodule", "update"}
	for _, opt := range opts {
		switch typedOpt := opt.(type) {
		case InitOpt:
			if typedOpt {
				args = append(args, "--init")
			}
		}
	}
	args = append(args, "--jobs=50")
	args = append(args, paths...)
	return g.run(args...)

}

// Clone clones the given repository to the given local path.  If reference is
// not empty it uses the given path as a reference/shared repo.
func (g *Git) Clone(repo, path string, opts ...CloneOpt) error {
	args := []string{"clone"}
	for _, opt := range opts {
		switch typedOpt := opt.(type) {
		case BareOpt:
			if typedOpt {
				args = append(args, "--bare")
			}
		case ReferenceOpt:
			reference := string(typedOpt)
			if reference != "" {
				args = append(args, []string{"--reference-if-able", reference}...)
			}
		case SharedOpt:
			if typedOpt {
				args = append(args, []string{"--shared", "--local"}...)
			}
		case NoCheckoutOpt:
			if typedOpt {
				args = append(args, "--no-checkout")
			}
		case DepthOpt:
			if typedOpt > 0 {
				args = append(args, []string{"--depth", strconv.Itoa(int(typedOpt))}...)
			}
		case OmitBlobsOpt:
			if typedOpt {
				args = append(args, "--filter=blob:none")
			}
		case OffloadPackfilesOpt:
			if typedOpt {
				args = append([]string{"-c", "fetch.uriprotocols=https"}, args...)
			}
		case RecurseSubmodulesOpt:
			// TODO(iankaz): Add setting submodule.fetchJobs in git config to jiri init
			if typedOpt {
				args = append(args, []string{"--recurse-submodules", "--jobs=16"}...)
			}
		}
	}
	args = append(args, repo)
	args = append(args, path)
	return g.run(args...)
}

// CommitWithMessage commits all files in staging with the given
// message.
func (g *Git) CommitWithMessage(message string) error {
	return g.run("commit", "--allow-empty", "--allow-empty-message", "-m", message)
}

// GetSymbolicRef returns which branch working tree (HEAD) is on.
func (g *Git) GetSymbolicRef() (string, error) {
	out, err := g.runOutput("symbolic-ref", "-q", "HEAD")
	if err != nil {
		return "", err
	}
	if got, want := len(out), 1; got != want {
		return "", fmt.Errorf("unexpected length of %v: got %v, want %v", out, got, want)
	}
	return out[0], nil
}

// Fetch fetches refs and tags from the given remote.
func (g *Git) Fetch(remote string, opts ...FetchOpt) error {
	return g.FetchRefspec(remote, "", opts...)
}

// FetchRefspec fetches refs and tags from the given remote for a particular refspec.
func (g *Git) FetchRefspec(remote, refspec string, opts ...FetchOpt) error {
	tags := false
	all := false
	prune := false
	updateShallow := false
	depth := 0
	fetchTag := ""
	updateHeadOk := false
	recurseSubmodules := false
	jobs := uint(0)
	for _, opt := range opts {
		switch typedOpt := opt.(type) {
		case TagsOpt:
			tags = bool(typedOpt)
		case AllOpt:
			all = bool(typedOpt)
		case PruneOpt:
			prune = bool(typedOpt)
		case DepthOpt:
			depth = int(typedOpt)
		case UpdateShallowOpt:
			updateShallow = bool(typedOpt)
		case FetchTagOpt:
			fetchTag = string(typedOpt)
		case UpdateHeadOkOpt:
			updateHeadOk = bool(typedOpt)
		case RecurseSubmodulesOpt:
			recurseSubmodules = bool(typedOpt)
		case JobsOpt:
			jobs = uint(typedOpt)
		}
	}
	args := []string{}
	args = append(args, "fetch")
	if prune {
		args = append(args, "-p")
	}
	if tags {
		args = append(args, "--tags")
	}
	if depth > 0 {
		args = append(args, "--depth", strconv.Itoa(depth))
	}
	if updateShallow {
		args = append(args, "--update-shallow")
	}
	if all {
		args = append(args, "--all")
	}
	if updateHeadOk {
		args = append(args, "--update-head-ok")
	}
	if recurseSubmodules {
		args = append(args, "--recurse-submodules")
	}
	if jobs > 0 {
		args = append(args, "--jobs="+strconv.FormatUint(uint64(jobs), 10))
	}
	if remote != "" {
		args = append(args, remote)
	}
	if fetchTag != "" {
		args = append(args, "tag", fetchTag)
	}
	if refspec != "" {
		args = append(args, refspec)
	}

	return g.run(args...)
}

// FilesWithUncommittedChanges returns the list of files that have
// uncommitted changes.
func (g *Git) FilesWithUncommittedChanges() ([]string, error) {
	out, err := g.runOutput("diff", "--name-only", "--no-ext-diff")
	if err != nil {
		return nil, err
	}
	out2, err := g.runOutput("diff", "--cached", "--name-only", "--no-ext-diff")
	if err != nil {
		return nil, err
	}
	return append(out, out2...), nil
}

// Remove removes the given files.
func (g *Git) Remove(fileNames ...string) error {
	args := []string{"rm"}
	args = append(args, fileNames...)
	return g.run(args...)
}

// ConfigGetKey gets current git configuration value for the given key.
func (g *Git) ConfigGetKey(key string) (string, error) {
	out, err := g.runOutput("config", "--get", key)
	if err != nil {
		return "", err
	}
	if got, want := len(out), 1; got != want {
		glog.Warning("wanted one line log, got %d line log: %q", got, out)
	}
	return out[0], nil
}

// ConfigGetKeyFromFile gets current git configuration value for the given key from file.
//
// Returns an empty string if the configuration value is not found.
func (g *Git) ConfigGetKeyFromFile(key string, file string) (string, error) {
	out, err := g.runOutput("config", "--file", file, "--default", "", "--get", key)
	if err != nil {
		return "", err
	}
	if len(out) == 0 {
		return "", nil
	}
	if len(out) > 1 {
		glog.Warning("wanted one line log, got %d line log: %q", len(out), out)
	}
	return out[0], nil
}

// ConfigAddKeyToFile adds additional git configuration value to file.
func (g *Git) ConfigAddKeyToFile(key string, file string, value string) error {
	return g.run("config", "--file", file, key, value)
}

func (g *Git) run(args ...string) error {
	var stdout, stderr bytes.Buffer
	if err := g.runGit(&stdout, &stderr, args...); err != nil {
		return gitError(stdout.String(), stderr.String(), err, g.rootDir, args...)
	}
	return nil
}

func trimOutput(o string) []string {
	output := strings.TrimSpace(o)
	if len(output) == 0 {
		return nil
	}
	return strings.Split(output, "\n")
}

func (g *Git) runOutput(args ...string) ([]string, error) {
	var stdout, stderr bytes.Buffer
	if err := g.runGit(&stdout, &stderr, args...); err != nil {
		return nil, gitError(stdout.String(), stderr.String(), err, g.rootDir, args...)
	}
	return trimOutput(stdout.String()), nil
}

func (g *Git) runGit(stdout, stderr io.Writer, args ...string) error {
	if g.submoduleDir != "" {
		args = append([]string{"-C", g.submoduleDir}, args...)
	}
	if g.userName != "" {
		args = append([]string{"-c", fmt.Sprintf("user.name=%s", g.userName)}, args...)
	}
	if g.userEmail != "" {
		args = append([]string{"-c", fmt.Sprintf("user.email=%s", g.userEmail)}, args...)
	}
	var outbuf bytes.Buffer
	var errbuf bytes.Buffer
	command := exec.Command("git", args...)
	command.Stdin = os.Stdin
	command.Stdout = io.MultiWriter(stdout, &outbuf)
	command.Stderr = io.MultiWriter(stderr, &errbuf)
	env := sliceToMap(os.Environ())
	env = mergeMaps(g.opts, env)
	command.Env = mapToSlice(env)
	dir := g.rootDir
	if dir == "" {
		// Use working directory
		if cwd, err := os.Getwd(); err == nil {
			dir = cwd
		}
	}
	command.Dir = dir
	err := command.Run()
	return err
}

// splitKeyValue splits kv into its key and value components.  The format of kv
// is "key=value"; the split is performed on the first '=' character.
func splitKeyValue(kv string) (string, string) {
	split := strings.SplitN(kv, "=", 2)
	if len(split) == 2 {
		return split[0], split[1]
	}
	return split[0], ""
}

type keySorter []string

func (s keySorter) Len() int      { return len(s) }
func (s keySorter) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func (s keySorter) Less(i, j int) bool {
	ikey, _ := splitKeyValue(s[i])
	jkey, _ := splitKeyValue(s[j])
	return ikey < jkey
}

// sortByKey sorts vars into ascending key order, where vars is expected to be
// in the []"key=value" slice representation.
func sortByKey(vars []string) {
	sort.Sort(keySorter(vars))
}

// joinKeyValue joins key and value into a single string "key=value".
func joinKeyValue(key, value string) string {
	return key + "=" + value
}

// mapToSlice converts from the map to the slice representation.  The returned
// slice is in sorted order.
func mapToSlice(from map[string]string) []string {
	to := make([]string, 0, len(from))
	for key, value := range from {
		if key != "" {
			to = append(to, joinKeyValue(key, value))
		}
	}
	sortByKey(to)
	return to
}

// mergeMaps merges together maps, and returns a new map with the merged result.
//
// As a result of its semantics, mergeMaps called with a single map returns a
// copy of the map, with empty keys dropped.
func mergeMaps(maps ...map[string]string) map[string]string {
	merged := make(map[string]string)
	for _, m := range maps {
		for key, value := range m {
			if key != "" {
				merged[key] = value
			}
		}
	}
	return merged
}

// SliceToMap converts from the slice to the map representation.  If the same
// key appears more than once, the last one "wins"; the value is set based on
// the last slice element containing that key.
func sliceToMap(from []string) map[string]string {
	to := make(map[string]string, len(from))
	for _, kv := range from {
		if key, value := splitKeyValue(kv); key != "" {
			to[key] = value
		}
	}
	return to
}