feat: add api-push (#548)

Co-authored-by: ChrisStatham <[email protected]>

Author: lindell

cmd/cmd-run.go

@@ -49,6 +49,8 @@ func RunCmd() *cobra.Command {
 	cmd.Flags().IntP("concurrent", "C", 1, "The maximum number of concurrent runs.")
 	cmd.Flags().BoolP("skip-pr", "", false, "Skip pull request and directly push to the branch.")
 	cmd.Flags().BoolP("push-only", "", false, "Skip pull request and only push the feature branch.")
+	cmd.Flags().BoolP("api-push", "", false, `Push changes through the API instead of git. Only supported for GitHub.
+It has the benefit of automatically producing verified commits. However, it is slower and not suited for changes to large files.`)
 	cmd.Flags().StringSliceP("skip-repo", "s", nil, "Skip changes on specified repositories, the name is including the owner of repository in the format \"ownerName/repoName\".")
 	cmd.Flags().BoolP("interactive", "i", false, "Take manual decision before committing any change. Requires git to be installed.")
 	cmd.Flags().BoolP("dry-run", "d", false, "Run without pushing changes or creating pull requests.")
@@ -92,6 +94,7 @@ func run(cmd *cobra.Command, _ []string) error {
 	concurrent, _ := flag.GetInt("concurrent")
 	skipPullRequest, _ := flag.GetBool("skip-pr")
 	pushOnly, _ := flag.GetBool("push-only")
+	apiPush, _ := flag.GetBool("api-push")
 	skipRepository, _ := flag.GetStringSlice("skip-repo")
 	interactive, _ := flag.GetBool("interactive")
 	dryRun, _ := flag.GetBool("dry-run")
@@ -108,6 +111,9 @@ func run(cmd *cobra.Command, _ []string) error {
 	repoInclude, _ := flag.GetString("repo-include")
 	repoExclude, _ := flag.GetString("repo-exclude")
 
+	platform, _ := flag.GetString("platform")
+	gitType, _ := flag.GetString("git-type")
+
 	if concurrent < 1 {
 		return errors.New("concurrent runs can't be less than one")
 	}
@@ -149,6 +155,15 @@ func run(cmd *cobra.Command, _ []string) error {
 		return errors.New("--concurrent and --interactive can't be used at the same time")
 	}
 
+	if apiPush {
+		if platform != "github" {
+			return errors.New("api-push is only supported for GitHub")
+		}
+		if gitType != "go" {
+			return errors.New("api-push only works with go-git")
+		}
+	}
+
 	// Parse commit author data
 	var commitAuthor *git.CommitAuthor
 	if authorName != "" || authorEmail != "" {
@@ -241,6 +256,7 @@ func run(cmd *cobra.Command, _ []string) error {
 		ForkOwner:              forkOwner,
 		SkipPullRequest:        skipPullRequest,
 		PushOnly:               pushOnly,
+		APIPush:                apiPush,
 		SkipRepository:         skipRepository,
 		CommitAuthor:           commitAuthor,
 		BaseBranch:             baseBranchName,

internal/git/changes.go

@@ -0,0 +1,18 @@
+package git
+
+// Changes represents the changes made to a repository
+type Changes struct {
+	// Map of file paths to the changes made to the file
+	// The key is the file path and the value is the change
+	Additions map[string][]byte
+
+	// List of file paths that were deleted
+	Deletions []string
+
+	// OldHash is the hash of the previous commit
+	OldHash string
+}
+
+type LastCommitChecker interface {
+	LastCommitChanges() (Changes, error)
+}

internal/git/gogit/git.go

@@ -3,11 +3,13 @@ package gogit
 import (
 	"bytes"
 	"context"
+	"io"
 	"time"
 
 	"github.com/go-git/go-git/v5/config"
 	"github.com/go-git/go-git/v5/plumbing/format/gitignore"
 	"github.com/go-git/go-git/v5/plumbing/object"
+	"github.com/go-git/go-git/v5/utils/merkletrie"
 	internalgit "github.com/lindell/multi-gitter/internal/git"
 	"github.com/pkg/errors"
 
@@ -218,3 +220,69 @@ func (g *Git) AddRemote(name, url string) error {
 	})
 	return err
 }
+
+func (g *Git) LastCommitChanges() (internalgit.Changes, error) {
+	iter, err := g.repo.Log(&git.LogOptions{})
+	if err != nil {
+		return internalgit.Changes{}, err
+	}
+
+	current, err := iter.Next()
+	if err != nil {
+		return internalgit.Changes{}, errors.WithMessage(err, "could not get current commit")
+	}
+	last, err := iter.Next()
+	if err != nil {
+		return internalgit.Changes{}, errors.WithMessage(err, "could not get last commit")
+	}
+
+	currentTree, err := current.Tree()
+	if err != nil {
+		return internalgit.Changes{}, errors.WithMessage(err, "could not get current tree")
+	}
+	lastTree, err := last.Tree()
+	if err != nil {
+		return internalgit.Changes{}, errors.WithMessage(err, "could not get current tree")
+	}
+
+	changes, err := lastTree.Diff(currentTree)
+	if err != nil {
+		return internalgit.Changes{}, errors.WithMessage(err, "could not get diff")
+	}
+
+	additions := map[string][]byte{}
+	deletions := []string{}
+	for _, change := range changes {
+		action, err := change.Action()
+		if err != nil {
+			return internalgit.Changes{}, errors.WithMessage(err, "could not get action")
+		}
+
+		if action == merkletrie.Insert || action == merkletrie.Modify {
+			_, to, err := change.Files()
+			if err != nil {
+				return internalgit.Changes{}, errors.WithMessage(err, "could not get files")
+			}
+
+			reader, err := to.Reader()
+			if err != nil {
+				return internalgit.Changes{}, errors.WithMessage(err, "could not get reader")
+			}
+			bytes, err := io.ReadAll(reader)
+			reader.Close()
+			if err != nil {
+				return internalgit.Changes{}, errors.WithMessage(err, "could not read file")
+			}
+
+			additions[to.Name] = bytes
+		} else if action == merkletrie.Delete {
+			deletions = append(deletions, change.From.Name)
+		}
+	}
+
+	return internalgit.Changes{
+		Additions: additions,
+		Deletions: deletions,
+		OldHash:   last.Hash.String(),
+	}, nil
+}

internal/multigitter/run.go

@@ -61,6 +61,7 @@ type Runner struct {
 	SkipPullRequest        bool     // If set, the script will run directly on the base-branch without creating any PR
 	PushOnly               bool     // If set, the script will only publish the feature branch without creating a PR
 	SkipRepository         []string // A list of repositories that run will skip
+	APIPush                bool     // Use the SCM API to commit and push the changes instead of git
 	RegExIncludeRepository *regexp.Regexp
 	RegExExcludeRepository *regexp.Regexp
 
@@ -338,9 +339,28 @@ func (r *Runner) runSingleRepo(ctx context.Context, repo scm.Repository) (scm.Pu
 
 	log.Info("Pushing changes to remote")
 	forcePush := featureBranchExist && r.ConflictStrategy == ConflictStrategyReplace
-	err = sourceController.Push(ctx, remoteName, forcePush)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not push changes")
+
+	if !r.APIPush {
+		err = sourceController.Push(ctx, remoteName, forcePush)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not push changes")
+		}
+	} else {
+		commitChecker, hasCommitChecker := sourceController.(git.LastCommitChecker)
+		changePusher, hasChangePusher := r.VersionController.(scm.ChangePusher)
+		if !hasCommitChecker || !hasChangePusher {
+			return nil, errors.New("the scm implementation does not support committing through the API")
+		}
+
+		changes, err := commitChecker.LastCommitChanges()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get diff")
+		}
+
+		err = changePusher.Push(ctx, repo, r.CommitMessage, changes, r.FeatureBranch, featureBranchExist, forcePush)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	if r.PushOnly {

internal/scm/changes.go

@@ -0,0 +1,20 @@
+package scm
+
+import (
+	"context"
+
+	"github.com/lindell/multi-gitter/internal/git"
+)
+
+// ChangePusher makes a commit through the API
+type ChangePusher interface {
+	Push(
+		ctx context.Context,
+		repo Repository,
+		commitMessage string,
+		change git.Changes,
+		featureBranch string,
+		branchExist bool,
+		forcePush bool,
+	) error
+}