Variability-aware patching of software product-line variants

src/main/java/org/variantsync/diffdetective/experiments/thesis_pm/PatchScenario.java

@@ -0,0 +1,40 @@
+package org.variantsync.diffdetective.experiments.thesis_pm;
+
+import org.variantsync.diffdetective.variation.DiffLinesLabel;
+import org.variantsync.diffdetective.variation.Label;
+import org.variantsync.diffdetective.variation.diff.Time;
+import org.variantsync.diffdetective.variation.diff.VariationDiff;
+import org.variantsync.diffdetective.variation.diff.view.DiffView;
+import org.variantsync.diffdetective.variation.tree.VariationTree;
+import org.variantsync.diffdetective.variation.tree.view.TreeView;
+import org.variantsync.diffdetective.variation.tree.view.relevance.Configure;
+import org.variantsync.diffdetective.variation.tree.view.relevance.ConfigureWithFullConfig;
+import org.variantsync.diffdetective.variation.tree.view.relevance.Unchanged;
+
+public class PatchScenario<L extends Label> {
+	public VariationDiff<L> sourcePatch;
+	public VariationTree<L> targetVariantBefore;
+	public VariationDiff<L> patchGroundTruth;
+	public VariationTree<L> patchedVariantGroundTruth;
+	public ConfigureWithFullConfig sourceVariantConfig;
+	public ConfigureWithFullConfig targetVariantConfig;
+	public VariationTree<DiffLinesLabel> sourceVariantAfterRedToCrossVarFeatures;
+	public Unchanged unchangedAfter;
+	public VariationTree<DiffLinesLabel> targetVariantBeforeRedToUnchanged;
+
+	public PatchScenario(VariationDiff<L> sourcePatch,
+			VariationTree<L> targetVariantBefore, VariationDiff<L> patchGroundTruth,
+			VariationTree<L> patchedVariantGroundTruth, ConfigureWithFullConfig sourceVariantConfig, ConfigureWithFullConfig targetVariantConfig) {
+		this.sourcePatch = sourcePatch;
+		this.targetVariantBefore = targetVariantBefore;
+		this.patchGroundTruth = patchGroundTruth;
+		this.patchedVariantGroundTruth = patchedVariantGroundTruth;
+		this.sourceVariantConfig = sourceVariantConfig;
+		this.targetVariantConfig = targetVariantConfig;
+		this.sourceVariantAfterRedToCrossVarFeatures = (VariationTree<DiffLinesLabel>) TreeView.tree(sourcePatch.project(Time.AFTER), this.targetVariantConfig);
+		VariationDiff<DiffLinesLabel> sourcePatchConfiguredToCrossVarFeatures = (VariationDiff<DiffLinesLabel>) DiffView.optimized(sourcePatch, targetVariantConfig);
+		this.unchangedAfter = new Unchanged((VariationDiff<DiffLinesLabel>) sourcePatchConfiguredToCrossVarFeatures, Time.AFTER);		
+		Unchanged unchangedBefore = new Unchanged((VariationDiff<DiffLinesLabel>) sourcePatchConfiguredToCrossVarFeatures, Time.BEFORE);
+		this.targetVariantBeforeRedToUnchanged = (VariationTree<DiffLinesLabel>) TreeView.tree(this.targetVariantBefore, unchangedBefore);
+	}
+}

src/main/java/org/variantsync/diffdetective/experiments/thesis_pm/Utils.java

@@ -0,0 +1,119 @@
+package org.variantsync.diffdetective.experiments.thesis_pm;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.eclipse.jgit.diff.DiffAlgorithm;
+import org.eclipse.jgit.diff.DiffAlgorithm.SupportedAlgorithm;
+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.DiffNode;
+import org.variantsync.diffdetective.variation.diff.VariationDiff;
+import org.variantsync.diffdetective.variation.diff.parse.VariationDiffParseOptions;
+import org.variantsync.diffdetective.variation.tree.VariationTree;
+import org.variantsync.diffdetective.variation.tree.view.TreeView;
+import org.variantsync.diffdetective.variation.tree.view.relevance.ConfigureWithFullConfig;
+import org.variantsync.diffdetective.variation.tree.view.relevance.Unchanged;
+import org.variantsync.functjonal.Pair;
+
+public class Utils {
+
+	public static boolean comparePatchedVariantWithExpectedResult(VariationTree<DiffLinesLabel> patchedVariant,
+			VariationTree<DiffLinesLabel> expectedResult) {
+		return Utils.isSameAs(patchedVariant.toCompletelyUnchangedVariationDiff(),
+				expectedResult.toCompletelyUnchangedVariationDiff());
+	}
+
+	public static Pair<Boolean, Boolean> arePatchedVariantsEquivalent(
+				VariationTree<DiffLinesLabel> patchedTargetVariant,
+				VariationTree<DiffLinesLabel> sourceVariantAfterRedToCrossVarFeatures,
+				VariationTree<DiffLinesLabel> targetVariantBeforeRedToUnchanged, ConfigureWithFullConfig configSourceVariant,
+				Unchanged unchangedAfter) {
+
+			VariationTree<DiffLinesLabel> targetVariantAfterRedToCrossVarFeatures = TreeView.tree(patchedTargetVariant,
+					configSourceVariant);
+
+			VariationTree<DiffLinesLabel> patchedTargetVariantRedToUnchanged = TreeView.tree(patchedTargetVariant,
+					unchangedAfter);
+
+	//		GameEngine.showAndAwaitAll(Show.tree(patchedTargetVariant, "patched target variant"),
+	//				Show.tree(patchedTargetVariantRedToUnchanged, "patched target variant red. to unchanged"),
+	//				Show.tree(sourceVariantAfterRedToCrossVarFeatures,
+	//						"patched source variant red. to cross variant features"),
+	//				Show.tree(targetVariantAfterRedToCrossVarFeatures,
+	//						"patched target variant red. to cross variant features"),
+	//				Show.tree(targetVariantBeforeRedToUnchanged, "target variant before red. to unchanged"));
+
+			return new Pair<Boolean, Boolean>(
+					sourceVariantAfterRedToCrossVarFeatures.unparse().equals(targetVariantAfterRedToCrossVarFeatures.unparse()),
+					patchedTargetVariantRedToUnchanged.unparse().equals(targetVariantBeforeRedToUnchanged.unparse()));
+
+		}
+
+	public static VariationDiff<DiffLinesLabel> parseVariationDiffFromFiles(String file1, String file2)
+			throws IOException, DiffParseException {
+		Path examplesDir = Path.of("data", "examples");
+		return VariationDiff.fromFiles(examplesDir.resolve(file1), examplesDir.resolve(file2),
+				DiffAlgorithm.SupportedAlgorithm.MYERS, VariationDiffParseOptions.Default);
+	}
+
+	public static VariationTree<DiffLinesLabel> parseVariationTreeFromFile(String file) {
+		Path examplesDir = Path.of("data", "examples");
+		Path path = examplesDir.resolve(file);
+		try {
+			VariationTree<DiffLinesLabel> tree = VariationTree.fromFile(path, VariationDiffParseOptions.Default);
+			return tree;
+		} catch (IOException e) {
+			e.printStackTrace();
+		} catch (DiffParseException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+
+	public static VariationDiff<DiffLinesLabel> parseVariationDiffFromFile(String file)
+			throws IOException, DiffParseException {
+		Path examplesDir = Path.of("data", "examples");
+		return VariationDiff.fromFile(examplesDir.resolve(file), VariationDiffParseOptions.Default);
+	}
+
+	public static <L extends Label> boolean isSameAs(VariationDiff<L> diff1, VariationDiff<L> diff2) {
+		return Utils.isSameAs(diff1.getRoot(), diff2.getRoot());
+	}
+
+	public static <L extends Label> boolean isSameAs(DiffNode<L> a, DiffNode<L> b) {
+		return Utils.isSameAs(a, b, new HashSet<>());
+	}
+
+	public static <L extends Label> boolean isSameAs(DiffNode<L> a, DiffNode<L> b, Set<DiffNode<L>> visited) {
+		if (!visited.add(a)) {
+			return true;
+		}
+
+		if (!(a.getNodeType().equals(b.getNodeType()) && hasSameLabel(a.getLabel(), b.getLabel())
+				&& (a.getFormula() == null ? b.getFormula() == null : a.getFormula().equals(b.getFormula())))) {
+			return false;
+		}
+
+		Iterator<DiffNode<L>> aIt = a.getAllChildren().iterator();
+		Iterator<DiffNode<L>> bIt = b.getAllChildren().iterator();
+		while (aIt.hasNext() && bIt.hasNext()) {
+			if (!isSameAs(aIt.next(), bIt.next(), visited)) {
+				return false;
+			}
+		}
+
+		return aIt.hasNext() == bIt.hasNext();
+	}
+
+	public static <L extends Label> boolean hasSameLabel(L a, L b) {
+		String labelA = a.toString().replaceAll(" ", "");
+		String labelB = b.toString().replaceAll(" ", "");
+		return labelA.equals(labelB);
+	}
+
+}

src/main/java/org/variantsync/diffdetective/shell/DiffCommand.java

@@ -0,0 +1,55 @@
+package org.variantsync.diffdetective.shell;
+
+import java.util.List;
+
+/** Single executable command with arguments. */
+public class DiffCommand extends ShellCommand {
+    private final String[] parts;
+    private boolean filesDifferent;
+
+    /**
+     * Constructs a single command.
+     * The first argument has to be a path to an executable which will be given all of the
+     * remaining arguments as parameters on execution.
+     *
+     * @param cmd executable path and arguments for the executable
+     */
+    public DiffCommand(final String... cmd) {
+        parts = cmd;
+    }
+
+    @Override
+    public String[] parts() {
+        return parts;
+    }
+
+    /**
+     * Interpret the result/exit code returned from a shell command.
+     * An {@code ShellException} is thrown if the result code is an error.
+     *
+     * @param resultCode the code that is to be parsed
+     * @param output the output of the shell command
+     * @return the output of the shell command
+     * @throws ShellException if {@code resultCode} is an error
+     */
+    @Override
+    public List<String> interpretResult(int resultCode, List<String> output) throws ShellException {
+    	// inputs are the same
+        if (resultCode == 0) {
+        	filesDifferent = false;
+        	return output;
+        }
+        // if inputs are different
+        if (resultCode == 1) {
+        	filesDifferent = true;
+        	return output;
+        }
+        // everything else: "serious trouble": exit code 2
+        throw new ShellException(output);
+
+    }
+
+	public boolean areFilesDifferent() {
+		return filesDifferent;
+	}
+}

src/main/java/org/variantsync/diffdetective/shell/GnuPatchCommand.java

@@ -0,0 +1,55 @@
+package org.variantsync.diffdetective.shell;
+
+import java.util.List;
+
+/** Single executable command with arguments. */
+public class GnuPatchCommand extends ShellCommand {
+    private final String[] parts;
+    private boolean patchingSuccessful;
+
+    /**
+     * Constructs a single command.
+     * The first argument has to be a path to an executable which will be given all of the
+     * remaining arguments as parameters on execution.
+     *
+     * @param cmd executable path and arguments for the executable
+     */
+    public GnuPatchCommand(final String... cmd) {
+        parts = cmd;
+    }
+
+    @Override
+    public String[] parts() {
+        return parts;
+    }
+
+    /**
+     * Interpret the result/exit code returned from a shell command.
+     * An {@code ShellException} is thrown if the result code is an error.
+     *
+     * @param resultCode the code that is to be parsed
+     * @param output the output of the shell command
+     * @return the output of the shell command
+     * @throws ShellException if {@code resultCode} is an error
+     */
+    @Override
+    public List<String> interpretResult(int resultCode, List<String> output) throws ShellException {
+    	// patching was successful
+        if (resultCode == 0) {
+        	patchingSuccessful = true;
+            return null;
+        }
+        // some hunks cannot be applied or merge conflicts
+        if (resultCode == 1) {
+        	patchingSuccessful = false;
+        	return null;
+        }
+        // everything else: "serious trouble": exit code 2
+        throw new ShellException(output);
+
+    }
+
+	public boolean isPatchingSuccessful() {
+		return patchingSuccessful;
+	}
+}

src/main/java/org/variantsync/diffdetective/shell/MPatchCommand.java

@@ -0,0 +1,55 @@
+package org.variantsync.diffdetective.shell;
+
+import java.util.List;
+
+/** Single executable command with arguments. */
+public class MPatchCommand extends ShellCommand {
+    private final String[] parts;
+    private boolean patchingSuccessful;
+
+    /**
+     * Constructs a single command.
+     * The first argument has to be a path to an executable which will be given all of the
+     * remaining arguments as parameters on execution.
+     *
+     * @param cmd executable path and arguments for the executable
+     */
+    public MPatchCommand(final String... cmd) {
+        parts = cmd;
+    }
+
+    @Override
+    public String[] parts() {
+        return parts;
+    }
+
+    /**
+     * Interpret the result/exit code returned from a shell command.
+     * An {@code ShellException} is thrown if the result code is an error.
+     *
+     * @param resultCode the code that is to be parsed
+     * @param output the output of the shell command
+     * @return the output of the shell command
+     * @throws ShellException if {@code resultCode} is an error
+     */
+    @Override
+    public List<String> interpretResult(int resultCode, List<String> output) throws ShellException {
+    	// patching was successful ???
+        if (resultCode == 0) {
+        	patchingSuccessful = true;
+            return null;
+        }
+        // some hunks cannot be applied or merge conflicts ???
+        if (resultCode == 1) {
+        	patchingSuccessful = false;
+        	return null;
+        }
+        // everything else: "serious trouble": exit code 2 ???
+        throw new ShellException(output);
+
+    }
+
+	public boolean isPatchingSuccessful() {
+		return patchingSuccessful;
+	}
+}

src/main/java/org/variantsync/diffdetective/util/StringUtils.java

@@ -6,7 +6,7 @@
 /** A collection of useful utilities related to string processing. */
 public class StringUtils {
     /** An operating system independent line break used in almost all internal strings. */
-    public final static String LINEBREAK = "\r\n";
+    public final static String LINEBREAK = "\n";
     /** A regex to identify line breaks of any operating system .*/
     public final static Pattern LINEBREAK_REGEX = Pattern.compile("\\r\\n|\\r|\\n");
 

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

@@ -378,16 +378,16 @@ public int count(final Predicate<DiffNode<L>> nodesToCount) {
      * 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<>();
+    public LinkedHashSet<Object> computeAllFeatureNames() {
+        LinkedHashSet<Object> 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);
+        features.removeIf(f -> FixTrueFalse.isTrueLiteral((String) f));
+        features.removeIf(f -> FixTrueFalse.isFalseLiteral((String) f));
         return features;
     }