aboutsummaryrefslogtreecommitdiffstats
path: root/plumbing
diff options
context:
space:
mode:
Diffstat (limited to 'plumbing')
-rw-r--r--plumbing/format/packfile/delta_test.go24
-rw-r--r--plumbing/format/packfile/patch_delta.go77
-rw-r--r--plumbing/object/commit_walker.go48
-rw-r--r--plumbing/object/commit_walker_test.go57
-rw-r--r--plumbing/revlist/revlist.go39
5 files changed, 192 insertions, 53 deletions
diff --git a/plumbing/format/packfile/delta_test.go b/plumbing/format/packfile/delta_test.go
index 9ee3499..42b777a 100644
--- a/plumbing/format/packfile/delta_test.go
+++ b/plumbing/format/packfile/delta_test.go
@@ -1,7 +1,6 @@
package packfile
import (
- "fmt"
"math/rand"
. "gopkg.in/check.v1"
@@ -86,9 +85,28 @@ func (s *DeltaSuite) TestAddDelta(c *C) {
baseBuf := genBytes(t.base)
targetBuf := genBytes(t.target)
delta := DiffDelta(baseBuf, targetBuf)
- result := PatchDelta(baseBuf, delta)
+ result, err := PatchDelta(baseBuf, delta)
- c.Log(fmt.Printf("Executing test case: %s\n", t.description))
+ c.Log("Executing test case:", t.description)
+ c.Assert(err, IsNil)
c.Assert(result, DeepEquals, targetBuf)
}
}
+
+func (s *DeltaSuite) TestIncompleteDelta(c *C) {
+ for _, t := range s.testCases {
+ c.Log("Incomplete delta on:", t.description)
+ baseBuf := genBytes(t.base)
+ targetBuf := genBytes(t.target)
+ delta := DiffDelta(baseBuf, targetBuf)
+ delta = delta[:len(delta)-2]
+ result, err := PatchDelta(baseBuf, delta)
+ c.Assert(err, NotNil)
+ c.Assert(result, IsNil)
+ }
+
+ // check nil input too
+ result, err := PatchDelta(nil, nil)
+ c.Assert(err, NotNil)
+ c.Assert(result, IsNil)
+}
diff --git a/plumbing/format/packfile/patch_delta.go b/plumbing/format/packfile/patch_delta.go
index 840f840..976cabc 100644
--- a/plumbing/format/packfile/patch_delta.go
+++ b/plumbing/format/packfile/patch_delta.go
@@ -1,6 +1,7 @@
package packfile
import (
+ "errors"
"io/ioutil"
"gopkg.in/src-d/go-git.v4/plumbing"
@@ -30,7 +31,11 @@ func ApplyDelta(target, base plumbing.EncodedObject, delta []byte) error {
return err
}
- dst := PatchDelta(src, delta)
+ dst, err := PatchDelta(src, delta)
+ if err != nil {
+ return err
+ }
+
target.SetSize(int64(len(dst)))
if _, err := w.Write(dst); err != nil {
@@ -40,15 +45,22 @@ func ApplyDelta(target, base plumbing.EncodedObject, delta []byte) error {
return nil
}
+var (
+ ErrInvalidDelta = errors.New("invalid delta")
+ ErrDeltaCmd = errors.New("wrong delta command")
+)
+
// PatchDelta returns the result of applying the modification deltas in delta to src.
-func PatchDelta(src, delta []byte) []byte {
+// An error will be returned if delta is corrupted (ErrDeltaLen) or an action command
+// is not copy from source or copy from delta (ErrDeltaCmd).
+func PatchDelta(src, delta []byte) ([]byte, error) {
if len(delta) < deltaSizeMin {
- return nil
+ return nil, ErrInvalidDelta
}
srcSz, delta := decodeLEB128(delta)
if srcSz != uint(len(src)) {
- return nil
+ return nil, ErrInvalidDelta
}
targetSz, delta := decodeLEB128(delta)
@@ -57,12 +69,25 @@ func PatchDelta(src, delta []byte) []byte {
var dest []byte
var cmd byte
for {
+ if len(delta) == 0 {
+ return nil, ErrInvalidDelta
+ }
+
cmd = delta[0]
delta = delta[1:]
if isCopyFromSrc(cmd) {
var offset, sz uint
- offset, delta = decodeOffset(cmd, delta)
- sz, delta = decodeSize(cmd, delta)
+ var err error
+ offset, delta, err = decodeOffset(cmd, delta)
+ if err != nil {
+ return nil, err
+ }
+
+ sz, delta, err = decodeSize(cmd, delta)
+ if err != nil {
+ return nil, err
+ }
+
if invalidSize(sz, targetSz) ||
invalidOffsetSize(offset, sz, srcSz) {
break
@@ -72,13 +97,18 @@ func PatchDelta(src, delta []byte) []byte {
} else if isCopyFromDelta(cmd) {
sz := uint(cmd) // cmd is the size itself
if invalidSize(sz, targetSz) {
- break
+ return nil, ErrInvalidDelta
+ }
+
+ if uint(len(delta)) < sz {
+ return nil, ErrInvalidDelta
}
+
dest = append(dest, delta[0:sz]...)
remainingTargetSz -= sz
delta = delta[sz:]
} else {
- return nil
+ return nil, ErrDeltaCmd
}
if remainingTargetSz <= 0 {
@@ -86,7 +116,7 @@ func PatchDelta(src, delta []byte) []byte {
}
}
- return dest
+ return dest, nil
}
// Decodes a number encoded as an unsigned LEB128 at the start of some
@@ -124,39 +154,60 @@ func isCopyFromDelta(cmd byte) bool {
return (cmd&0x80) == 0 && cmd != 0
}
-func decodeOffset(cmd byte, delta []byte) (uint, []byte) {
+func decodeOffset(cmd byte, delta []byte) (uint, []byte, error) {
var offset uint
if (cmd & 0x01) != 0 {
+ if len(delta) == 0 {
+ return 0, nil, ErrInvalidDelta
+ }
offset = uint(delta[0])
delta = delta[1:]
}
if (cmd & 0x02) != 0 {
+ if len(delta) == 0 {
+ return 0, nil, ErrInvalidDelta
+ }
offset |= uint(delta[0]) << 8
delta = delta[1:]
}
if (cmd & 0x04) != 0 {
+ if len(delta) == 0 {
+ return 0, nil, ErrInvalidDelta
+ }
offset |= uint(delta[0]) << 16
delta = delta[1:]
}
if (cmd & 0x08) != 0 {
+ if len(delta) == 0 {
+ return 0, nil, ErrInvalidDelta
+ }
offset |= uint(delta[0]) << 24
delta = delta[1:]
}
- return offset, delta
+ return offset, delta, nil
}
-func decodeSize(cmd byte, delta []byte) (uint, []byte) {
+func decodeSize(cmd byte, delta []byte) (uint, []byte, error) {
var sz uint
if (cmd & 0x10) != 0 {
+ if len(delta) == 0 {
+ return 0, nil, ErrInvalidDelta
+ }
sz = uint(delta[0])
delta = delta[1:]
}
if (cmd & 0x20) != 0 {
+ if len(delta) == 0 {
+ return 0, nil, ErrInvalidDelta
+ }
sz |= uint(delta[0]) << 8
delta = delta[1:]
}
if (cmd & 0x40) != 0 {
+ if len(delta) == 0 {
+ return 0, nil, ErrInvalidDelta
+ }
sz |= uint(delta[0]) << 16
delta = delta[1:]
}
@@ -164,7 +215,7 @@ func decodeSize(cmd byte, delta []byte) (uint, []byte) {
sz = 0x10000
}
- return sz, delta
+ return sz, delta, nil
}
func invalidSize(sz, targetSz uint) bool {
diff --git a/plumbing/object/commit_walker.go b/plumbing/object/commit_walker.go
index 8d2c6e8..797c17a 100644
--- a/plumbing/object/commit_walker.go
+++ b/plumbing/object/commit_walker.go
@@ -18,10 +18,16 @@ type commitPreIterator struct {
// The given callback will be called for each visited commit. Each commit will
// be visited only once. If the callback returns an error, walking will stop
// and will return the error. Other errors might be returned if the history
-// cannot be traversed (e.g. missing objects).
-func NewCommitPreorderIter(c *Commit) CommitIter {
+// cannot be traversed (e.g. missing objects). Ignore allows to skip some
+// commits from being iterated.
+func NewCommitPreorderIter(c *Commit, ignore []plumbing.Hash) CommitIter {
+ seen := make(map[plumbing.Hash]bool)
+ for _, h := range ignore {
+ seen[h] = true
+ }
+
return &commitPreIterator{
- seen: make(map[plumbing.Hash]bool),
+ seen: seen,
stack: make([]CommitIter, 0),
start: c,
}
@@ -51,20 +57,33 @@ func (w *commitPreIterator) Next() (*Commit, error) {
}
}
- // check and update seen
if w.seen[c.Hash] {
continue
}
w.seen[c.Hash] = true
+
if c.NumParents() > 0 {
- w.stack = append(w.stack, c.Parents())
+ w.stack = append(w.stack, filteredParentIter(c, w.seen))
}
return c, nil
}
}
+func filteredParentIter(c *Commit, seen map[plumbing.Hash]bool) CommitIter {
+ var hashes []plumbing.Hash
+ for _, h := range c.ParentHashes {
+ if !seen[h] {
+ hashes = append(hashes, h)
+ }
+ }
+
+ return NewCommitIter(c.s,
+ storer.NewEncodedObjectLookupIter(c.s, plumbing.CommitObject, hashes),
+ )
+}
+
func (w *commitPreIterator) ForEach(cb func(*Commit) error) error {
for {
c, err := w.Next()
@@ -98,11 +117,16 @@ type commitPostIterator struct {
// history like WalkCommitHistory but in post-order. This means that after
// walking a merge commit, the merged commit will be walked before the base
// it was merged on. This can be useful if you wish to see the history in
-// chronological order.
-func NewCommitPostorderIter(c *Commit) CommitIter {
+// chronological order. Ignore allows to skip some commits from being iterated.
+func NewCommitPostorderIter(c *Commit, ignore []plumbing.Hash) CommitIter {
+ seen := make(map[plumbing.Hash]bool)
+ for _, h := range ignore {
+ seen[h] = true
+ }
+
return &commitPostIterator{
stack: []*Commit{c},
- seen: make(map[plumbing.Hash]bool),
+ seen: seen,
}
}
@@ -114,17 +138,17 @@ func (w *commitPostIterator) Next() (*Commit, error) {
c := w.stack[len(w.stack)-1]
w.stack = w.stack[:len(w.stack)-1]
+
if w.seen[c.Hash] {
continue
}
+
w.seen[c.Hash] = true
- err := c.Parents().ForEach(func(pcm *Commit) error {
- w.stack = append(w.stack, pcm)
+ return c, c.Parents().ForEach(func(p *Commit) error {
+ w.stack = append(w.stack, p)
return nil
})
-
- return c, err
}
}
diff --git a/plumbing/object/commit_walker_test.go b/plumbing/object/commit_walker_test.go
index 2a03057..48b504d 100644
--- a/plumbing/object/commit_walker_test.go
+++ b/plumbing/object/commit_walker_test.go
@@ -1,6 +1,10 @@
package object
-import . "gopkg.in/check.v1"
+import (
+ "gopkg.in/src-d/go-git.v4/plumbing"
+
+ . "gopkg.in/check.v1"
+)
type CommitWalkerSuite struct {
BaseObjectsSuite
@@ -12,8 +16,7 @@ func (s *CommitWalkerSuite) TestCommitPreIterator(c *C) {
commit := s.commit(c, s.Fixture.Head)
var commits []*Commit
- wIter := NewCommitPreorderIter(commit)
- wIter.ForEach(func(c *Commit) error {
+ NewCommitPreorderIter(commit, nil).ForEach(func(c *Commit) error {
commits = append(commits, c)
return nil
})
@@ -35,12 +38,33 @@ func (s *CommitWalkerSuite) TestCommitPreIterator(c *C) {
}
}
+func (s *CommitWalkerSuite) TestCommitPreIteratorWithIgnore(c *C) {
+ commit := s.commit(c, s.Fixture.Head)
+
+ var commits []*Commit
+ NewCommitPreorderIter(commit, []plumbing.Hash{
+ plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"),
+ }).ForEach(func(c *Commit) error {
+ commits = append(commits, c)
+ return nil
+ })
+
+ c.Assert(commits, HasLen, 2)
+
+ expected := []string{
+ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
+ "918c48b83bd081e863dbe1b80f8998f058cd8294",
+ }
+ for i, commit := range commits {
+ c.Assert(commit.Hash.String(), Equals, expected[i])
+ }
+}
+
func (s *CommitWalkerSuite) TestCommitPostIterator(c *C) {
commit := s.commit(c, s.Fixture.Head)
var commits []*Commit
- wIter := NewCommitPostorderIter(commit)
- wIter.ForEach(func(c *Commit) error {
+ NewCommitPostorderIter(commit, nil).ForEach(func(c *Commit) error {
commits = append(commits, c)
return nil
})
@@ -57,6 +81,29 @@ func (s *CommitWalkerSuite) TestCommitPostIterator(c *C) {
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
"35e85108805c84807bc66a02d91535e1e24b38b9",
}
+
+ for i, commit := range commits {
+ c.Assert(commit.Hash.String(), Equals, expected[i])
+ }
+}
+
+func (s *CommitWalkerSuite) TestCommitPostIteratorWithIgnore(c *C) {
+ commit := s.commit(c, s.Fixture.Head)
+
+ var commits []*Commit
+ NewCommitPostorderIter(commit, []plumbing.Hash{
+ plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"),
+ }).ForEach(func(c *Commit) error {
+ commits = append(commits, c)
+ return nil
+ })
+
+ c.Assert(commits, HasLen, 2)
+
+ expected := []string{
+ "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
+ "918c48b83bd081e863dbe1b80f8998f058cd8294",
+ }
for i, commit := range commits {
c.Assert(commit.Hash.String(), Equals, expected[i])
}
diff --git a/plumbing/revlist/revlist.go b/plumbing/revlist/revlist.go
index 20bc99d..1bda2fa 100644
--- a/plumbing/revlist/revlist.go
+++ b/plumbing/revlist/revlist.go
@@ -16,11 +16,7 @@ import (
// the reachable objects from the given objects. Ignore param are object hashes
// that we want to ignore on the result. All that objects must be accessible
// from the object storer.
-func Objects(
- s storer.EncodedObjectStorer,
- objects []plumbing.Hash,
- ignore []plumbing.Hash) ([]plumbing.Hash, error) {
-
+func Objects(s storer.EncodedObjectStorer, objects, ignore []plumbing.Hash) ([]plumbing.Hash, error) {
seen := hashListToSet(ignore)
result := make(map[plumbing.Hash]bool)
@@ -32,7 +28,7 @@ func Objects(
}
for _, h := range objects {
- if err := processObject(s, h, seen, walkerFunc); err != nil {
+ if err := processObject(s, h, seen, ignore, walkerFunc); err != nil {
return nil, err
}
}
@@ -45,6 +41,7 @@ func processObject(
s storer.EncodedObjectStorer,
h plumbing.Hash,
seen map[plumbing.Hash]bool,
+ ignore []plumbing.Hash,
walkerFunc func(h plumbing.Hash),
) error {
o, err := s.EncodedObject(plumbing.AnyObject, h)
@@ -59,12 +56,12 @@ func processObject(
switch do := do.(type) {
case *object.Commit:
- return reachableObjects(do, seen, walkerFunc)
+ return reachableObjects(do, seen, ignore, walkerFunc)
case *object.Tree:
return iterateCommitTrees(seen, do, walkerFunc)
case *object.Tag:
walkerFunc(do.Hash)
- return processObject(s, do.Target, seen, walkerFunc)
+ return processObject(s, do.Target, seen, ignore, walkerFunc)
case *object.Blob:
walkerFunc(do.Hash)
default:
@@ -82,22 +79,24 @@ func processObject(
func reachableObjects(
commit *object.Commit,
seen map[plumbing.Hash]bool,
+ ignore []plumbing.Hash,
cb func(h plumbing.Hash)) error {
- return object.NewCommitPreorderIter(commit).
- ForEach(func(commit *object.Commit) error {
- if seen[commit.Hash] {
- return nil
- }
- cb(commit.Hash)
+ i := object.NewCommitPreorderIter(commit, ignore)
+ return i.ForEach(func(commit *object.Commit) error {
+ if seen[commit.Hash] {
+ return nil
+ }
+
+ cb(commit.Hash)
- tree, err := commit.Tree()
- if err != nil {
- return err
- }
+ tree, err := commit.Tree()
+ if err != nil {
+ return err
+ }
- return iterateCommitTrees(seen, tree, cb)
- })
+ return iterateCommitTrees(seen, tree, cb)
+ })
}
// iterateCommitTrees iterate all reachable trees from the given commit
generated by cgit (git 2.34.1) at 2024-11-11 07:35:23 +0000