plumbing: format/packfile, Refactor patch delta

The changes aim to simplify the code and reduce duplication.

Signed-off-by: Paulo Gomes <pjbgf@linux.com>

2 files changed, 79 insertions, 113 deletions

diff --git a/plumbing/format/packfile/diff_delta.go b/plumbing/format/packfile/diff_delta.go
index 2c7a335..8898e58 100644
--- a/plumbing/format/packfile/diff_delta.go
+++ b/plumbing/format/packfile/diff_delta.go
@@ -17,8 +17,11 @@ const (
 	s = 16
 
 	// https://github.com/git/git/blob/f7466e94375b3be27f229c78873f0acf8301c0a5/diff-delta.c#L428
-	// Max size of a copy operation (64KB)
+	// Max size of a copy operation (64KB).
 	maxCopySize = 64 * 1024
+
+	// Min size of a copy operation.
+	minCopySize = 4
 )
 
 // GetDelta returns an EncodedObject of type OFSDeltaObject. Base and Target object,
diff --git a/plumbing/format/packfile/patch_delta.go b/plumbing/format/packfile/patch_delta.go
index 67c20ff..960769c 100644
--- a/plumbing/format/packfile/patch_delta.go
+++ b/plumbing/format/packfile/patch_delta.go
@@ -18,7 +18,33 @@ import (
 // and https://github.com/tarruda/node-git-core/blob/master/src/js/delta.js
 // for details about the delta format.
 
-const deltaSizeMin = 4
+var (
+	ErrInvalidDelta = errors.New("invalid delta")
+	ErrDeltaCmd     = errors.New("wrong delta command")
+)
+
+const (
+	payload      = 0x7f // 0111 1111
+	continuation = 0x80 // 1000 0000
+)
+
+type offset struct {
+	mask  byte
+	shift uint
+}
+
+var offsets = []offset{
+	{mask: 0x01, shift: 0},
+	{mask: 0x02, shift: 8},
+	{mask: 0x04, shift: 16},
+	{mask: 0x08, shift: 24},
+}
+
+var sizes = []offset{
+	{mask: 0x10, shift: 0},
+	{mask: 0x20, shift: 8},
+	{mask: 0x40, shift: 16},
+}
 
 // ApplyDelta writes to target the result of applying the modification deltas in delta to base.
 func ApplyDelta(target, base plumbing.EncodedObject, delta []byte) (err error) {
@@ -59,11 +85,6 @@ func ApplyDelta(target, base plumbing.EncodedObject, delta []byte) (err error) {
 	return err
 }
 
-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.
 // An error will be returned if delta is corrupted (ErrDeltaLen) or an action command
 // is not copy from source or copy from delta (ErrDeltaCmd).
@@ -121,7 +142,8 @@ func ReaderFromDelta(base plumbing.EncodedObject, deltaRC io.Reader) (io.ReadClo
 				return
 			}
 
-			if isCopyFromSrc(cmd) {
+			switch {
+			case isCopyFromSrc(cmd):
 				offset, err := decodeOffsetByteReader(cmd, deltaBuf)
 				if err != nil {
 					_ = dstWr.CloseWithError(err)
@@ -174,7 +196,8 @@ func ReaderFromDelta(base plumbing.EncodedObject, deltaRC io.Reader) (io.ReadClo
 				}
 				remainingTargetSz -= sz
 				basePos += sz
-			} else if isCopyFromDelta(cmd) {
+
+			case isCopyFromDelta(cmd):
 				sz := uint(cmd) // cmd is the size itself
 				if invalidSize(sz, targetSz) {
 					_ = dstWr.CloseWithError(ErrInvalidDelta)
@@ -186,10 +209,12 @@ func ReaderFromDelta(base plumbing.EncodedObject, deltaRC io.Reader) (io.ReadClo
 				}
 
 				remainingTargetSz -= sz
-			} else {
+
+			default:
 				_ = dstWr.CloseWithError(ErrDeltaCmd)
 				return
 			}
+
 			if remainingTargetSz <= 0 {
 				_ = dstWr.Close()
 				return
@@ -201,7 +226,7 @@ func ReaderFromDelta(base plumbing.EncodedObject, deltaRC io.Reader) (io.ReadClo
 }
 
 func patchDelta(dst *bytes.Buffer, src, delta []byte) error {
-	if len(delta) < deltaSizeMin {
+	if len(delta) < minCopySize {
 		return ErrInvalidDelta
 	}
 
@@ -222,7 +247,9 @@ func patchDelta(dst *bytes.Buffer, src, delta []byte) error {
 
 		cmd = delta[0]
 		delta = delta[1:]
-		if isCopyFromSrc(cmd) {
+
+		switch {
+		case isCopyFromSrc(cmd):
 			var offset, sz uint
 			var err error
 			offset, delta, err = decodeOffset(cmd, delta)
@@ -241,7 +268,8 @@ func patchDelta(dst *bytes.Buffer, src, delta []byte) error {
 			}
 			dst.Write(src[offset : offset+sz])
 			remainingTargetSz -= sz
-		} else if isCopyFromDelta(cmd) {
+
+		case isCopyFromDelta(cmd):
 			sz := uint(cmd) // cmd is the size itself
 			if invalidSize(sz, targetSz) {
 				return ErrInvalidDelta
@@ -254,7 +282,8 @@ func patchDelta(dst *bytes.Buffer, src, delta []byte) error {
 			dst.Write(delta[0:sz])
 			remainingTargetSz -= sz
 			delta = delta[sz:]
-		} else {
+
+		default:
 			return ErrDeltaCmd
 		}
 
@@ -408,48 +437,24 @@ func decodeLEB128ByteReader(input io.ByteReader) (uint, error) {
 	return num, nil
 }
 
-const (
-	payload      = 0x7f // 0111 1111
-	continuation = 0x80 // 1000 0000
-)
-
 func isCopyFromSrc(cmd byte) bool {
-	return (cmd & 0x80) != 0
+	return (cmd & continuation) != 0
 }
 
 func isCopyFromDelta(cmd byte) bool {
-	return (cmd&0x80) == 0 && cmd != 0
+	return (cmd&continuation) == 0 && cmd != 0
 }
 
 func decodeOffsetByteReader(cmd byte, delta io.ByteReader) (uint, error) {
 	var offset uint
-	if (cmd & 0x01) != 0 {
-		next, err := delta.ReadByte()
-		if err != nil {
-			return 0, err
-		}
-		offset = uint(next)
-	}
-	if (cmd & 0x02) != 0 {
-		next, err := delta.ReadByte()
-		if err != nil {
-			return 0, err
-		}
-		offset |= uint(next) << 8
-	}
-	if (cmd & 0x04) != 0 {
-		next, err := delta.ReadByte()
-		if err != nil {
-			return 0, err
-		}
-		offset |= uint(next) << 16
-	}
-	if (cmd & 0x08) != 0 {
-		next, err := delta.ReadByte()
-		if err != nil {
-			return 0, err
+	for _, o := range offsets {
+		if (cmd & o.mask) != 0 {
+			next, err := delta.ReadByte()
+			if err != nil {
+				return 0, err
+			}
+			offset |= uint(next) << o.shift
 		}
-		offset |= uint(next) << 24
 	}
 
 	return offset, nil
@@ -457,33 +462,14 @@ func decodeOffsetByteReader(cmd byte, delta io.ByteReader) (uint, error) {
 
 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
+	for _, o := range offsets {
+		if (cmd & o.mask) != 0 {
+			if len(delta) == 0 {
+				return 0, nil, ErrInvalidDelta
+			}
+			offset |= uint(delta[0]) << o.shift
+			delta = delta[1:]
 		}
-		offset |= uint(delta[0]) << 24
-		delta = delta[1:]
 	}
 
 	return offset, delta, nil
@@ -491,29 +477,18 @@ func decodeOffset(cmd byte, delta []byte) (uint, []byte, error) {
 
 func decodeSizeByteReader(cmd byte, delta io.ByteReader) (uint, error) {
 	var sz uint
-	if (cmd & 0x10) != 0 {
-		next, err := delta.ReadByte()
-		if err != nil {
-			return 0, err
-		}
-		sz = uint(next)
-	}
-	if (cmd & 0x20) != 0 {
-		next, err := delta.ReadByte()
-		if err != nil {
-			return 0, err
-		}
-		sz |= uint(next) << 8
-	}
-	if (cmd & 0x40) != 0 {
-		next, err := delta.ReadByte()
-		if err != nil {
-			return 0, err
+	for _, s := range sizes {
+		if (cmd & s.mask) != 0 {
+			next, err := delta.ReadByte()
+			if err != nil {
+				return 0, err
+			}
+			sz |= uint(next) << s.shift
 		}
-		sz |= uint(next) << 16
 	}
+
 	if sz == 0 {
-		sz = 0x10000
+		sz = maxCopySize
 	}
 
 	return sz, nil
@@ -521,29 +496,17 @@ func decodeSizeByteReader(cmd byte, delta io.ByteReader) (uint, error) {
 
 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
+	for _, s := range sizes {
+		if (cmd & s.mask) != 0 {
+			if len(delta) == 0 {
+				return 0, nil, ErrInvalidDelta
+			}
+			sz |= uint(delta[0]) << s.shift
+			delta = delta[1:]
 		}
-		sz |= uint(delta[0]) << 16
-		delta = delta[1:]
 	}
 	if sz == 0 {
-		sz = 0x10000
+		sz = maxCopySize
 	}
 
 	return sz, delta, nil