*: Lint

3 files changed, 88 insertions, 24 deletions

diff --git a/diff/trees/diff.go b/diff/trees/diff.go
index 836b71cc..9583c939 100644
--- a/diff/trees/diff.go
+++ b/diff/trees/diff.go
@@ -12,9 +12,12 @@ import (
 // reaches directory entries.
 func Diff(a, b *object.Tree, readTree func(objectid.ObjectID) (*object.Tree, error)) ([]Entry, error) {
 	var out []Entry
-	if err := diffRecursive(a, b, nil, readTree, &out); err != nil {
+
+	err := diffRecursive(a, b, nil, readTree, &out)
+	if err != nil {
 		return nil, err
 	}
+
 	return out, nil
 }
 
@@ -27,17 +30,23 @@ func diffRecursive(a, b *object.Tree, prefix []byte, readTree func(objectid.Obje
 		for i := range b.Entries {
 			entry := &b.Entries[i]
 			full := joinPath(prefix, entry.Name)
+
 			*out = append(*out, Entry{Path: full, Kind: EntryKindAdded, Old: nil, New: entry})
-			if entry.Mode == object.FileModeDir {
-				sub, err := readTree(entry.ID)
-				if err != nil {
-					return err
-				}
-				if err := diffRecursive(nil, sub, full, readTree, out); err != nil {
-					return err
-				}
+			if entry.Mode != object.FileModeDir {
+				continue
+			}
+
+			sub, err := readTree(entry.ID)
+			if err != nil {
+				return err
+			}
+
+			err = diffRecursive(nil, sub, full, readTree, out)
+			if err != nil {
+				return err
 			}
 		}
+
 		return nil
 	}
 
@@ -45,25 +54,33 @@ func diffRecursive(a, b *object.Tree, prefix []byte, readTree func(objectid.Obje
 		for i := range a.Entries {
 			entry := &a.Entries[i]
 			full := joinPath(prefix, entry.Name)
+
 			*out = append(*out, Entry{Path: full, Kind: EntryKindDeleted, Old: entry, New: nil})
-			if entry.Mode == object.FileModeDir {
-				sub, err := readTree(entry.ID)
-				if err != nil {
-					return err
-				}
-				if err := diffRecursive(sub, nil, full, readTree, out); err != nil {
-					return err
-				}
+			if entry.Mode != object.FileModeDir {
+				continue
+			}
+
+			sub, err := readTree(entry.ID)
+			if err != nil {
+				return err
+			}
+
+			err = diffRecursive(sub, nil, full, readTree, out)
+			if err != nil {
+				return err
 			}
 		}
+
 		return nil
 	}
 
 	i := 0
+
 	j := 0
 	for i < len(a.Entries) && j < len(b.Entries) {
 		left := &a.Entries[i]
 		right := &b.Entries[j]
+
 		cmp := object.TreeEntryNameCompare(
 			left.Name,
 			left.Mode,
@@ -73,49 +90,63 @@ func diffRecursive(a, b *object.Tree, prefix []byte, readTree func(objectid.Obje
 		switch {
 		case cmp < 0:
 			full := joinPath(prefix, left.Name)
+
 			*out = append(*out, Entry{Path: full, Kind: EntryKindDeleted, Old: left, New: nil})
 			if left.Mode == object.FileModeDir {
 				sub, err := readTree(left.ID)
 				if err != nil {
 					return err
 				}
-				if err := diffRecursive(sub, nil, full, readTree, out); err != nil {
+
+				err = diffRecursive(sub, nil, full, readTree, out)
+				if err != nil {
 					return err
 				}
 			}
+
 			i++
 		case cmp > 0:
 			full := joinPath(prefix, right.Name)
+
 			*out = append(*out, Entry{Path: full, Kind: EntryKindAdded, Old: nil, New: right})
 			if right.Mode == object.FileModeDir {
 				sub, err := readTree(right.ID)
 				if err != nil {
 					return err
 				}
-				if err := diffRecursive(nil, sub, full, readTree, out); err != nil {
+
+				err = diffRecursive(nil, sub, full, readTree, out)
+				if err != nil {
 					return err
 				}
 			}
+
 			j++
 		default:
 			full := joinPath(prefix, left.Name)
+
 			modified := left.Mode != right.Mode || left.ID != right.ID
 			if modified {
 				*out = append(*out, Entry{Path: full, Kind: EntryKindModified, Old: left, New: right})
 			}
+
 			if left.Mode == object.FileModeDir && right.Mode == object.FileModeDir && left.ID != right.ID {
 				leftSub, err := readTree(left.ID)
 				if err != nil {
 					return err
 				}
+
 				rightSub, err := readTree(right.ID)
 				if err != nil {
 					return err
 				}
-				if err := diffRecursive(leftSub, rightSub, full, readTree, out); err != nil {
+
+				err = diffRecursive(leftSub, rightSub, full, readTree, out)
+				if err != nil {
 					return err
 				}
 			}
+
 			i++
 			j++
 		}
@@ -124,13 +155,16 @@ func diffRecursive(a, b *object.Tree, prefix []byte, readTree func(objectid.Obje
 	for ; i < len(a.Entries); i++ {
 		left := &a.Entries[i]
 		full := joinPath(prefix, left.Name)
+
 		*out = append(*out, Entry{Path: full, Kind: EntryKindDeleted, Old: left, New: nil})
 		if left.Mode == object.FileModeDir {
 			sub, err := readTree(left.ID)
 			if err != nil {
 				return err
 			}
-			if err := diffRecursive(sub, nil, full, readTree, out); err != nil {
+
+			err = diffRecursive(sub, nil, full, readTree, out)
+			if err != nil {
 				return err
 			}
 		}
@@ -139,13 +173,16 @@ func diffRecursive(a, b *object.Tree, prefix []byte, readTree func(objectid.Obje
 	for ; j < len(b.Entries); j++ {
 		right := &b.Entries[j]
 		full := joinPath(prefix, right.Name)
+
 		*out = append(*out, Entry{Path: full, Kind: EntryKindAdded, Old: nil, New: right})
 		if right.Mode == object.FileModeDir {
 			sub, err := readTree(right.ID)
 			if err != nil {
 				return err
 			}
-			if err := diffRecursive(nil, sub, full, readTree, out); err != nil {
+
+			err = diffRecursive(nil, sub, full, readTree, out)
+			if err != nil {
 				return err
 			}
 		}
diff --git a/diff/trees/diff_test.go b/diff/trees/diff_test.go
index 2fb8540f..1664bdf8 100644
--- a/diff/trees/diff_test.go
+++ b/diff/trees/diff_test.go
@@ -157,88 +157,112 @@ type diffExpectation struct {
 
 func writeTestFile(t *testing.T, path, data string) {
 	t.Helper()
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+
+	err := os.MkdirAll(filepath.Dir(path), 0o755)
+	if err != nil {
 		t.Fatalf("create directory for %s: %v", path, err)
 	}
-	if err := os.WriteFile(path, []byte(data), 0o644); err != nil {
+
+	err = os.WriteFile(path, []byte(data), 0o644)
+	if err != nil {
 		t.Fatalf("write %s: %v", path, err)
 	}
 }
 
 func openLooseStore(t *testing.T, objectsPath string, algo objectid.Algorithm) *loose.Store {
 	t.Helper()
+
 	root, err := os.OpenRoot(objectsPath)
 	if err != nil {
 		t.Fatalf("OpenRoot(%q): %v", objectsPath, err)
 	}
+
 	t.Cleanup(func() { _ = root.Close() })
+
 	store, err := loose.New(root, algo)
 	if err != nil {
 		t.Fatalf("loose.New: %v", err)
 	}
+
 	t.Cleanup(func() { _ = store.Close() })
+
 	return store
 }
 
 func makeReadTree(t *testing.T, store *loose.Store, algo objectid.Algorithm) func(objectid.ObjectID) (*object.Tree, error) {
 	t.Helper()
+
 	return func(id objectid.ObjectID) (*object.Tree, error) {
 		ty, content, err := store.ReadBytesContent(id)
 		if err != nil {
 			return nil, err
 		}
+
 		if ty != objecttype.TypeTree {
 			return nil, errors.New("diff/trees test: object is not a tree")
 		}
+
 		return object.ParseTree(content, algo)
 	}
 }
 
 func mustReadTree(t *testing.T, readTree func(objectid.ObjectID) (*object.Tree, error), id objectid.ObjectID) *object.Tree {
 	t.Helper()
+
 	tree, err := readTree(id)
 	if err != nil {
 		t.Fatalf("read tree %s: %v", id, err)
 	}
+
 	return tree
 }
 
 func parseID(t *testing.T, algo objectid.Algorithm, hex string) objectid.ObjectID {
 	t.Helper()
+
 	id, err := objectid.ParseHex(algo, hex)
 	if err != nil {
 		t.Fatalf("parse object id %q: %v", hex, err)
 	}
+
 	return id
 }
 
 func checkDiffs(t *testing.T, diffs []trees.Entry, expected map[string]diffExpectation) {
 	t.Helper()
+
 	got := make(map[string]trees.Entry, len(diffs))
 	for _, diff := range diffs {
 		path := string(diff.Path)
 		if _, exists := got[path]; exists {
 			t.Fatalf("duplicate diff path %q", path)
 		}
+
 		got[path] = diff
 	}
+
 	if len(got) != len(expected) {
 		t.Fatalf("diff count = %d, want %d", len(got), len(expected))
 	}
+
 	for path, want := range expected {
 		diff, ok := got[path]
 		if !ok {
 			t.Fatalf("missing diff for %q", path)
 		}
+
 		if diff.Kind != want.kind {
 			t.Errorf("%s kind = %v, want %v", path, diff.Kind, want.kind)
 		}
+
 		if (diff.Old == nil) != want.oldNil {
 			t.Errorf("%s old nil = %v, want %v", path, diff.Old == nil, want.oldNil)
 		}
+
 		if (diff.New == nil) != want.newNil {
 			t.Errorf("%s new nil = %v, want %v", path, diff.New == nil, want.newNil)
 		}
+
 		if diff.Kind == trees.EntryKindModified && diff.Old != nil && diff.New != nil && diff.Old.ID == diff.New.ID {
 			t.Errorf("%s modified entry should change IDs", path)
 		}
diff --git a/diff/trees/path.go b/diff/trees/path.go
index 0ced379a..e40f3de5 100644
--- a/diff/trees/path.go
+++ b/diff/trees/path.go
@@ -4,11 +4,14 @@ func joinPath(prefix, name []byte) []byte {
 	if len(prefix) == 0 {
 		out := make([]byte, len(name))
 		copy(out, name)
+
 		return out
 	}
+
 	out := make([]byte, len(prefix)+1+len(name))
 	copy(out, prefix)
 	out[len(prefix)] = '/'
 	copy(out[len(prefix)+1:], name)
+
 	return out
 }