fix git tree sorting bug; consolidate proxies code

Author: petar

git/cache.go

@@ -71,32 +71,33 @@ func (x *Cache) clone(ctx context.Context, addr Address, all bool) Cloned {
 		all:      all,
 		cache:    x,
 		addr:     addr,
-		diskRepo: openOrInitOnDisk(ctx, x.urlCachePath(addr.Repo)),
+		diskRepo: openOrInitOnDisk(ctx, x.urlCachePath(addr.Repo), true), // cache must be bare, otherwise checkout branch cannot be pushed
 		memRepo:  initInMemory(ctx),
 	}
 	c.pull(ctx)
+	switchToBranch(ctx, c.memRepo, addr.Branch)
+	return c
+}
 
-	// switch to or create branch
-	err := must.Try(func() { Checkout(ctx, Worktree(ctx, c.memRepo), addr.Branch) })
+func switchToBranch(ctx context.Context, repo *Repository, branch Branch) {
+	err := must.Try(func() { Checkout(ctx, Worktree(ctx, repo), branch) })
 	switch {
 	case err == plumbing.ErrReferenceNotFound:
-		must.NoError(ctx, c.memRepo.CreateBranch(&config.Branch{Name: string(addr.Branch)}))
-		SetHeadToBranch(ctx, c.memRepo, addr.Branch)
-		// must.NoError(ctx, Worktree(ctx, c.memRepo).Reset(&git.ResetOptions{Mode: git.HardReset}))
+		must.NoError(ctx, repo.CreateBranch(&config.Branch{Name: string(branch)}))
+		SetHeadToBranch(ctx, repo, branch)
+		// must.NoError(ctx, Worktree(ctx, repo).Reset(&git.ResetOptions{Mode: git.HardReset}))
 	case err != nil:
 		must.NoError(ctx, err)
 	}
-
-	return c
 }
 
-func openOrInitOnDisk(ctx context.Context, path URL) *Repository {
+func openOrInitOnDisk(ctx context.Context, path URL, bare bool) *Repository {
 	repo, err := git.PlainOpen(string(path))
 	if err == nil {
 		return repo
 	}
 	must.Assertf(ctx, err == git.ErrRepositoryNotExists, "%v", err)
-	return InitPlain(ctx, string(path), true) // cache must be bare, otherwise checkout branch cannot be pushed
+	return InitPlain(ctx, string(path), bare)
 }
 
 type clonedCacheProxy struct {

git/clone.go

@@ -16,6 +16,12 @@ func UseCache(ctx context.Context, dir string) {
 	proxy = NewCache(ctx, dir)
 }
 
+func UseNoCacheOnDisk(ctx context.Context, dir string) {
+	cacheLk.Lock()
+	defer cacheLk.Unlock()
+	proxy = NewNoCacheOnDisk(dir)
+}
+
 func getProxy() Proxy {
 	cacheLk.Lock()
 	defer cacheLk.Unlock()
@@ -26,12 +32,12 @@ func CloneOne(ctx context.Context, addr Address) Cloned {
 	if pxy := getProxy(); pxy != nil {
 		return pxy.CloneOne(ctx, addr)
 	}
-	return cloneOneNoProxy(ctx, addr)
+	return NoCache{}.CloneOne(ctx, addr)
 }
 
 func CloneAll(ctx context.Context, addr Address) Cloned {
 	if pxy := getProxy(); pxy != nil {
 		return pxy.CloneAll(ctx, addr)
 	}
-	return cloneAllNoProxy(ctx, addr)
+	return NoCache{}.CloneAll(ctx, addr)
 }

git/embed.go

@@ -81,7 +81,7 @@ func EmbedOnCommit(
 	embeddingsTreeHash := MergeTrees(ctx, repo, remoteTreeHashes, allowOverride, filter)
 
 	// merge embeddings into the toBranch tree
-	// XXX: check if merge produced changes
+	// XXX: check if merge produced changes, don't commit if it didn't
 	mergedTreeHash := mergeTrees(ctx, repo, ns.NS{}, parentCommit.TreeHash, embeddingsTreeHash, false, MergePassFilter)
 
 	// create a commit

git/merge.go

@@ -2,6 +2,7 @@ package git
 
 import (
 	"context"
+	"sort"
 
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/filemode"
@@ -73,9 +74,24 @@ func mergeTrees(
 	}
 
 	// make tree
-	entries := make([]object.TreeEntry, 0, len(merged))
+	entries := make(TreeEntries, 0, len(merged))
 	for _, mergedEntry := range merged {
 		entries = append(entries, mergedEntry)
 	}
+	sort.Sort(entries)
 	return MakeTree(ctx, repo, object.Tree{Entries: entries})
 }
+
+type TreeEntries []object.TreeEntry
+
+func (x TreeEntries) Len() int {
+	return len(x)
+}
+
+func (x TreeEntries) Less(i, j int) bool {
+	return x[i].Name < x[j].Name
+}
+
+func (x TreeEntries) Swap(i, j int) {
+	x[i], x[j] = x[j], x[i]
+}

git/nocache.go

@@ -0,0 +1,66 @@
+package git
+
+import (
+	"context"
+	"path/filepath"
+
+	"github.com/gov4git/lib4git/base"
+)
+
+type NoCache struct {
+	dir string // if non empty, repositories will be created on disk within this dir
+}
+
+func NewNoCacheInMemory() Proxy {
+	return NoCache{}
+}
+
+func NewNoCacheOnDisk(dir string) Proxy {
+	return NoCache{dir: dir}
+}
+
+func (x NoCache) CloneOne(ctx context.Context, addr Address) Cloned {
+	return x.clone(ctx, addr, false)
+}
+
+func (x NoCache) CloneAll(ctx context.Context, addr Address) Cloned {
+	return x.clone(ctx, addr, true)
+}
+
+func (x NoCache) clone(ctx context.Context, addr Address, all bool) Cloned {
+	var repo *Repository
+	if x.dir == "" {
+		repo = initInMemory(ctx)
+	} else {
+		p := URL(filepath.Join(x.dir, nonceName()))
+		base.Infof("materializing repo %v on disk %v\n", addr.Repo, p)
+		repo = openOrInitOnDisk(ctx, p, false)
+	}
+	c := &clonedNoCache{all: all, addr: addr, repo: repo}
+	c.Pull(ctx)
+	switchToBranch(ctx, c.repo, addr.Branch)
+	return c
+}
+
+type clonedNoCache struct {
+	all  bool
+	addr Address
+	repo *Repository
+}
+
+func (x *clonedNoCache) Push(ctx context.Context) {
+	PushOnce(ctx, x.repo, x.addr.Repo, mirrorRefSpecs)
+}
+
+func (x *clonedNoCache) Pull(ctx context.Context) {
+	PullOnce(ctx, x.repo, x.addr.Repo, clonePullRefSpecs(x.addr, x.all))
+}
+
+func (x *clonedNoCache) Repo() *Repository {
+	return x.repo
+}
+
+func (x *clonedNoCache) Tree() *Tree {
+	t, _ := x.Repo().Worktree()
+	return t
+}

git/proxy.go

@@ -5,9 +5,6 @@ import (
 
 	"github.com/go-git/go-billy/v5/memfs"
 	"github.com/go-git/go-git/v5"
-	"github.com/go-git/go-git/v5/config"
-	"github.com/go-git/go-git/v5/plumbing"
-	"github.com/go-git/go-git/v5/plumbing/transport"
 	"github.com/go-git/go-git/v5/storage/memory"
 	"github.com/gov4git/lib4git/must"
 )
@@ -28,78 +25,8 @@ type Cloned interface {
 	Tree() *Tree
 }
 
-func cloneOneNoProxy(ctx context.Context, addr Address) Cloned {
-	return &clonedNoProxy{all: false, addr: addr, repo: cloneToMemoryOrInit(ctx, addr)}
-}
-
-func cloneAllNoProxy(ctx context.Context, addr Address) Cloned {
-	c := &clonedNoProxy{all: true, addr: addr, repo: cloneToMemoryOrInit(ctx, addr)}
-	c.Pull(ctx)
-	return c
-}
-
-func cloneToMemoryOrInit(ctx context.Context, addr Address) *Repository {
-	repo, err := must.Try1(func() *Repository { return cloneToMemory(ctx, addr) })
-	if err == nil {
-		return repo
-	}
-	_, isNoBranch := err.(git.NoMatchingRefSpecError)
-	if !isNoBranch && err != transport.ErrEmptyRemoteRepository && err != plumbing.ErrReferenceNotFound {
-		must.Panic(ctx, err)
-	}
-	repo = initInMemory(ctx)
-
-	_, err = repo.CreateRemote(&config.RemoteConfig{Name: Origin, URLs: []string{string(addr.Repo)}})
-	must.NoError(ctx, err)
-
-	err = repo.CreateBranch(&config.Branch{Name: string(addr.Branch), Remote: Origin})
-	must.NoError(ctx, err)
-
-	ChangeDefaultBranch(ctx, repo, addr.Branch)
-
-	return repo
-}
-
 func initInMemory(ctx context.Context) *Repository {
 	repo, err := git.Init(memory.NewStorage(), memfs.New())
 	must.NoError(ctx, err)
 	return repo
 }
-
-func cloneToMemory(ctx context.Context, addr Address) *Repository {
-	repo, err := git.CloneContext(ctx,
-		memory.NewStorage(),
-		memfs.New(),
-		&git.CloneOptions{
-			URL:           string(addr.Repo),
-			Auth:          GetAuth(ctx, addr.Repo),
-			ReferenceName: plumbing.NewBranchReferenceName(string(addr.Branch)),
-		},
-	)
-	must.NoError(ctx, err)
-
-	return repo
-}
-
-type clonedNoProxy struct {
-	all  bool
-	addr Address
-	repo *Repository
-}
-
-func (x *clonedNoProxy) Push(ctx context.Context) {
-	PushOnce(ctx, x.repo, x.addr.Repo, mirrorRefSpecs)
-}
-
-func (x *clonedNoProxy) Pull(ctx context.Context) {
-	PullOnce(ctx, x.repo, x.addr.Repo, clonePullRefSpecs(x.addr, x.all))
-}
-
-func (x *clonedNoProxy) Repo() *Repository {
-	return x.repo
-}
-
-func (x *clonedNoProxy) Tree() *Tree {
-	t, _ := x.Repo().Worktree()
-	return t
-}

git/surgery.go

@@ -36,11 +36,15 @@ func CreateCommit(
 	parents []plumbing.Hash,
 ) plumbing.Hash {
 
-	opts := git.CommitOptions{Author: GetAuthor()}
+	opts := git.CommitOptions{
+		All:               true,
+		AllowEmptyCommits: true,
+		Author:            GetAuthor(),
+	}
 	must.NoError(ctx, opts.Validate(repo))
 	commit := object.Commit{
-		Author: *opts.Author,
-		// Committer:    *opts.Committer,
+		Author:       *opts.Author,
+		Committer:    *opts.Author,
 		Message:      msg,
 		TreeHash:     treeHash,
 		ParentHashes: parents,

git/sync.go

@@ -16,11 +16,18 @@ func nonceName() string {
 	return "nonce-" + strconv.FormatUint(uint64(rand.Int63()), 36)
 }
 
-const mirrorBranchesRefSpec = "refs/heads/*:refs/heads/*"
-const mirrorTagsRefSpec = "refs/tags/*:refs/tags/*"
-const mirrorHeadRefSpec = "refs/HEAD:refs/HEAD"
+const (
+	mirrorBranchesRefSpec = "refs/heads/*:refs/heads/*"
+	mirrorRemotesRefSpec  = "refs/remotes/*:refs/remotes/*"
+	mirrorTagsRefSpec     = "refs/tags/*:refs/tags/*"
+	mirrorHeadRefSpec     = "refs/HEAD:refs/HEAD"
+)
 
-var mirrorRefSpecs = []config.RefSpec{mirrorBranchesRefSpec /*, mirrorTagsRefSpec, mirrorHeadRefSpec*/}
+var mirrorRefSpecs = []config.RefSpec{
+	mirrorBranchesRefSpec,
+	// mirrorRemotesRefSpec,
+	// mirrorTagsRefSpec, mirrorHeadRefSpec,
+}
 
 func branchRefSpec(b Branch) []config.RefSpec {
 	return []config.RefSpec{

go.mod

@@ -10,8 +10,6 @@ require (
 	go.uber.org/zap v1.24.0
 )
 
-// replace github.com/go-git/go-git => /Users/petar/github.com/go-git/go-git
-
 require (
 	github.com/Microsoft/go-winio v0.5.2 // indirect
 	github.com/ProtonMail/go-crypto v0.0.0-20230217124315-7d5c6f04bbb8 // indirect