Add diff tool

build.gradle

@@ -66,7 +66,8 @@ ext {
             projects.snapshotTestsXml,
             projects.snapshotTestsJaxbJakarta,
             projects.snapshotTestsNormalize,
-            projects.snapshotTestsDirectoryParams
+            projects.snapshotTestsDirectoryParams,
+            projects.diffTool
     );
 }
 

diff-tool/README.md

@@ -0,0 +1,96 @@
+# Diff-Tool
+
+This is a thin wrapper around `java-diff-utils` which provides the convenience of rendering diffs to a nice human
+readable String.
+
+## Usage
+
+```java
+final String expected = "...";
+final String actual = "...";
+
+// Create a diff using default configuration
+final StringDiff diff1 = StringDiff.simple(expected, actual);
+
+// Render as unified diff
+final String unifiedDiff = diff1.toString();
+// Render as split diff
+final String splitDiff = diff1.toString(SplitDiffRenderer.INSTANCE);
+
+// Test whether compared Strings differed in line separators
+final boolean lineSeparatorDifference = diff1.hasLineSeparatorDifference()
+// Tests whether compared Strings differed in actual text
+final boolean textDifference = diff1.hasTextDifference()
+
+// Create a diff by configuring the java-diff-utils _DiffRowGenerator_
+final DiffAlgorithm diffAlgorithm = DiffUtilsDiffAlgorithm.create(builder -> builder
+        .showInlineDiffs(true)
+        .inlineDiffByWord(true)
+        .ignoreWhiteSpaces(true));
+
+final StringDiff diff2 = StringDiff.using(diffAlgorithm, expected, actual);
+```
+
+## Sample output
+
+Unified Diff:
+```
+[...]
+  6  6   Some unchanged lines6
+  7  7   Some unchanged lines7
+  8  8   Some unchanged lines8
+  9    - This is a test <<senctence>>.
+     9 + This is a test <<for diffutils>>.
+ 10 10   This is the second line.
+ 11 11   Some unchanged lines9
+ 12 12   Some unchanged lines10
+ 13 13   Some unchanged lines11
+ 14 14   Some unchanged lines12
+ 15    - And here is the finish with way more than 80 characters and I'm very curious how this is going to be displayed in split view diff.
+ 16 15   This line is unchanged
+    16 + This line has been added
+ 17 17   Some unchanged lines13
+ 18 18   Some unchanged lines14
+ 19 19   Some unchanged lines15
+[...]
+[...]
+ 22 22   Some unchanged lines18
+ 23 23   Some unchanged lines19
+ 24 24   Some unchanged lines20
+ 25    - <<Another>> <<difference>>
+    25 + <<This>> <<has changed>>
+ 26 26   Some unchanged lines21
+ 27 27   Some unchanged lines22
+ 28 28   Some unchanged lines23
+[...]
+```
+
+Split Diff
+```
+[...]
+  6   Some unchanged lines6                                                                                                              |  6   Some unchanged lines6
+  7   Some unchanged lines7                                                                                                              |  7   Some unchanged lines7
+  8   Some unchanged lines8                                                                                                              |  8   Some unchanged lines8
+  9 ! This is a test <<senctence>>.                                                                                                      |  9 ! This is a test <<for diffutils>>.
+ 10   This is the second line.                                                                                                           | 10   This is the second line.
+ 11   Some unchanged lines9                                                                                                              | 11   Some unchanged lines9
+ 12   Some unchanged lines10                                                                                                             | 12   Some unchanged lines10
+ 13   Some unchanged lines11                                                                                                             | 13   Some unchanged lines11
+ 14   Some unchanged lines12                                                                                                             | 14   Some unchanged lines12
+ 15 - And here is the finish with way more than 80 characters and I'm very curious how this is going to be displayed in split view diff. |
+ 16   This line is unchanged                                                                                                             | 15   This line is unchanged
+                                                                                                                                         | 16 + This line has been added
+ 17   Some unchanged lines13                                                                                                             | 17   Some unchanged lines13
+ 18   Some unchanged lines14                                                                                                             | 18   Some unchanged lines14
+ 19   Some unchanged lines15                                                                                                             | 19   Some unchanged lines15
+[...]
+[...]
+ 22   Some unchanged lines18                                                                                                             | 22   Some unchanged lines18
+ 23   Some unchanged lines19                                                                                                             | 23   Some unchanged lines19
+ 24   Some unchanged lines20                                                                                                             | 24   Some unchanged lines20
+ 25 ! <<Another>> <<difference>>                                                                                                         | 25 ! <<This>> <<has changed>>
+ 26   Some unchanged lines21                                                                                                             | 26   Some unchanged lines21
+ 27   Some unchanged lines22                                                                                                             | 27   Some unchanged lines22
+ 28   Some unchanged lines23                                                                                                             | 28   Some unchanged lines23
+[...]
+```

diff-tool/build.gradle

@@ -0,0 +1,9 @@
+plugins {
+    id("snapshot-tests.published-java-component")
+}
+description = "Diff Tool"
+ext.automaticModuleName = "de.skuzzle.test.snapshots.difftool"
+
+dependencies {
+    api(libs.javadiffutils)
+}

diff-tool/src/main/java/de/skuzzle/difftool/DiffAlgorithm.java

@@ -0,0 +1,8 @@
+package de.skuzzle.difftool;
+
+import java.util.List;
+
+public interface DiffAlgorithm {
+
+    List<DiffLine> diffOf(List<String> left, List<String> right);
+}

diff-tool/src/main/java/de/skuzzle/difftool/DiffLine.java

@@ -0,0 +1,55 @@
+package de.skuzzle.difftool;
+
+import java.util.Objects;
+
+public final class DiffLine {
+
+    private final Type type;
+    private final String oldLine;
+    private final String newLine;
+
+    public DiffLine(Type type, String oldLine, String newLine) {
+        this.type = Objects.requireNonNull(type);
+        this.oldLine = Objects.requireNonNull(oldLine);
+        this.newLine = Objects.requireNonNull(newLine);
+    }
+
+    public enum Type {
+        INSERT,
+        DELETE,
+        CHANGE,
+        EQUAL
+    }
+
+    public Type type() {
+        return type;
+    }
+
+    public String oldLine() {
+        return oldLine;
+    }
+
+    public String newLine() {
+        return newLine;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        final DiffLine diffLine = (DiffLine) o;
+        return type == diffLine.type && oldLine.equals(diffLine.oldLine) && newLine.equals(diffLine.newLine);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(type, oldLine, newLine);
+    }
+
+    @Override
+    public String toString() {
+        return "[" + this.type + "," + this.oldLine + "," + this.newLine + "]";
+    }
+}

diff-tool/src/main/java/de/skuzzle/difftool/DiffRenderer.java

@@ -0,0 +1,18 @@
+package de.skuzzle.difftool;
+
+import java.util.List;
+
+/**
+ * Defines how a diff is rendered as a String.
+ */
+public interface DiffRenderer {
+
+    /**
+     * Creates a String representation of the provided diff.
+     *
+     * @param rows The diff.
+     * @param diffSettings Additional parameters.
+     * @return The String representation.
+     */
+    String renderDiff(List<DiffLine> rows, DiffSettings diffSettings);
+}

diff-tool/src/main/java/de/skuzzle/difftool/DiffSettings.java

@@ -0,0 +1,82 @@
+package de.skuzzle.difftool;
+
+/**
+ * Defines parameters that are used when rendering a diff to String using a
+ * {@link DiffRenderer}.
+ */
+public final class DiffSettings {
+
+    public static final DiffSettings DEFAULT = new DiffSettings(5, 0, DiffSymbols.DEFAULT);
+
+    private final int contextLines;
+    private final int lineNumberOffset;
+    private final DiffSymbols symbols;
+
+    public DiffSettings(int contextLines, int lineNumberOffset, DiffSymbols symbols) {
+        this.contextLines = contextLines;
+        this.lineNumberOffset = lineNumberOffset;
+        this.symbols = symbols;
+    }
+
+    public static DiffSettings withDefaultSymbols(int contextLines, int lineNumberOffset) {
+        return new DiffSettings(contextLines, lineNumberOffset, DiffSymbols.DEFAULT);
+    }
+
+    public int contextLines() {
+        return contextLines;
+    }
+
+    public int lineNumberOffset() {
+        return lineNumberOffset;
+    }
+
+    public DiffSymbols symbols() {
+        return symbols;
+    }
+
+    public static final class DiffSymbols {
+
+        public static DiffSymbols DEFAULT = new DiffSymbols("!", "+", "-", " ", LineSeparator.SYSTEM, "[...]");
+
+        private final String changedLine;
+        private final String addedLine;
+        private final String deletedLine;
+        private final String equalLine;
+        private final LineSeparator newLineCharacter;
+        private final String continuation;
+
+        public DiffSymbols(String changedLine, String addedLine, String deletedLine, String equalLine,
+                LineSeparator newLineCharacter, String continuation) {
+            this.changedLine = changedLine;
+            this.addedLine = addedLine;
+            this.deletedLine = deletedLine;
+            this.equalLine = equalLine;
+            this.newLineCharacter = newLineCharacter;
+            this.continuation = continuation;
+        }
+
+        public String changedLine() {
+            return changedLine;
+        }
+
+        public String addedLine() {
+            return addedLine;
+        }
+
+        public String deletedLine() {
+            return deletedLine;
+        }
+
+        public String equalLine() {
+            return equalLine;
+        }
+
+        public LineSeparator newLineCharacter() {
+            return newLineCharacter;
+        }
+
+        public String continuation() {
+            return continuation;
+        }
+    }
+}

diff-tool/src/main/java/de/skuzzle/difftool/GitLineSeparator.java

@@ -0,0 +1,67 @@
+package de.skuzzle.difftool;
+
+import java.util.Locale;
+
+final class GitLineSeparator {
+
+    static final LineSeparator GIT_LINE_SEPARATOR = determineGitLineSeparator(GitConfig.DEFAULT);
+
+    static LineSeparator determineGitLineSeparator(GitConfig gitConfig) {
+        final String autocrlf = gitConfig.autocrlf();
+        if (autocrlf == null) {
+            return LineSeparator.SYSTEM;
+        }
+        switch (autocrlf.toLowerCase(Locale.ROOT)) {
+        case "true":
+            return LineSeparator.CRLF;
+        case "input":
+            return LineSeparator.LF;
+        case "false":
+            final String eol = gitConfig.eol();
+            if (eol == null) {
+                return LineSeparator.SYSTEM;
+            }
+            switch (eol.toLowerCase(Locale.ROOT)) {
+            case "crlf":
+                return LineSeparator.CRLF;
+            case "lf":
+                return LineSeparator.LF;
+            case "native":
+            default:
+                return LineSeparator.SYSTEM;
+            }
+        }
+        return LineSeparator.SYSTEM;
+    }
+
+    static class GitConfig {
+
+        static final GitConfig DEFAULT = new GitConfig();
+
+        String autocrlf() {
+            return execute("git config core.autocrlf");
+        }
+
+        String eol() {
+            return execute("git config core.eol");
+        }
+
+        static String execute(String command) {
+            try {
+                final Process exec = Runtime.getRuntime().exec(command);
+                try (var err = exec.getErrorStream()) {
+                    err.readAllBytes();
+                }
+                try (var in = exec.getInputStream()) {
+                    return new String(in.readAllBytes());
+                }
+            } catch (Exception e) {
+                return null;
+            }
+        }
+    }
+
+    private GitLineSeparator() {
+        // hidden
+    }
+}