Use the term 'edit class' instead of 'elementary edit pattern'

Author: ibbem

src/main/java/org/variantsync/diffdetective/analysis/AnalysisResult.java

@@ -2,10 +2,10 @@
 
 import org.variantsync.diffdetective.diff.difftree.serialize.DiffTreeSerializeDebugData;
 import org.variantsync.diffdetective.diff.result.DiffError;
-import org.variantsync.diffdetective.metadata.ElementaryPatternCount;
+import org.variantsync.diffdetective.metadata.EditClassCount;
 import org.variantsync.diffdetective.metadata.ExplainedFilterSummary;
 import org.variantsync.diffdetective.metadata.Metadata;
-import org.variantsync.diffdetective.pattern.proposed.ProposedElementaryPatterns;
+import org.variantsync.diffdetective.editclass.proposed.ProposedEditClasses;
 import org.variantsync.functjonal.Functjonal;
 import org.variantsync.functjonal.category.InplaceMonoid;
 import org.variantsync.functjonal.category.InplaceSemigroup;
@@ -55,7 +55,7 @@ public class AnalysisResult implements Metadata<AnalysisResult> {
         a.max.set(CommitProcessTime.max(a.max, b.max));
         a.debugData.append(b.debugData);
         a.filterHits.append(b.filterHits);
-        a.elementaryPatternCounts.append(b.elementaryPatternCounts);
+        a.editClassCounts.append(b.editClassCounts);
         MergeMap.putAllValues(a.customInfo, b.customInfo, Semigroup.assertEquals());
         a.diffErrors.append(b.diffErrors);
     };
@@ -80,7 +80,7 @@ public class AnalysisResult implements Metadata<AnalysisResult> {
     public final CommitProcessTime min, max;
     public final DiffTreeSerializeDebugData debugData;
     public ExplainedFilterSummary filterHits;
-    public ElementaryPatternCount elementaryPatternCounts;
+    public EditClassCount editClassCounts;
     private final LinkedHashMap<String, String> customInfo = new LinkedHashMap<>();
     private final MergeMap<DiffError, Integer> diffErrors = new MergeMap<>(new HashMap<>(), Integer::sum);
 
@@ -152,7 +152,7 @@ public AnalysisResult(
         this.runtimeWithMultithreadingInSeconds = runtimeWithMultithreadingInSeconds;
         this.debugData = debugData;
         this.filterHits = filterHits;
-        this.elementaryPatternCounts = new ElementaryPatternCount();
+        this.editClassCounts = new EditClassCount();
         this.min = min;
         this.max = max;
     }
@@ -189,7 +189,7 @@ public static AnalysisResult importFrom(final Path p, final Map<String, BiConsum
         AnalysisResult result = new AnalysisResult();
 
         final List<String> filterHitsLines = new ArrayList<>();
-        final List<String> elementaryPatternCountsLines = new ArrayList<>();
+        final List<String> editClassCountsLines = new ArrayList<>();
 
         try (BufferedReader input = Files.newBufferedReader(p)) {
             // examine each line of the metadata file separately
@@ -229,13 +229,13 @@ public static AnalysisResult importFrom(final Path p, final Map<String, BiConsum
                         // temporary fix for renaming from Unchanged to Untouched
                         final String unchanged = "Unchanged";
                         if (key.startsWith(unchanged)) {
-                            key = ProposedElementaryPatterns.Untouched.getName();
+                            key = ProposedEditClasses.Untouched.getName();
                             line = key + line.substring(unchanged.length());
                         }
 
                         final String finalKey = key;
-                        if (ProposedElementaryPatterns.All.stream().anyMatch(pattern -> pattern.getName().equals(finalKey))) {
-                            elementaryPatternCountsLines.add(line);
+                        if (ProposedEditClasses.All.stream().anyMatch(editClass -> editClass.getName().equals(finalKey))) {
+                            editClassCountsLines.add(line);
                         } else if (key.startsWith(ExplainedFilterSummary.FILTERED_MESSAGE_BEGIN)) {
                             filterHitsLines.add(line);
                         } else if (key.startsWith(ERROR_BEGIN)) {
@@ -257,7 +257,7 @@ public static AnalysisResult importFrom(final Path p, final Map<String, BiConsum
         }
 
         result.filterHits = ExplainedFilterSummary.parse(filterHitsLines);
-        result.elementaryPatternCounts = ElementaryPatternCount.parse(elementaryPatternCountsLines, p.toString());
+        result.editClassCounts = EditClassCount.parse(editClassCountsLines, p.toString());
 
         return result;
     }
@@ -289,7 +289,7 @@ public LinkedHashMap<String, Object> snapshot() {
         snap.putAll(customInfo);
         snap.putAll(debugData.snapshot());
         snap.putAll(filterHits.snapshot());
-        snap.putAll(elementaryPatternCounts.snapshot());
+        snap.putAll(editClassCounts.snapshot());
         snap.putAll(Functjonal.bimap(diffErrors, error -> ERROR_BEGIN + error + ERROR_END, Object::toString));
         return snap;
     }

src/main/java/org/variantsync/diffdetective/analysis/EditClassCount.java

@@ -0,0 +1,46 @@
+package org.variantsync.diffdetective.analysis;
+
+import org.variantsync.diffdetective.editclass.EditClass;
+import org.variantsync.diffdetective.editclass.EditClassCatalogue;
+import org.variantsync.diffdetective.util.CSV;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * Gathers statistics about matching edit classes.
+ * @author Paul Bittner
+ */
+public class EditClassCount implements CSV {
+    private final EditClassCatalogue catalogue;
+    private final Map<EditClass, Integer> editClassCounts;
+
+    /**
+     * Creates a new counter object for the given catalogue of edit classes.
+     * @param catalogue The catalogue whose edit classes to match and count.
+     */
+    public EditClassCount(final EditClassCatalogue catalogue) {
+        this.catalogue = catalogue;
+        this.editClassCounts = new HashMap<>();
+        catalogue.all().forEach(e -> editClassCounts.put(e, 0));
+    }
+
+    /**
+     * Increment the count for the given edit class.
+     * The given edit class is assumed to be part of this counts catalog.
+     * @see EditClassCount#EditClassCount(EditClassCatalogue)
+     * @param editClass The edit class whose count to increase by one.
+     */
+    public void increment(final EditClass editClass) {
+        editClassCounts.computeIfPresent(editClass, (p, i) -> i + 1);
+    }
+
+    @Override
+    public String toCSV(final String delimiter) {
+        return catalogue.all().stream()
+                .map(editClassCounts::get)
+                .map(Object::toString)
+                .collect(Collectors.joining(delimiter));
+    }
+}

src/main/java/org/variantsync/diffdetective/analysis/ElementaryPatternCount.java

@@ -1,29 +1,29 @@
 package org.variantsync.diffdetective.analysis;
 
 import org.variantsync.diffdetective.diff.PatchDiff;
-import org.variantsync.diffdetective.pattern.ElementaryPatternCatalogue;
+import org.variantsync.diffdetective.editclass.EditClassCatalogue;
 import org.variantsync.diffdetective.util.CSV;
 
 /**
  * Statistics for processing a patch in a commit.
  * @param patchDiff The diff of the processed patch.
- * @param elementaryPatternCount Count statistics for the elementary edit patterns matched to the edits in the patch.
+ * @param editClassCount Count statistics for the edit class matched to the edits in the patch.
  * @author Paul Bittner
  */
 public record PatchStatistics(
         PatchDiff patchDiff,
-        ElementaryPatternCount elementaryPatternCount) implements CSV {
+        EditClassCount editClassCount) implements CSV {
     /**
-     * Creates empty patch statistics for the given catalogue of edit patterns.
+     * Creates empty patch statistics for the given catalogue of edit classes.
      * @param patch The patch to gather statistics for.
-     * @param catalogue A catalogue of elementary edit patterns which should be used for classifying edits.
+     * @param catalogue A catalogue of edit classes which should be used for classifying edits.
      */
-    public PatchStatistics(final PatchDiff patch, final ElementaryPatternCatalogue catalogue) {
-        this(patch, new ElementaryPatternCount(catalogue));
+    public PatchStatistics(final PatchDiff patch, final EditClassCatalogue catalogue) {
+        this(patch, new EditClassCount(catalogue));
     }
 
     @Override
     public String toCSV(final String delimiter) {
-        return patchDiff.getCommitHash() + delimiter + patchDiff.getFileName() + delimiter + elementaryPatternCount.toCSV(delimiter);
+        return patchDiff.getCommitHash() + delimiter + patchDiff.getFileName() + delimiter + editClassCount.toCSV(delimiter);
     }
 }

src/main/java/org/variantsync/diffdetective/analysis/PatchStatistics.java

@@ -3,7 +3,7 @@
 import org.variantsync.diffdetective.diff.difftree.DiffNode;
 import org.variantsync.diffdetective.diff.difftree.DiffTree;
 
-import static org.variantsync.diffdetective.pattern.proposed.ProposedElementaryPatterns.*;
+import static org.variantsync.diffdetective.editclass.proposed.ProposedEditClasses.*;
 
 /**
  * A filter on DiffTrees that is equipped with some metadata T (e.g., for debugging or logging).
@@ -33,7 +33,7 @@ public static TaggedPredicate<String, DiffTree> Any() {
      */
     public static TaggedPredicate<String, DiffTree> moreThanOneArtifactNode() {
         return new TaggedPredicate<>(
-                "has more than one elementary pattern",
+                "has more than one artifact node",
                 tree -> tree.count(DiffNode::isArtifact) > 1
         );
     }
@@ -65,10 +65,10 @@ public static TaggedPredicate<String, DiffTree> consistent() {
     /**
      * Returns a tagged predicate that returns true iff
      * the DiffTree has at least one artifact node ({@link DiffNode#isArtifact()})
-     * that does not match any pattern of
-     * {@link org.variantsync.diffdetective.pattern.proposed.ProposedElementaryPatterns#AddToPC},
-     * {@link org.variantsync.diffdetective.pattern.proposed.ProposedElementaryPatterns#RemFromPC},
-     * {@link org.variantsync.diffdetective.pattern.proposed.ProposedElementaryPatterns#Untouched}.
+     * that does not match any edit class of
+     * {@link org.variantsync.diffdetective.editclass.proposed.ProposedEditClasses#AddToPC},
+     * {@link org.variantsync.diffdetective.editclass.proposed.ProposedEditClasses#RemFromPC},
+     * {@link org.variantsync.diffdetective.editclass.proposed.ProposedEditClasses#Untouched}.
      * The predicate is tagged with a String description of the predicate.
      */
     public static TaggedPredicate<String, DiffTree> hasAtLeastOneEditToVariability() {

src/main/java/org/variantsync/diffdetective/diff/difftree/filter/DiffTreeFilter.java

@@ -2,30 +2,30 @@
 
 import org.variantsync.diffdetective.diff.difftree.DiffNode;
 import org.variantsync.diffdetective.diff.difftree.DiffTree;
-import org.variantsync.diffdetective.pattern.ElementaryPatternCatalogue;
+import org.variantsync.diffdetective.editclass.EditClassCatalogue;
 
 import java.util.List;
 
 /**
- * Collapses elementary patterns in a DiffTree.
+ * Collapses edit classes in a DiffTree.
  * Contrary to its name, this transformation leaves a DiffTree's graph structure unchanged.
  * This transformation uses the {@link RelabelNodes} transformer to relabel all nodes.
- * All {@link DiffNode#isArtifact() artifact} nodes will be labeled by their respective elementary pattern.
+ * All {@link DiffNode#isArtifact() artifact} nodes will be labeled by their respective edit class.
  * All other nodes will be labeled by the {@link org.variantsync.diffdetective.diff.difftree.NodeType#name name of their node type}.
  * @author Paul Bittner
  */
-public class CollapseElementaryPatterns implements DiffTreeTransformer {
+public class CollapseEditClasses implements DiffTreeTransformer {
     private final DiffTreeTransformer relabelNodes;
 
     /**
-     * Creates a new transformation that will use the given catalog of elementary patterns
+     * Creates a new transformation that will use the given catalog of edit classes
      * to relabel {@link DiffNode#isArtifact() artifact} nodes.
-     * @param patterns Catalog of patterns to match on artifact nodes.
+     * @param editClasses Catalog of edit classes to match on artifact nodes.
      */
-    public CollapseElementaryPatterns(final ElementaryPatternCatalogue patterns) {
+    public CollapseEditClasses(final EditClassCatalogue editClasses) {
         relabelNodes = new RelabelNodes(d -> {
             if (d.isArtifact()) {
-                return patterns.match(d).getName();
+                return editClasses.match(d).getName();
             } else {
                 return d.nodeType.name;
             }

…ransform/CollapseElementaryPatterns.java …ftree/transform/CollapseEditClasses.javasrc/main/java/org/variantsync/diffdetective/diff/difftree/transform/CollapseElementaryPatterns.java renamed to src/main/java/org/variantsync/diffdetective/diff/difftree/transform/CollapseEditClasses.java src/main/java/org/variantsync/diffdetective/diff/difftree/transform/CollapseElementaryPatterns.java renamed to src/main/java/org/variantsync/diffdetective/diff/difftree/transform/CollapseEditClasses.java

@@ -12,7 +12,7 @@
  * A subtree is unedited, if all nodes in it are unchanged and all nodes have the same
  * before and after parent.
  * Such subtrees just model state but not an edit and thus are removed from the validation
- * of our elementary edit patterns in our ESEC/FSE'22 paper.
+ * of our edit classes in our ESEC/FSE'22 paper.
  * @author Paul Bittner
  */
 public class CutNonEditedSubtrees implements DiffTreeTransformer, DiffTreeVisitor {

src/main/java/org/variantsync/diffdetective/diff/difftree/transform/CutNonEditedSubtrees.java

@@ -1,51 +1,50 @@
-package org.variantsync.diffdetective.pattern;
+package org.variantsync.diffdetective.editclass;
 
 import org.variantsync.diffdetective.diff.difftree.DiffNode;
 import org.variantsync.diffdetective.diff.difftree.DiffTree;
 import org.variantsync.diffdetective.diff.difftree.DiffType;
 import org.variantsync.diffdetective.preliminary.pattern.Pattern;
 
 /**
- * Abstract class for elementary edit pattern according to our ESEC/FSE'22 paper.
+ * Abstract edit class according to our ESEC/FSE'22 paper.
  * @author Paul Bittner, Sören Viegener
  */
-public abstract class ElementaryPattern extends Pattern<DiffNode> {
+public abstract class EditClass extends Pattern<DiffNode> {
     private final DiffType diffType;
 
     /**
-     * Each elementary pattern handles exactly one DiffType.
+     * Each edit class handles exactly one DiffType.
      * @param name unique identifier (see {@link Pattern}).
-     * @param diffType This pattern matches only {@link DiffNode}s of the given {@link DiffType}.
+     * @param diffType This edit class matches only {@link DiffNode}s of the given {@link DiffType}.
      */
-    public ElementaryPattern(final String name, final DiffType diffType) {
+    public EditClass(final String name, final DiffType diffType) {
         super(name);
         this.diffType = diffType;
     }
 
     /**
-     * Returns the diff type nodes must have to be matched to this pattern.
+     * Returns the diff type nodes matched by this edit class.
      */
     public DiffType getDiffType() {
         return diffType;
     }
 
     /**
-     * Returns true iff given node matches this pattern.
-     * @param artifactNode Node which has node type ARTIFACT and whose DiffType is the same as this
-     * patterns DiffType.
+     * Returns true iff the given node matches this edit class.
+     * @param artifactNode Node which has node type ARTIFACT and whose DiffType is the same as {@link getDiffType()}.
      */
     protected abstract boolean matchesArtifactNode(DiffNode artifactNode);
 
     /**
-     * Returns true if this pattern matches the given node and is an artifact.
+     * Returns true if this edit class matches the given node and is an artifact.
      */
     @Override
     public final boolean matches(DiffNode node) {
         return node.isArtifact() && node.diffType == diffType && matchesArtifactNode(node);
     }
 
     /**
-     * Returns true iff this pattern matches at leat one node on the given tree.
+     * Returns true iff this edit class matches at leat one node on the given tree.
      */
     public boolean anyMatch(final DiffTree t) {
         return t.anyMatch(this::matches);