Rename compareUsingMatching to diffUsingMatching

Author: ibbem

src/main/java/org/variantsync/diffdetective/validation/ConstructionValidation.java

@@ -56,7 +56,7 @@
  * This experiment computes the variation diff from
  * <ol>
  * <li>a line matching ({@link DiffTreeParser#createDiffTree Viegener's algorithm}
- * <li>a tree matching computed by Gumtree ({@link DiffTree#compareUsingMatching}
+ * <li>a tree matching computed by Gumtree ({@link DiffTree#diffUsingMatching}
  * <li>a hybrid matching ({@link DiffTree#improveMatching})
  * </ol>
  * compares them using some quality metrics and stores timing statistics.
@@ -288,7 +288,7 @@ public boolean analyzeDiffTree(Analysis analysis) throws Exception, DiffParseExc
             afterVariationTree.assertConsistency();
 
             clock.start();
-            final DiffNode newDiffTreeRoot = DiffTree.compareUsingMatching(
+            final DiffNode newDiffTreeRoot = DiffTree.diffUsingMatching(
                 beforeVariationTree.getRoot().projection(BEFORE),
                 afterVariationTree.getRoot().projection(AFTER),
                 augmentedMatcher(statistics.diffTree[1])

src/main/java/org/variantsync/diffdetective/variation/diff/DiffTree.java

@@ -466,10 +466,10 @@ public String toString() {
      * Create a {@link DiffTree} by matching nodes between {@code before} and {@code after} with the
      * default GumTree matcher.
      *
-     * @see compareUsingMatching(VariationNode, VariationNode, Matcher)
+     * @see diffUsingMatching(VariationNode, VariationNode, Matcher)
      */
-    public static DiffTree compareUsingMatching(VariationTree before, VariationTree after) {
-        DiffNode root = compareUsingMatching(
+    public static DiffTree diffUsingMatching(VariationTree before, VariationTree after) {
+        DiffNode root = diffUsingMatching(
             before.root(),
             after.root(),
             Matchers.getInstance().getMatcher()
@@ -481,19 +481,19 @@ public static DiffTree compareUsingMatching(VariationTree before, VariationTree
     /**
      * Create a {@link DiffNode} by matching nodes between {@code before} and {@code after} with
      * {@code matcher}. The arguments of this function aren't modified (note the
-     * {@link compareUsingMatching(DiffNode, VariationNode, Matcher) overload} which modifies
+     * {@link diffUsingMatching(DiffNode, VariationNode, Matcher) overload} which modifies
      * {@code before} in-place.
      *
      * @param before the variation tree before an edit
      * @param after the variation tree after an edit
-     * @see compareUsingMatching(DiffNode, VariationNode, Matcher)
+     * @see diffUsingMatching(DiffNode, VariationNode, Matcher)
      */
-    public static <A extends VariationNode<A>, B extends VariationNode<B>> DiffNode compareUsingMatching(
+    public static <A extends VariationNode<A>, B extends VariationNode<B>> DiffNode diffUsingMatching(
         VariationNode<A> before,
         VariationNode<B> after,
         Matcher matcher
     ) {
-        return compareUsingMatching(DiffNode.unchanged(before), after, matcher);
+        return diffUsingMatching(DiffNode.unchanged(before), after, matcher);
     }
 
     /**
@@ -510,7 +510,7 @@ public static <A extends VariationNode<A>, B extends VariationNode<B>> DiffNode
      * @param after the variation tree after an edit
      * @see "Constructing Variation Diffs Using Tree Diffing Algorithms"
      */
-    public static <B extends VariationNode<B>> DiffNode compareUsingMatching(
+    public static <B extends VariationNode<B>> DiffNode diffUsingMatching(
         DiffNode before,
         VariationNode<B> after,
         Matcher matcher
@@ -612,7 +612,7 @@ public void improveMatching(Matcher matcher) {
      * Run {@code matcher} on the matching extracted from {@code tree} and modify {@code tree}
      * in-place to reflect the new matching.
      *
-     * This is equivalent to {@code compareUsingMatching} except that the existing implicit matching
+     * This is equivalent to {@code diffUsingMatching} except that the existing implicit matching
      * is {@link extractMatching extracted} and used as basis for the new matching. Hence, this
      * method is mostly an optimisation to avoid a copy of the {@code AFTER} projection of {@code
      * tree}.

src/test/java/TreeDiffing.java

@@ -78,7 +78,7 @@ public void testCase(TestCase testCase) throws IOException, DiffParseException {
         VariationTree beforeEdit = parseVariationTree(testCase.beforeEdit());
         VariationTree afterEdit = parseVariationTree(testCase.afterEdit());
 
-        DiffTree diffTree = DiffTree.compareUsingMatching(beforeEdit, afterEdit);
+        DiffTree diffTree = DiffTree.diffUsingMatching(beforeEdit, afterEdit);
 
         try (var output = IO.newBufferedOutputStream(testCase.actual())) {
             new LineGraphExporter(new Format(new FullNodeFormat(), new ChildOrderEdgeFormat()))