refactor: extract Transformer super interface ...

... from VariationDiffTransformer

Author: pmbittner

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

@@ -3,6 +3,7 @@
 import java.util.Arrays;
 import java.util.List;
 
+import org.variantsync.diffdetective.variation.diff.transform.Transformer;
 import org.variantsync.diffdetective.variation.diff.transform.VariationDiffTransformer;
 import org.variantsync.diffdetective.variation.DiffLinesLabel;
 
@@ -20,7 +21,7 @@ public PreprocessingAnalysis(VariationDiffTransformer<DiffLinesLabel>... preproc
 
     @Override
     public boolean analyzeVariationDiff(Analysis analysis) {
-        VariationDiffTransformer.apply(preprocessors, analysis.getCurrentVariationDiff());
+        Transformer.apply(preprocessors, analysis.getCurrentVariationDiff());
         analysis.getCurrentVariationDiff().assertConsistency();
         return true;
     }

src/main/java/org/variantsync/diffdetective/internal/SimpleRenderer.java

@@ -18,6 +18,7 @@
 import org.variantsync.diffdetective.variation.diff.render.RenderOptions;
 import org.variantsync.diffdetective.variation.diff.render.VariationDiffRenderer;
 import org.variantsync.diffdetective.variation.diff.serialize.nodeformat.MappingsDiffNodeFormat;
+import org.variantsync.diffdetective.variation.diff.transform.Transformer;
 import org.variantsync.diffdetective.variation.diff.transform.VariationDiffTransformer;
 
 import java.io.IOException;
@@ -165,7 +166,7 @@ public static void main(String[] args) throws IOException {
             final List<VariationDiffTransformer<DiffLinesLabel>> transform = VariationDiffMiner.Postprocessing(repository);
             final PatchDiff patch = VariationDiffParser.parsePatch(repository, file, commit);
             Assert.assertNotNull(patch != null);
-            VariationDiffTransformer.apply(transform, patch.getVariationDiff());
+            Transformer.apply(transform, patch.getVariationDiff());
             renderer.render(patch, Path.of("render", repoName), RENDER_OPTIONS_TO_USE);
         }
 

src/main/java/org/variantsync/diffdetective/mining/postprocessing/Postprocessor.java

@@ -7,6 +7,7 @@
 import org.variantsync.diffdetective.variation.diff.filter.ExplainedFilter;
 import org.variantsync.diffdetective.variation.diff.filter.TaggedPredicate;
 import org.variantsync.diffdetective.variation.diff.transform.CutNonEditedSubtrees;
+import org.variantsync.diffdetective.variation.diff.transform.Transformer;
 import org.variantsync.diffdetective.variation.diff.transform.VariationDiffTransformer;
 
 import java.util.List;
@@ -66,7 +67,7 @@ public static <L extends Label> Postprocessor<L> Default() {
     public Result<L> postprocess(final List<VariationDiff<L>> frequentSubgraphs) {
         final List<VariationDiff<L>> processedTrees = frequentSubgraphs.stream()
                 .filter(filters)
-                .peek(tree -> VariationDiffTransformer.apply(transformers, tree))
+                .peek(tree -> Transformer.apply(transformers, tree))
                 .toList();
 
         final Map<String, Integer> filterCounts = new ExplainedFilterSummary(filters).snapshot();

src/main/java/org/variantsync/diffdetective/variation/diff/transform/CollapseNestedNonEditedAnnotations.java

@@ -36,7 +36,7 @@ public class CollapseNestedNonEditedAnnotations implements VariationDiffTransfor
     private final List<Stack<DiffNode<DiffLinesLabel>>> chains = new ArrayList<>();
 
     @Override
-    public List<Class<? extends VariationDiffTransformer<DiffLinesLabel>>> getDependencies() {
+    public List<Class<? extends Transformer<VariationDiff<DiffLinesLabel>>>> getDependencies() {
         return List.of(Cast.unchecked(CutNonEditedSubtrees.class));
     }
 

src/main/java/org/variantsync/diffdetective/variation/diff/transform/LabelWithEditClass.java

@@ -39,7 +39,7 @@ public void transform(VariationDiff<DiffLinesLabel> variationDiff) {
     }
 
     @Override
-    public List<Class<? extends VariationDiffTransformer<DiffLinesLabel>>> getDependencies() {
+    public List<Class<? extends Transformer<VariationDiff<DiffLinesLabel>>>> getDependencies() {
         return relabelNodes.getDependencies();
     }
 }

src/main/java/org/variantsync/diffdetective/variation/diff/transform/Transformer.java

@@ -0,0 +1,70 @@
+package org.variantsync.diffdetective.variation.diff.transform;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Models an operation that changes an object of type T inplace (i.e., the object is altered).
+ * To model further assumptions on the given elements T (i.e., assumptions that cannot easily be expressed as a type),
+ * Transformers may have dependencies to other transformers, which should be applied first.
+ */
+public interface Transformer<T> {
+    /**
+     * Apply a transformation to the given Object inplace.
+     * The object will be changed.
+     * @param element The T object to transform.
+     */
+    void transform(final T element);
+
+    /**
+     * Returns a list of dependencies to other transformers.
+     * A transformer should only be run, if another transformation with the respective type was run for each type on the dependencies.
+     * @return List of types of which instances should be run before applying this transformation.
+     */
+    default List<Class<? extends Transformer<T>>> getDependencies() {
+        return new ArrayList<>(0);
+    }
+
+    /**
+     * Checks that the dependencies of all given transformers are satisfied when
+     * applying the transformers sequentially.
+     * @param transformers The transformers whose dependencies to check.
+     * @throws RuntimeException when a dependency is not met.
+     */
+    static <T> void checkDependencies(final List<? extends Transformer<T>> transformers) {
+        for (int i = transformers.size() - 1; i >= 0; --i) {
+            final Transformer<T> currentTransformer = transformers.get(i);
+            final List<Class<? extends Transformer<T>>> currentDependencies = currentTransformer.getDependencies();
+            for (final Class<? extends Transformer<T>> dependency : currentDependencies) {
+                boolean dependencyMet = false;
+                for (int j = i - 1; j >= 0; --j) {
+                    if (dependency.isInstance(transformers.get(j))) {
+                        dependencyMet = true;
+                        break;
+                    }
+                }
+                if (!dependencyMet) {
+                    throw new RuntimeException("Dependency not met! Transformer "
+                            + currentTransformer
+                            + " requires a transformer of type "
+                            + dependency
+                            + " applied before!");
+                }
+            }
+        }
+    }
+
+    /**
+     * Applies all given transformers to the given element sequentially.
+     * First checks that all dependencies between transformers are met via {@link #checkDependencies(List)}.
+     * @param transformers Transformers to apply sequentially.
+     * @param tree Tree to transform inplace.
+     */
+    static <T> void apply(final List<? extends Transformer<T>> transformers, final T element) {
+        checkDependencies(transformers);
+        for (final Transformer<T> t : transformers) {
+            t.transform(element);
+        }
+    }
+
+}

src/main/java/org/variantsync/diffdetective/variation/diff/transform/VariationDiffTransformer.java

@@ -3,70 +3,10 @@
 import org.variantsync.diffdetective.variation.Label;
 import org.variantsync.diffdetective.variation.diff.VariationDiff;
 
-import java.util.ArrayList;
-import java.util.List;
-
 /**
  * Interface that represents inplace transformations of VariationDiffs.
  * A VariationDiffTransformer is intended to alter a given VariationDiff.
  * @author Paul Bittner
  */
-public interface VariationDiffTransformer<L extends Label> {
-    /**
-     * Apply a transformation to the given VariationDiff inplace.
-     * The given tree will be changed.
-     * @param variationDiff The VariationDiff to transform.
-     */
-    void transform(final VariationDiff<L> variationDiff);
-
-    /**
-     * Returns a list of dependencies to other transformers.
-     * A transformer should only be run, if another transformation with the respective type was run for each type on the dependencies.
-     * @return List of types of which instances should be run before applying this transformation.
-     */
-    default List<Class<? extends VariationDiffTransformer<L>>> getDependencies() {
-        return new ArrayList<>(0);
-    }
-
-    /**
-     * Checks that the dependencies of all given VariationDiffTransformers are satisfied when
-     * applying the transformers sequentially.
-     * @param transformers The transformers whose dependencies to check.
-     * @throws RuntimeException when a dependency is not met.
-     */
-    static <L extends Label> void checkDependencies(final List<VariationDiffTransformer<L>> transformers) {
-        for (int i = transformers.size() - 1; i >= 0; --i) {
-            final VariationDiffTransformer<L> currentTransformer = transformers.get(i);
-            final List<Class<? extends VariationDiffTransformer<L>>> currentDependencies = currentTransformer.getDependencies();
-            for (final Class<? extends VariationDiffTransformer<L>> dependency : currentDependencies) {
-                boolean dependencyMet = false;
-                for (int j = i - 1; j >= 0; --j) {
-                    if (dependency.isInstance(transformers.get(j))) {
-                        dependencyMet = true;
-                        break;
-                    }
-                }
-                if (!dependencyMet) {
-                    throw new RuntimeException("Dependency not met! VariationDiffTransformer "
-                            + currentTransformer
-                            + " requires a transformer of type "
-                            + dependency
-                            + " applied before!");
-                }
-            }
-        }
-    }
-
-    /**
-     * Applies all given transformers to the given VariationDiff sequentially.
-     * First checks that all dependencies between transformers are met via {@link #checkDependencies(List)}.
-     * @param transformers Transformers to apply sequentially.
-     * @param tree Tree to transform inplace.
-     */
-    static <L extends Label> void apply(final List<VariationDiffTransformer<L>> transformers, final VariationDiff<L> tree) {
-        checkDependencies(transformers);
-        for (final VariationDiffTransformer<L> t : transformers) {
-            t.transform(tree);
-        }
-    }
+public interface VariationDiffTransformer<L extends Label> extends Transformer<VariationDiff<L>> {
 }