feat: show content diff

Now you can use flag `--show-diff` or `-i` to show changes in all
modified files in format similar to git diff output.

Author: zladovan

README.md

@@ -39,8 +39,8 @@ Download archive for your platform from [releases page](https://github.com/unrav
 
 When you are on Linux you can use following commands to download and install latest release:
 
-    wget https://github.com/unravela/indiff/releases/download/v0.1.0/indiff_0.1.0_Linux_x86_64.tar.gz
-    tar -xzvf ./indiff_0.1.0_Linux_x86_64.tar.gz -C /tmp/
+    wget https://github.com/unravela/indiff/releases/download/v0.2.0/indiff_0.2.0_Linux_x86_64.tar.gz
+    tar -xzvf ./indiff_0.2.0_Linux_x86_64.tar.gz -C /tmp/
     sudo mv /tmp/indiff /usr/local/bin
 
 
@@ -101,6 +101,34 @@ To check changes between revision tagged with `v1.0.0` and latest commit run:
 
 > Instead of tag name you can use commit hash. Tildes and carets are supported too so you can use expressions like `HEAD^` or `v.1.0.0~2`.
 
+### Content diff
+
+If you want to see the details about what exactly was changed you can use `-i` flag and indiff will print changes for each modified file in format similar to `git diff` output.
+
+Running following command:
+    
+    indiff -f v1.0.0 -i en,de
+
+Can result in output like this:
+
+    de: missing translation of: en/first.xml
+    de: missing translation of: en/second.md
+    de: missing translation of: en/subone/second.md
+    de: modified only base: en/first.md: de/first.md
+    diff en/first.md
+    @@ -1 +1,3 @@
+    # First file
+    +
+    +Content of file
+    de: modified base and translation: en/section/one.md: de/section/one.md
+    diff en/section/one.md
+    @@ -0,0 +1 @@
+    +# First file in section one
+    diff de/section/one.md
+    @@ -0,0 +1 @@
+    +# Erste Datei in Abschnitt eins
+
+
 ### It works without git too
 
 If you project is not versioned with git you can still use indiff to look for missing translation files.

cmd/main.go

@@ -74,6 +74,12 @@ func main() {
 				Value:   false,
 				Aliases: []string{"a"},
 			},
+			&cli.BoolFlag{
+				Name:    "show-diff",
+				Usage:   "Print diff for each modified file",
+				Value:   false,
+				Aliases: []string{"i"},
+			},
 		},
 		Writer:          os.Stderr,
 		HideHelpCommand: true,
@@ -126,7 +132,10 @@ func run(c *cli.Context) error {
 	}
 
 	// parse revision range
-	revisionRange := git.NewRange(c.String("from-revision"), c.String("to-revision"))
+	revisionRange := &git.Range{
+		Older: c.String("from-revision"),
+		Newer: c.String("to-revision"),
+	}
 	isGitAllowed := !c.Bool("no-git")
 
 	// collect bundle
@@ -149,7 +158,11 @@ func run(c *cli.Context) error {
 	}
 
 	// render
-	r := render.NewPlain(root, !c.Bool("absolute-paths"))
+	r := &render.Plain{
+		RootPath:          root,
+		ShowRelativePaths: !c.Bool("absolute-paths"),
+		ShowDiff:          c.Bool("show-diff"),
+	}
 	r.Render(os.Stdout, diffs)
 
 	return nil

diff.go

@@ -51,21 +51,42 @@ func (m *Missing) String() string {
 	return fmt.Sprintf("Missing{ base: %s, lang: %s }", m.base, m.lang)
 }
 
+// Modification holds modified file changes made to this file
+type Modification struct {
+	file  *File
+	patch string // TODO: use some structured type instead of string to be able to control output
+}
+
+// NewModification turns File to Modification (modified file) with changes in given patch
+func NewModification(file *File, patch string) *Modification {
+	return &Modification{file: file, patch: patch}
+}
+
+// Modified turns this file to Modification with changes in given patch
+func (f *File) Modified(patch string) *Modification {
+	return NewModification(f, patch)
+}
+
 // ModifiedBase says that base file was modified but it's translation was not
 type ModifiedBase struct {
-	base        *File
+	base        *Modification
 	translation *File
 	// TODO: what exactly was added / removed
 }
 
 // NewModifiedBase creates new ModifiedBase file difference
-func NewModifiedBase(base *File, translation *File) *ModifiedBase {
+func NewModifiedBase(base *Modification, translation *File) *ModifiedBase {
 	return &ModifiedBase{base: base, translation: translation}
 }
 
 // Base points to file in base language which was modified
 func (m *ModifiedBase) Base() *File {
-	return m.base
+	return m.base.file
+}
+
+// BasePatch returns text representation of changes made to file in base language
+func (m *ModifiedBase) BasePatch() string {
+	return m.base.patch
 }
 
 // Translation points to file which equivalent in base language was modified
@@ -79,36 +100,46 @@ func (m *ModifiedBase) Lang() string {
 }
 
 func (m *ModifiedBase) String() string {
-	return fmt.Sprintf("ModifiedBase{ base: %s, translation: %s }", m.base, m.translation)
+	return fmt.Sprintf("ModifiedBase{ base: %s, translation: %s }", m.base.file, m.translation)
 }
 
 // ModifiedBoth says that base file and it's translation was modified
 type ModifiedBoth struct {
-	base        *File
-	translation *File
+	base        *Modification
+	translation *Modification
 	// TODO: what exactly was added / removed
 }
 
 // NewModifiedBoth creates new ModifiedBoth file difference
-func NewModifiedBoth(base *File, translation *File) *ModifiedBoth {
+func NewModifiedBoth(base *Modification, translation *Modification) *ModifiedBoth {
 	return &ModifiedBoth{base: base, translation: translation}
 }
 
 // Base points to file in base language which was modified
 func (m *ModifiedBoth) Base() *File {
-	return m.base
+	return m.base.file
+}
+
+// BasePatch returns text representation of changes made to file in base language
+func (m *ModifiedBoth) BasePatch() string {
+	return m.base.patch
+}
+
+// TranslationPatch returns text representation of changes made to translation file
+func (m *ModifiedBoth) TranslationPatch() string {
+	return m.translation.patch
 }
 
 // Translation points to translation file which was modified
 func (m *ModifiedBoth) Translation() *File {
-	return m.translation
+	return m.translation.file
 }
 
 // Lang is language of translation file
 func (m *ModifiedBoth) Lang() string {
-	return m.translation.Lang
+	return m.translation.file.Lang
 }
 
 func (m *ModifiedBoth) String() string {
-	return fmt.Sprintf("ModifiedBoth{ base: %s, translation: %s }", m.base, m.translation)
+	return fmt.Sprintf("ModifiedBoth{ base: %s, translation: %s }", m.base.file, m.translation.file)
 }

git/changes.go

@@ -2,7 +2,6 @@ package git
 
 import (
 	"bytes"
-	"path/filepath"
 
 	"github.com/pkg/errors"
 
@@ -11,60 +10,78 @@ import (
 	"github.com/go-git/go-git/v5/utils/merkletrie/noder"
 )
 
-// treeChanges holds changes
-type treeChanges struct {
-	root    string
-	changes merkletrie.Changes
+// revChange holds one change between to revisions
+type revisionChange struct {
+	underlying    merkletrie.Change
+	revisionRange *revisionRange
 }
 
+// revisionChanges represent collection of changes between two revisions
+type revisionChanges []*revisionChange
+
 // collectChanges collects changes in repo in given revisionRange
-func collectChanges(repo *git.Repository, revisionRange *Range) (*treeChanges, error) {
-	// get trees for both sides of revision range
-	olderTree, err := revisionRange.olderTree(repo)
-	if err != nil {
-		return nil, errors.Wrap(err, "Cannot get older revision tree")
-	}
-	newerTree, err := revisionRange.newerTree(repo)
-	if err != nil {
-		return nil, errors.Wrap(err, "Cannot get newer revision tree")
-	}
-	changes, err := merkletrie.DiffTree(olderTree, newerTree, diffTreeIsEquals)
+func collectChanges(repo *git.Repository, revisionRange *revisionRange) (revisionChanges, error) {
+	older := revisionRange.older.root
+	newer := revisionRange.newer.root
+	originalChanges, err := merkletrie.DiffTree(older, newer, diffTreeIsEquals)
 	if err != nil {
 		return nil, errors.Wrap(err, "Cannot resolve difference between older and newer revision tree")
 	}
 
-	// resolve repo root path
-	tree, err := repo.Worktree()
-	if err != nil {
-		return nil, errors.Wrap(err, "Cannot get worktree of repository")
+	// enrich changes with revision references
+	changes := make(revisionChanges, len(originalChanges))
+	for i, c := range originalChanges {
+		changes[i] = &revisionChange{
+			underlying:    c,
+			revisionRange: revisionRange,
+		}
 	}
-	root := tree.Filesystem.Root()
 
-	return &treeChanges{root: root, changes: changes}, nil
+	return changes, nil
 }
 
 // forEachCreatedOrModified invokes given function f for each change with action Inserted or Modified
-func (t *treeChanges) forEachCreatedOrModified(f func(path string)) {
-	for _, c := range t.changes {
-		action, _ := c.Action()
+func (changes revisionChanges) forEachCreatedOrModified(f func(change *revisionChange)) {
+	for _, c := range changes {
+		action, _ := c.underlying.Action()
 		if action == merkletrie.Insert || action == merkletrie.Modify {
-			path := filepath.Join(t.root, c.To.String())
-			f(path)
+			f(c)
 		}
 	}
 }
 
-// wasCreatedOrModified check if given path points to file which was changed with action Inserted or Modified
-func (t *treeChanges) wasCreatedOrModified(path string) bool {
-	for _, c := range t.changes {
-		action, _ := c.Action()
-		if action == merkletrie.Insert || action == merkletrie.Modify {
-			if path == filepath.Join(t.root, c.To.String()) {
-				return true
-			}
-		}
+// fromPath returns path to file before change
+func (c *revisionChange) fromPath() string {
+	return c.underlying.From.String()
+}
+
+// fromContent reads content of the file before change
+func (c *revisionChange) fromContent() string {
+	if c.fromPath() == "" {
+		return ""
+	}
+	content, err := c.revisionRange.older.contentOf(c.fromPath())
+	if err != nil {
+		panic(err)
+	}
+	return content
+}
+
+// toPath returns path to file after change
+func (c *revisionChange) toPath() string {
+	return c.underlying.To.String()
+}
+
+// toContent returns content of the file after change
+func (c *revisionChange) toContent() string {
+	if c.toPath() == "" {
+		return ""
+	}
+	content, err := c.revisionRange.newer.contentOf(c.toPath())
+	if err != nil {
+		panic(err)
 	}
-	return false
+	return content
 }
 
 // code below was copied from go-git as it was private but needed for merkletrie.DiffTree