Merge branch 'merge-thesis_bm' into develop

Author: ibbem

docs/datasets/benjamin-bachelor-thesis.md

@@ -0,0 +1,5 @@
+Project name       | Domain                  | Source code available (**y**es/**n**o)? | Is it a git repository (**y**es/**n**o)? | Repository URL                                               | Clone URL                                          | Estimated number of commits
+-------------------|-------------------------|-----------------------------------------|------------------------------------------|--------------------------------------------------------------|----------------------------------------------------|-----------------------------
+vim                | text editor             | y                                       | y                                        | https://github.com/vim/vim                                   | https://github.com/DiffDetective/vim.git           | 15,274
+busybox            | embedded systems        | y                                       | y                                        | https://git.busybox.net/busybox                              | https://github.com/DiffDetective/busybox           | 17,447
+Marlin             | 3d printing             | y                                       | y                                        | https://github.com/MarlinFirmware/Marlin                     | https://github.com/DiffDetective/Marlin.git        | 19,258

pom.xml

@@ -100,6 +100,19 @@
             <version>1.0-SNAPSHOT</version>
         </dependency>
 
+        <dependency>
+            <groupId>com.github.gumtreediff</groupId>
+            <artifactId>core</artifactId>
+            <version>3.0.0</version>
+        </dependency>
+        <dependency>
+            <!-- For Gumtree -->
+            <groupId>org.atteo.classindex</groupId>
+            <artifactId>classindex</artifactId>
+            <version>3.11</version>
+            <scope>test</scope>
+        </dependency>
+
         <dependency>
             <groupId>net.lingala.zip4j</groupId>
             <artifactId>zip4j</artifactId>
@@ -118,6 +131,12 @@
             <version>3.12.0</version>
         </dependency>
 
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.12.0</version>
+        </dependency>
+
         <dependency>
             <groupId>org.tinylog</groupId>
             <artifactId>tinylog-api</artifactId>

deploy_libs.sh scripts/deploy_libs.shdeploy_libs.sh renamed to scripts/deploy_libs.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 # FeatureIDE
 mvn deploy:deploy-file -DgroupId=de.ovgu -DartifactId=featureide.lib.fm -Dversion=3.8.1 -Durl=file:./local-maven-repo/ -DrepositoryId=local-maven-repo -DupdateReleaseInfo=true -Dfile=./lib/de.ovgu.featureide.lib.fm-v3.8.1.jar

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

@@ -450,6 +450,9 @@ protected void processCommit() throws Exception {
                 }
 
                 processPatch();
+            } catch (Throwable t) {
+                Logger.error("error during {} {}", currentPatch.getFileName(), currentPatch.getCommitHash());
+                throw t;
             } finally {
                 runReverseHook(patchHook, Hooks::endPatch);
             }

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

@@ -32,4 +32,6 @@ public final class MetadataKeys {
 
     public final static String EXPORTED_COMMITS = "exported commits";
     public final static String EXPORTED_TREES = "exported trees";
+
+    public final static String EDIT_CLASS_MOVEMENT = "edit class movement";
 }

src/main/java/org/variantsync/diffdetective/gumtree/DiffTreeAdapter.java

@@ -0,0 +1,30 @@
+package org.variantsync.diffdetective.gumtree;
+
+import org.variantsync.diffdetective.variation.diff.DiffNode;
+import org.variantsync.diffdetective.variation.diff.Projection;
+import org.variantsync.diffdetective.variation.diff.Time;
+import org.variantsync.diffdetective.variation.tree.VariationNode;
+
+/**
+ * Adapter for running Gumtree's matching algorithms on the projections of variation diffs.
+ *
+ * This class is almost identical to {@link VariationTreeAdapter} except that it provides type safe
+ * access to the projected {@link DiffNode}.
+ */
+public class DiffTreeAdapter extends VariationTreeAdapter {
+    public DiffTreeAdapter(DiffNode node, Time time) {
+        super(node.projection(time));
+    }
+
+    public DiffTreeAdapter(Projection node) {
+        super(node);
+    }
+
+    protected VariationTreeAdapter newInstance(VariationNode<?> node) {
+        return new DiffTreeAdapter((Projection)node);
+    }
+
+    public DiffNode getDiffNode() {
+        return ((Projection)getVariationNode()).getBackingNode();
+    }
+}

src/main/java/org/variantsync/diffdetective/gumtree/VariationTreeAdapter.java

@@ -0,0 +1,117 @@
+package org.variantsync.diffdetective.gumtree;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+
+import org.variantsync.diffdetective.variation.tree.VariationNode;
+
+import com.github.gumtreediff.tree.AbstractTree;
+import com.github.gumtreediff.tree.Tree;
+import com.github.gumtreediff.tree.Type;
+import com.github.gumtreediff.tree.TypeSet;
+
+/**
+ * Adapter for running Gumtree's matching algorithms on variation trees.
+ *
+ * This class is an <a href="https://en.wikipedia.org/wiki/Adapter_pattern">adapter</a> for a
+ * snapshot of a variation tree. This means that it doesn't reflect most changes to the underlying
+ * variation tree. Essentially it creates a copy of the tree structure and the labels of a variation
+ * tree by stores a reference to the variation node which it adapts.
+ */
+public class VariationTreeAdapter extends AbstractTree {
+    private String cachedLabel;
+    private VariationNode<?> backingNode;
+
+    public VariationTreeAdapter(VariationNode<?> node) {
+        this.backingNode = node;
+
+        if (backingNode.isConditionalAnnotation()) {
+            cachedLabel = backingNode.getFormula().toString();
+        } else {
+            cachedLabel = backingNode.getLabelLines().stream().collect(Collectors.joining("\n"));
+        }
+
+        var children = new ArrayList<Tree>(node.getChildren().size());
+        for (var child : node.getChildren()) {
+            children.add(newInstance(child));
+        }
+        setChildren(children);
+    }
+
+    protected VariationTreeAdapter newInstance(VariationNode<?> node) {
+        return new VariationTreeAdapter(node);
+    }
+
+    public VariationNode<?> getVariationNode() {
+        return backingNode;
+    }
+
+
+    @Override
+    public String getLabel() {
+        return cachedLabel;
+    }
+
+    /**
+     * Uses line numbers instead of byte indexes.
+     */
+    @Override
+    public int getLength() {
+        return 1;
+    }
+
+    @Override
+    public Iterator<Entry<String, Object>> getMetadata() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Object getMetadata(String arg0) {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Uses line numbers instead of byte indexes.
+     */
+    @Override
+    public int getPos() {
+        return backingNode.getLineRange().fromInclusive();
+    }
+
+    @Override
+    public Type getType() {
+        return TypeSet.type(backingNode.getNodeType().toString());
+    }
+
+    @Override
+    public void setLabel(String label) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void setLength(int length) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Object setMetadata(String name, Object value) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void setPos(int pos) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void setType(Type type) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Tree deepCopy() {
+        throw new UnsupportedOperationException();
+    }
+}

src/main/java/org/variantsync/diffdetective/metadata/Metadata.java

@@ -73,7 +73,7 @@ static <T> T mergeEqual(T a, T b) {
      * @param properties The key-value store to print.
      * @return A string showing all key-value pairs.
      */
-    static String show(final Map<String, ?> properties) {
+    public static String show(final Map<String, ?> properties) {
         StringBuilder result = new StringBuilder();
         for (final Map.Entry<String, ?> property : properties.entrySet()) {
             result.append(show(property.getKey(), property.getValue()));

src/main/java/org/variantsync/diffdetective/preliminary/pattern/semantic/MoveElse.java

@@ -6,6 +6,7 @@
 
 import java.util.Collection;
 import java.util.Optional;
+import java.util.stream.Stream;
 
 import static org.variantsync.diffdetective.variation.diff.Time.AFTER;
 
@@ -37,13 +38,11 @@ public Optional<PatternMatch<DiffNode>> match(DiffNode annotationNode) {
                 return Optional.empty();
             }
 
-            Collection<DiffNode> commonAddElse = annotationNode.getAllChildren();
-            commonAddElse.retainAll(annotationNode.getParent(AFTER).getAllChildren());
+            Collection<DiffNode> annotationChildren = annotationNode.getParent(AFTER).getAllChildrenSet();
+            Stream<DiffNode> commonAddElse = annotationNode.getAllChildrenStream().filter(annotationChildren::contains);
+            Stream<DiffNode> commonRemElse = removedElse.getAllChildrenStream().filter(annotationChildren::contains);
 
-            Collection<DiffNode> commonRemElse = removedElse.getAllChildren();
-            commonRemElse.retainAll(annotationNode.getParent(AFTER).getAllChildren());
-
-            if(commonAddElse.isEmpty() && commonRemElse.isEmpty()){
+            if(commonAddElse.limit(1).count() == 0 && commonRemElse.limit(1).count() == 0){
                 return Optional.empty();
             }
 

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

@@ -64,6 +64,18 @@ public static void assertTrue(boolean cond, String errorMessage) {
         }
     }
 
+    public static void assertFalse(boolean condition) {
+        assertTrue(!condition);
+    }
+
+    public static void assertFalse(boolean condition, final Supplier<String> errorMessage) {
+        assertTrue(!condition, errorMessage);
+    }
+
+    public static void assertFalse(boolean condition, String errorMessage) {
+        assertTrue(!condition, errorMessage);
+    }
+
     /** Throws {@link AssertionError} with {@code errorMessage} as error message. */
     public static void fail(String errorMessage) {
         throw new AssertionError(errorMessage);
@@ -89,7 +101,7 @@ public static <T> void assertEquals(T expected, T actual) {
                 fail("expected is null but actual is not!");
             }
         } else {
-            assertTrue(expected.equals(actual));
+            assertTrue(expected.equals(actual), expected + " != " + actual);
         }
     }
 }