Merge pull request #173 from VariantSync/variant-generation

Some little features

Author: pmbittner

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

@@ -24,6 +24,7 @@
 import org.variantsync.diffdetective.variation.diff.traverse.VariationDiffTraversal;
 import org.variantsync.diffdetective.variation.diff.traverse.VariationDiffVisitor;
 import org.variantsync.diffdetective.variation.tree.VariationTree;
+import org.variantsync.diffdetective.util.fide.FixTrueFalse;
 import org.variantsync.functjonal.Cast;
 import org.variantsync.functjonal.Result;
 
@@ -34,6 +35,7 @@
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -207,7 +209,7 @@ public static <L extends Label> VariationDiff<L> fromTrees(VariationTree<L> befo
      * The returned value is a deep copy of the variation tree within this diff
      * at the given time.
      * If you instead wish to only have a view on the tree at the given diff
-     * have a look at {@link DiffNode#projection(Time)} for this trees {@link #getRoot() root}.
+     * have a look at {@link DiffNode#projection(Time)} for this tree's {@link #getRoot() root}.
      * @param t The time for which to project the variation tree.
      */
     public VariationTree<L> project(Time t) {
@@ -374,6 +376,24 @@ public int count(final Predicate<DiffNode<L>> nodesToCount) {
         return count.get();
     }
 
+    /**
+     * Returns all variable names occurring in annotations (i.e., formulas of mapping nodes) in this variation diff.
+     * This method is deterministic: It will return the feature names always in the same order, assuming the variation diff is not changed inbetween.
+     * @return A set of every occuring feature name.
+     */
+    public LinkedHashSet<String> computeAllFeatureNames() {
+        LinkedHashSet<String> features = new LinkedHashSet<>();
+        forAll(node -> {
+                if (node.isConditionalAnnotation()) {
+                    features.addAll(node.getFormula().getUniqueContainedFeatures());
+                }
+            });
+        // Since FeatureIDE falsely reports constants "True" and "False" as feature names, we have to remove them from the resulting set.
+        features.removeIf(FixTrueFalse::isTrueLiteral);
+        features.removeIf(FixTrueFalse::isFalseLiteral);
+        return features;
+    }
+
     /**
      * Sets the source of this VariationDiff.
      * @see VariationDiffSource

src/main/java/org/variantsync/diffdetective/variation/tree/view/TreeView.java

@@ -61,15 +61,15 @@ public static <L extends Label> void treeInline(final VariationTree<L> t, final
     /**
      * Creates a view on the given variation tree as described by the given relevance predicate.
      * This function is side-effect free.
-     * Thre given variation tree and relevance will not be altered.
+     * The given variation tree and relevance will not be altered.
      * This function corresponds to Equation 4 in our SPLC'23 paper - Views on Edits to Variational Software.
      * @param t The variation tree to generate a view on.
      * @param r A relevance predicate that determines for each node in the
      *          tree whether it should be contained in the view or should be excluded.
      * @return A variation tree that represents a view on the given variation tree t.
      */
-    public static VariationTree<?> tree(final VariationTree<?> t, final Relevance r) {
-        final VariationTree<?> copy = t.deepCopy();
+    public static <L extends Label> VariationTree<L> tree(final VariationTree<L> t, final Relevance r) {
+        final VariationTree<L> copy = t.deepCopy();
         treeInline(copy, r);
         return copy;
     }

src/main/java/org/variantsync/diffdetective/variation/tree/view/relevance/Configure.java

@@ -4,23 +4,26 @@
 import org.prop4j.NodeWriter;
 import org.variantsync.diffdetective.analysis.logic.SAT;
 import org.variantsync.diffdetective.util.fide.FixTrueFalse;
+import org.variantsync.diffdetective.util.fide.FixTrueFalse.Formula;
 import org.variantsync.diffdetective.variation.tree.VariationNode;
 
+import java.util.Map;
+import java.util.Map.Entry;
 import java.util.function.Consumer;
 
 /**
  * Relevance predicate that generates (partial) variants from variation trees.
  * This relevance predicate is the implementation of Equation 5 in our SPLC'23 paper.
  */
 public class Configure implements Relevance {
-    private final FixTrueFalse.Formula configuration;
+    private final Formula configuration;
 
     /**
      * Same as {@link Configure#Configure(Node)} but with a formula that is witnessed to
      * not contain true or false constants not at the root.
      * Workaround for FeatureIDE bug <a href="https://github.com/FeatureIDE/FeatureIDE/issues/1333">FeatureIDE Issue 1333</a>.
      */
-    public Configure(final FixTrueFalse.Formula configuration) {
+    public Configure(final Formula configuration) {
         this.configuration = configuration;
     }
 
@@ -35,6 +38,39 @@ public Configure(final Node configuration) {
         this(FixTrueFalse.EliminateTrueAndFalse(configuration));
     }
 
+    /**
+     * Create a configuration from an assignment of variable names to boolean values.
+     * The given assignment may be complete or partial.
+     * Internally, a big conjunction of literals is created:
+     * <pre>
+     *           ⋀ f              ∧          ⋀ ¬ f
+     *   (f, true) ∈ assignment    (f, false) ∈ assignment
+     * </pre>
+     *
+     * As an example, suppose the map contains the following entries:
+     * <pre>
+     *   A ↦ true
+     *   B ↦ false
+     *   C ↦ true
+     * </pre>
+     * then we construct a formula A ∧ (¬ B) ∧ C.
+     */
+    public Configure(final Map<String, Boolean> assignment) {
+        // We use commutativity of ∧ to iterate the map only once instead of twice as shown in the formula above.
+        final Formula[] fixedFeatures = new Formula[assignment.size()];
+        int i = 0;
+        for (Entry<String, Boolean> entry : assignment.entrySet()) {
+            fixedFeatures[i] = Formula.var(entry.getKey());
+            if (!entry.getValue()) {
+                fixedFeatures[i] = Formula.not(fixedFeatures[i]);
+            }
+
+            ++i;
+        }
+
+        this.configuration = Formula.and(fixedFeatures);
+    }
+
     @Override
     public boolean test(VariationNode<?, ?> v) {
         return SAT.isSatisfiable(

src/test/java/FeatureNamesTest.java

@@ -0,0 +1,56 @@
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashSet;
+import java.util.List;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.variantsync.diffdetective.diff.result.DiffParseException;
+import org.variantsync.diffdetective.variation.DiffLinesLabel;
+import org.variantsync.diffdetective.variation.Label;
+import org.variantsync.diffdetective.variation.diff.VariationDiff;
+import org.variantsync.diffdetective.variation.diff.parse.VariationDiffParseOptions;
+
+/**
+ * Test for {@link VariationDiff#computeAllFeatureNames()}.
+ */
+public class FeatureNamesTest {
+    private final static Path
+        diffsDir    = Constants.RESOURCE_DIR.resolve("diffs"),
+        pctestDir   = Constants.RESOURCE_DIR.resolve("pctest"),
+        ourDir      = Constants.RESOURCE_DIR.resolve("featurenames"),
+        collapseDir = diffsDir.resolve("collapse"),
+        moveDir     = diffsDir.resolve("move");
+
+    public record TestCase<L extends Label>(String origin, VariationDiff<L> diff, LinkedHashSet<String> features) {
+        public static TestCase<DiffLinesLabel> fromFile(Path p, String... features) throws IOException, DiffParseException {
+            return new TestCase<>(
+                p.toString(),
+                VariationDiff.fromFile(p, VariationDiffParseOptions.Default),
+                new LinkedHashSet<String>(List.of(features))
+            );
+        }
+    };
+
+    private static List<TestCase<DiffLinesLabel>> diffFeatureNameTestCases() throws IOException, DiffParseException {
+        return List.of(
+            TestCase.fromFile(collapseDir.resolve("elif.txt"), "A", "B", "C", "D", "E"),
+            TestCase.fromFile(collapseDir.resolve("simple.txt"), "A", "B", "C"),
+            TestCase.fromFile(moveDir.resolve("simple.txt"), "X", "Y"),
+            TestCase.fromFile(pctestDir.resolve("a.diff"), "A", "D", "E", "B", "C"),
+            TestCase.fromFile(pctestDir.resolve("elif.diff"), "A", "B", "C", "D"),
+            TestCase.fromFile(pctestDir.resolve("else.diff"), "A", "C", "B"),
+            TestCase.fromFile(ourDir.resolve("empty.diff")),
+            TestCase.fromFile(ourDir.resolve("a.diff"), "FIRST", "SECOND"),
+            TestCase.fromFile(ourDir.resolve("b.diff"), "A")
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("diffFeatureNameTestCases")
+    public void testComputeAllFeatureNames(TestCase<DiffLinesLabel> testCase) {
+        assertEquals(testCase.features(), testCase.diff().computeAllFeatureNames(), testCase.origin());
+    }
+}

src/test/resources/featurenames/a.diff

@@ -0,0 +1,6 @@
+ #if FIRST
+   foo
+ #if SECOND
+   bar
+ #endif
+ #endif

src/test/resources/featurenames/b.diff

@@ -0,0 +1,6 @@
+-#if A
+   foo
+ #if A
+   bar
+ #endif
+-#endif

src/test/resources/featurenames/empty.diff

@@ -0,0 +1 @@
+ foo