Skip to content

Commit 184b1c8

Browse files
ibbemibbem
committed
feat: create an interface for and a collection of differs
1 parent af736eb commit 184b1c8

4 files changed

Lines changed: 293 additions & 0 deletions

File tree

‎src/main/java/org/variantsync/diffdetective/variation/diff/Differ.java‎

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
package org.variantsync.diffdetective.variation.diff;
2+
3+
import java.io.FileReader;
4+
import java.io.IOException;
5+
import java.io.Reader;
6+
import java.io.StringReader;
7+
import java.nio.file.Path;
8+
9+
import org.variantsync.diffdetective.diff.result.DiffParseException;
10+
import org.variantsync.diffdetective.util.FileSource;
11+
import org.variantsync.diffdetective.util.Source;
12+
import org.variantsync.diffdetective.variation.Label;
13+
14+
/**
15+
* A generic interface for creating variation diffs from the state before and the state after an
16+
* edit.
17+
*
18+
* @see Differs
19+
*/
20+
@FunctionalInterface
21+
public interface Differ<L extends Label> {
22+
/**
23+
* Create a variation diff by diffing the content of two {@link Reader}s.
24+
* For {@link VariationDiff#getSource() traceability}, both {@link Reader}s are paired with a {@link Source}.
25+
*/
26+
VariationDiff<L> diff(Reader before, Reader after, Source beforeSource, Source afterSource) throws IOException, DiffParseException;
27+
28+
/**
29+
* Create a variation diff by diffing the content of two {@link String}s.
30+
* For {@link VariationDiff#getSource() traceability}, both {@link String}s are paired with a {@link Source}.
31+
*/
32+
default VariationDiff<L> diff(String before, String after, Source beforeSource, Source afterSource) throws IOException, DiffParseException {
33+
return diff(new StringReader(before), new StringReader(after), beforeSource, afterSource);
34+
}
35+
36+
/**
37+
* Create a variation diff by diffing two {@link String}s.
38+
* @see diff(Reader, Reader, Source, Source)
39+
*/
40+
default VariationDiff<L> diff(Path before, Path after) throws IOException, DiffParseException {
41+
try (
42+
Reader beforeStream = new FileReader(before.toFile());
43+
Reader afterStream = new FileReader(after.toFile())
44+
) {
45+
return diff(beforeStream, afterStream, new FileSource(before), new FileSource(after));
46+
}
47+
}
48+
}

‎src/main/java/org/variantsync/diffdetective/variation/diff/Differs.java‎

Lines changed: 133 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,133 @@
1+
package org.variantsync.diffdetective.variation.diff;
2+
3+
import java.io.IOException;
4+
import java.io.Reader;
5+
6+
import org.apache.commons.io.IOUtils;
7+
import org.eclipse.jgit.diff.DiffAlgorithm;
8+
import org.variantsync.diffdetective.diff.result.DiffParseException;
9+
import org.variantsync.diffdetective.util.CompositeSource;
10+
import org.variantsync.diffdetective.util.Source;
11+
import org.variantsync.diffdetective.variation.DiffLinesLabel;
12+
import org.variantsync.diffdetective.variation.diff.construction.GumTreeDiff;
13+
import org.variantsync.diffdetective.variation.diff.construction.JGitDiff;
14+
import org.variantsync.diffdetective.variation.diff.parse.VariationDiffParseOptions;
15+
import org.variantsync.diffdetective.variation.diff.parse.VariationDiffParser; // For Javadoc
16+
import org.variantsync.diffdetective.variation.tree.VariationTree;
17+
18+
import com.github.gumtreediff.matchers.Matcher;
19+
import com.github.gumtreediff.matchers.Matchers;
20+
21+
/**
22+
* A collection of differs that create variation diffs.
23+
* @see Differ
24+
* @see VariationDiff
25+
*/
26+
public class Differs {
27+
/**
28+
* Returns a differ that {@link VariationDiffParser#createVariationDiff parses} a
29+
* {@link VariationDiff} after {@link JGitDiff#textDiff diffing} with
30+
* {@link DiffAlgorithm.SupportedAlgorithm one of JGit's differ}.
31+
*
32+
* @param lineDiffAlgorithm the Git diffing algorithm to use
33+
* @param parseOptions options for parsing the {@link VariationDiff}
34+
* @return the diffed {@link VariationDiff}
35+
*/
36+
public static LineDiffer lineDiffer(DiffAlgorithm.SupportedAlgorithm lineDiffAlgorithm, VariationDiffParseOptions parseOptions) {
37+
return new LineDiffer() {
38+
@Override
39+
public String diffLines(Reader before, Reader after) throws IOException {
40+
return JGitDiff.textDiff(IOUtils.toString(before), IOUtils.toString(after), lineDiffAlgorithm);
41+
}
42+
43+
@Override
44+
public String diffLines(String before, String after) throws IOException {
45+
return JGitDiff.textDiff(before, after, lineDiffAlgorithm);
46+
}
47+
48+
@Override
49+
public VariationDiffParseOptions getParseOptions() {
50+
return parseOptions;
51+
}
52+
};
53+
}
54+
55+
/**
56+
* Calls {@link lineDiffer(DiffAlgorithm.SupportedAlgorithm, VariationDiffParseOptions)} with
57+
* {@link DiffAlgorithm.SupportedAlgorithm.MYERS} and {@link VariationDiffParseOptions.Default}.
58+
*/
59+
public static LineDiffer lineDiffer() {
60+
return lineDiffer(DiffAlgorithm.SupportedAlgorithm.MYERS, VariationDiffParseOptions.Default);
61+
}
62+
63+
/**
64+
* Returns a differ that {@link VariationTree#fromFile parses} two variation trees and then
65+
* {@link GumTreeDiff#diffUsingMatching diffs} these variation trees.
66+
*
67+
* @param parseOptions options for parsing the {@link VariationTree}s
68+
* @param matcher the matcher used for diffing the {@link VariationTree}s
69+
* @return the diffed {@link VariationDiff}
70+
*/
71+
public static TreeDiffer<DiffLinesLabel> treeDiffer(VariationDiffParseOptions parseOptions, Matcher matcher) {
72+
return new TreeDiffer<DiffLinesLabel>() {
73+
@Override
74+
public VariationDiff<DiffLinesLabel> diffTrees(VariationTree<DiffLinesLabel> before, VariationTree<DiffLinesLabel> after) {
75+
return GumTreeDiff.diffUsingMatching(before, after, matcher);
76+
}
77+
78+
@Override
79+
public VariationDiffParseOptions getParseOptions() {
80+
return parseOptions;
81+
}
82+
};
83+
}
84+
85+
/**
86+
* Calls {@link treeDiffer(VariationDiffParseOptions, Matcher)} with {@link
87+
* VariationDiffParseOptions.Default} and {@link Matchers.getInstance().getMatcher()}.
88+
*/
89+
public static TreeDiffer<DiffLinesLabel> treeDiffer() {
90+
return treeDiffer(VariationDiffParseOptions.Default, Matchers.getInstance().getMatcher());
91+
}
92+
93+
/**
94+
* Returns a differ that first parses a {@link VariationDiff} like {@link lineDiffer} and then
95+
* {@link GumTreeDiff#improveMatching improves} the represented matching.
96+
*
97+
* @param lineDiffAlgorithm the Git diffing algorithm to use
98+
* @param parseOptions options for parsing the {@link VariationDiff}
99+
* @param matcher the matcher used for diffing the variation trees
100+
* @return the diffed {@link VariationDiff}
101+
*/
102+
public static LineDiffer hybrid(DiffAlgorithm.SupportedAlgorithm lineDiffAlgorithm, VariationDiffParseOptions parseOptions, Matcher matcher) {
103+
return new LineDiffer() {
104+
@Override
105+
public String diffLines(Reader before, Reader after) throws IOException {
106+
return JGitDiff.textDiff(IOUtils.toString(before), IOUtils.toString(after), lineDiffAlgorithm);
107+
}
108+
109+
@Override
110+
public VariationDiffParseOptions getParseOptions() {
111+
return parseOptions;
112+
}
113+
114+
@Override
115+
public VariationDiff<DiffLinesLabel> diff(Reader before, Reader after, Source beforeSource, Source afterSource) throws IOException, DiffParseException {
116+
VariationDiff<DiffLinesLabel> vd = LineDiffer.super.diff(before, after, beforeSource, afterSource);
117+
return new VariationDiff<>(
118+
GumTreeDiff.improveMatching(vd.getRoot(), matcher),
119+
new CompositeSource("GumTreeDiff.improveMatching", vd.getSource())
120+
);
121+
};
122+
};
123+
}
124+
125+
/**
126+
* Calls {@link treeDiffer(VariationDiffParseOptions, Matcher)} with {@link
127+
* DiffAlgorithm.SupportedAlgorithm.MYERS}, {@link VariationDiffParseOptions.Default}, and
128+
* {@link Matchers.getInstance().getMatcher()}.
129+
*/
130+
public static LineDiffer hybrid() {
131+
return hybrid(DiffAlgorithm.SupportedAlgorithm.MYERS, VariationDiffParseOptions.Default, Matchers.getInstance().getMatcher());
132+
}
133+
}

‎src/main/java/org/variantsync/diffdetective/variation/diff/LineDiffer.java‎

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
package org.variantsync.diffdetective.variation.diff;
2+
3+
import java.io.IOException;
4+
import java.io.Reader;
5+
import java.io.StringReader;
6+
7+
import org.variantsync.diffdetective.diff.result.DiffParseException;
8+
import org.variantsync.diffdetective.util.CompositeSource;
9+
import org.variantsync.diffdetective.util.Source;
10+
import org.variantsync.diffdetective.variation.DiffLinesLabel;
11+
import org.variantsync.diffdetective.variation.diff.parse.VariationDiffParseOptions;
12+
import org.variantsync.diffdetective.variation.diff.parse.VariationDiffParser;
13+
14+
/**
15+
* A {@link Differ} that first creates a line diff and
16+
* {@link VariationDiffParser#createVariationDiff parses} this line diff into a
17+
* {@link VariationDiff}.
18+
*/
19+
@FunctionalInterface
20+
public interface LineDiffer extends Differ<DiffLinesLabel> {
21+
/**
22+
* Returns a line diff of {@code before} and {@code after} in the unified diff format.
23+
*/
24+
String diffLines(Reader before, Reader after) throws IOException;
25+
26+
/**
27+
* Returns a line diff of {@code before} and {@code after} in the unified diff format.
28+
*/
29+
default String diffLines(String before, String after) throws IOException {
30+
return diffLines(new StringReader(before), new StringReader(after));
31+
}
32+
33+
/**
34+
* Returns the options used for {@link parseDiff parsing} the {@link VariationDiff} in {@link parseDiff}.
35+
*/
36+
default VariationDiffParseOptions getParseOptions() {
37+
return VariationDiffParseOptions.Default;
38+
}
39+
40+
/**
41+
* Parses the {@link diffLines line diff} into a {@link VariationDiff} using the options
42+
* from {@link getParseOptions}.
43+
*/
44+
default VariationDiff<DiffLinesLabel> parseDiff(String diff, Source diffSource) throws DiffParseException {
45+
return VariationDiffParser.createVariationDiff(
46+
diff,
47+
new CompositeSource("VariationDiffParser.createVariationDiff", diffSource),
48+
getParseOptions()
49+
);
50+
}
51+
52+
/**
53+
* Composes {@link diffLines} and {@link parseDiff} to create a {@link VariationDiff}.
54+
*/
55+
@Override
56+
default VariationDiff<DiffLinesLabel> diff(Reader before, Reader after, Source beforeSource, Source afterSource) throws IOException, DiffParseException {
57+
return parseDiff(
58+
diffLines(before, after),
59+
new CompositeSource("line diff", beforeSource, afterSource)
60+
);
61+
}
62+
}

‎src/main/java/org/variantsync/diffdetective/variation/diff/TreeDiffer.java‎

Lines changed: 50 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,50 @@
1+
package org.variantsync.diffdetective.variation.diff;
2+
3+
import java.io.BufferedReader;
4+
import java.io.IOException;
5+
import java.io.Reader;
6+
7+
import org.variantsync.diffdetective.diff.result.DiffParseException;
8+
import org.variantsync.diffdetective.util.Source;
9+
import org.variantsync.diffdetective.variation.DiffLinesLabel;
10+
import org.variantsync.diffdetective.variation.Label;
11+
import org.variantsync.diffdetective.variation.diff.parse.VariationDiffParseOptions;
12+
import org.variantsync.diffdetective.variation.tree.VariationTree;
13+
14+
/**
15+
* A {@link Differ} that first {@link VariationTree#fromFile parses} {@link VariationTree}s and
16+
* diffs these trees.
17+
*/
18+
@FunctionalInterface
19+
public interface TreeDiffer<L extends Label> extends Differ<L> {
20+
/**
21+
* Creates a {@link VariationDiff} by diffing two variation trees.
22+
*/
23+
VariationDiff<L> diffTrees(VariationTree<DiffLinesLabel> before, VariationTree<DiffLinesLabel> after);
24+
25+
/**
26+
* Returns the options used for parsing the {@link VariationTree}s in {@link parseTree}.
27+
*/
28+
default VariationDiffParseOptions getParseOptions() {
29+
return VariationDiffParseOptions.Default;
30+
}
31+
32+
/**
33+
* {@link VariationTree#fromFile Parses} {@code input} into a {@link VariationTree} using
34+
* the options from {@code getParseOptions}.
35+
*/
36+
default VariationTree<DiffLinesLabel> parseTree(Reader input, Source source) throws IOException, DiffParseException {
37+
return VariationTree.fromFile(new BufferedReader(input), source, getParseOptions());
38+
}
39+
40+
/**
41+
* Composes {@link parseTree} and {@link diffTrees} to create a {@link VariationDiff}.
42+
*/
43+
@Override
44+
default VariationDiff<L> diff(Reader before, Reader after, Source beforeSource, Source afterSource) throws IOException, DiffParseException {
45+
return diffTrees(
46+
parseTree(before, beforeSource),
47+
parseTree(after, afterSource)
48+
);
49+
}
50+
}

0 commit comments

Comments
 (0)