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/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;
     }