From 0af572dd21c0aa79d13745b633ee24ba6c4d6cf1 Mon Sep 17 00:00:00 2001
From: "Santiago M. Mola" <santi@mola.io>
Date: Wed, 14 Dec 2016 23:12:44 +0100
Subject: move plumbing from top level package to plumbing (#183)

* plumbing: rename Object -> EncodedObject.

* plumbing/storer: rename ObjectStorer -> EncodedObjectStorer.

* move difftree to plumbing/difftree.

* move diff -> utils/diff

* make Object/Tag/Blob/Tree/Commit/File depend on storer.

* Object and its implementations now depend only on
  storer.EncodedObjectStorer, not git.Repository.
* Tests are decoupled accordingly.

* move Object/Commit/File/Tag/Tree to plumbing/object.

* move Object/Commit/File/Tag/Tree to plumbing/object.
* move checkClose to utils/ioutil.

* move RevListObjects to plumbing/revlist.Objects.

* move DiffTree to plumbing/difftree package.

* rename files with plural nouns to singular

* plumbing/object: add GetBlob/GetCommit/GetTag/GetTree.
---
 utils/diff/diff.go          |  45 ++++++++++++++++++
 utils/diff/diff_ext_test.go | 109 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 154 insertions(+)
 create mode 100644 utils/diff/diff.go
 create mode 100644 utils/diff/diff_ext_test.go

(limited to 'utils/diff')

diff --git a/utils/diff/diff.go b/utils/diff/diff.go
new file mode 100644
index 0000000..b840ad6
--- /dev/null
+++ b/utils/diff/diff.go
@@ -0,0 +1,45 @@
+// Package diff implements line oriented diffs, similar to the ancient
+// Unix diff command.
+//
+// The current implementation is just a wrapper around Sergi's
+// go-diff/diffmatchpatch library, which is a go port of Neil
+// Fraser's google-diff-match-patch code
+package diff
+
+import (
+	"bytes"
+
+	"github.com/sergi/go-diff/diffmatchpatch"
+)
+
+// Do computes the (line oriented) modifications needed to turn the src
+// string into the dst string.
+func Do(src, dst string) (diffs []diffmatchpatch.Diff) {
+	dmp := diffmatchpatch.New()
+	wSrc, wDst, warray := dmp.DiffLinesToChars(src, dst)
+	diffs = dmp.DiffMain(wSrc, wDst, false)
+	diffs = dmp.DiffCharsToLines(diffs, warray)
+	return diffs
+}
+
+// Dst computes and returns the destination text.
+func Dst(diffs []diffmatchpatch.Diff) string {
+	var text bytes.Buffer
+	for _, d := range diffs {
+		if d.Type != diffmatchpatch.DiffDelete {
+			text.WriteString(d.Text)
+		}
+	}
+	return text.String()
+}
+
+// Src computes and returns the source text
+func Src(diffs []diffmatchpatch.Diff) string {
+	var text bytes.Buffer
+	for _, d := range diffs {
+		if d.Type != diffmatchpatch.DiffInsert {
+			text.WriteString(d.Text)
+		}
+	}
+	return text.String()
+}
diff --git a/utils/diff/diff_ext_test.go b/utils/diff/diff_ext_test.go
new file mode 100644
index 0000000..adda276
--- /dev/null
+++ b/utils/diff/diff_ext_test.go
@@ -0,0 +1,109 @@
+package diff_test
+
+import (
+	"testing"
+
+	"gopkg.in/src-d/go-git.v4/utils/diff"
+
+	"github.com/sergi/go-diff/diffmatchpatch"
+	. "gopkg.in/check.v1"
+)
+
+func Test(t *testing.T) { TestingT(t) }
+
+type suiteCommon struct{}
+
+var _ = Suite(&suiteCommon{})
+
+var diffTests = [...]struct {
+	src string // the src string to diff
+	dst string // the dst string to diff
+}{
+	// equal inputs
+	{"", ""},
+	{"a", "a"},
+	{"a\n", "a\n"},
+	{"a\nb", "a\nb"},
+	{"a\nb\n", "a\nb\n"},
+	{"a\nb\nc", "a\nb\nc"},
+	{"a\nb\nc\n", "a\nb\nc\n"},
+	// missing '\n'
+	{"", "\n"},
+	{"\n", ""},
+	{"a", "a\n"},
+	{"a\n", "a"},
+	{"a\nb", "a\nb"},
+	{"a\nb\n", "a\nb\n"},
+	{"a\nb\nc", "a\nb\nc"},
+	{"a\nb\nc\n", "a\nb\nc\n"},
+	// generic
+	{"a\nbbbbb\n\tccc\ndd\n\tfffffffff\n", "bbbbb\n\tccc\n\tDD\n\tffff\n"},
+}
+
+func (s *suiteCommon) TestAll(c *C) {
+	for i, t := range diffTests {
+		diffs := diff.Do(t.src, t.dst)
+		src := diff.Src(diffs)
+		dst := diff.Dst(diffs)
+		c.Assert(src, Equals, t.src, Commentf("subtest %d, src=%q, dst=%q, bad calculated src", i, t.src, t.dst))
+		c.Assert(dst, Equals, t.dst, Commentf("subtest %d, src=%q, dst=%q, bad calculated dst", i, t.src, t.dst))
+	}
+}
+
+var doTests = [...]struct {
+	src, dst string
+	exp      []diffmatchpatch.Diff
+}{
+	{
+		src: "",
+		dst: "",
+		exp: []diffmatchpatch.Diff{},
+	},
+	{
+		src: "a",
+		dst: "a",
+		exp: []diffmatchpatch.Diff{
+			{
+				Type: 0,
+				Text: "a",
+			},
+		},
+	},
+	{
+		src: "",
+		dst: "abc\ncba",
+		exp: []diffmatchpatch.Diff{
+			{
+				Type: 1,
+				Text: "abc\ncba",
+			},
+		},
+	},
+	{
+		src: "abc\ncba",
+		dst: "",
+		exp: []diffmatchpatch.Diff{
+			{
+				Type: -1,
+				Text: "abc\ncba",
+			},
+		},
+	},
+	{
+		src: "abc\nbcd\ncde",
+		dst: "000\nabc\n111\nBCD\n",
+		exp: []diffmatchpatch.Diff{
+			{Type: 1, Text: "000\n"},
+			{Type: 0, Text: "abc\n"},
+			{Type: -1, Text: "bcd\ncde"},
+			{Type: 1, Text: "111\nBCD\n"},
+		},
+	},
+}
+
+func (s *suiteCommon) TestDo(c *C) {
+	for i, t := range doTests {
+		diffs := diff.Do(t.src, t.dst)
+		c.Assert(diffs, DeepEquals, t.exp, Commentf("subtest %d", i))
+	}
+}
-- 
cgit