feat: extract before and after annotations for each line to account for PC changes

Author: AlexanderSchultheiss

src/main/java/org/variantsync/vevos/extraction/BlockAnnotation.java

@@ -19,16 +19,22 @@ public final class BlockAnnotation implements Serializable {
     private static final Pattern variableEnd = Pattern.compile("}");
     private static final Pattern quotation = Pattern.compile("\"");
     private static final Pattern semicolon = Pattern.compile(";");
-    private final String featureMapping;
-    private final String presenceCondition;
+    private final FeatureMapping featureMappingBefore;
+    private final PresenceCondition presenceConditionBefore;
+    private final FeatureMapping featureMappingAfter;
+    private final PresenceCondition presenceConditionAfter;
     private int lineStartInclusive;
     private int lineEndInclusive;
 
-    public BlockAnnotation(int lineStartInclusive, int lineEndInclusive, String featureMapping, String presenceCondition) {
+    public BlockAnnotation(int lineStartInclusive, int lineEndInclusive,
+                           FeatureMapping featureMappingBefore, PresenceCondition presenceConditionBefore,
+                           FeatureMapping featureMappingAfter, PresenceCondition presenceConditionAfter) {
         this.lineStartInclusive = lineStartInclusive;
         this.lineEndInclusive = lineEndInclusive;
-        this.featureMapping = featureMapping;
-        this.presenceCondition = presenceCondition;
+        this.featureMappingBefore = featureMappingBefore;
+        this.presenceConditionBefore = presenceConditionBefore;
+        this.featureMappingAfter = featureMappingAfter;
+        this.presenceConditionAfter = presenceConditionAfter;
     }
 
     public void setLineStartInclusive(int lineStartInclusive) {
@@ -48,32 +54,55 @@ public int lineEndExclusive() {
     }
 
     @Override
-    public boolean equals(Object obj) {
-        if (obj == this) return true;
-        if (obj == null || obj.getClass() != this.getClass()) return false;
-        var that = (BlockAnnotation) obj;
-        return this.lineStartInclusive == that.lineStartInclusive &&
-                this.lineEndInclusive == that.lineEndInclusive &&
-                Objects.equals(this.featureMapping, that.featureMapping) &&
-                Objects.equals(this.presenceCondition, that.presenceCondition);
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        BlockAnnotation that = (BlockAnnotation) o;
+        return lineStartInclusive == that.lineStartInclusive
+                && lineEndInclusive == that.lineEndInclusive
+                && Objects.equals(featureMappingBefore, that.featureMappingBefore)
+                && Objects.equals(presenceConditionBefore, that.presenceConditionBefore)
+                && Objects.equals(featureMappingAfter, that.featureMappingAfter)
+                && Objects.equals(presenceConditionAfter, that.presenceConditionAfter);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(lineStartInclusive, lineEndInclusive, featureMapping, presenceCondition);
+        return Objects.hash(featureMappingBefore, presenceConditionBefore, featureMappingAfter, presenceConditionAfter, lineStartInclusive, lineEndInclusive);
+    }
+
+    public boolean annotationEquals(BlockAnnotation other) {
+        return this.featureMappingBefore.equals(other.featureMappingBefore)
+                && this.featureMappingAfter.equals(other.featureMappingAfter)
+                && this.presenceConditionBefore.equals(other.presenceConditionBefore)
+                && this.presenceConditionAfter.equals(other.presenceConditionAfter);
+    }
+
+    public boolean annotationEquals(LineAnnotation other) {
+        return this.featureMappingBefore.equals(other.featureMappingBefore())
+                && this.featureMappingAfter.equals(other.featureMappingAfter())
+                && this.presenceConditionBefore.equals(other.presenceConditionBefore())
+                && this.presenceConditionAfter.equals(other.presenceConditionAfter());
     }
 
     @Override
     public String toString() {
         return "BlockAnnotation[" +
                 "lineStartInclusive=" + lineStartInclusive + ", " +
                 "lineEndExclusive=" + lineEndInclusive + ", " +
-                "featureMapping=" + featureMapping + ", " +
-                "presenceCondition=" + presenceCondition + ']';
+                "featureMappingBefore=" + featureMappingBefore + ", " +
+                "presenceConditionBefore=" + presenceConditionBefore + ", " +
+                "featureMappingAfter=" + featureMappingAfter + ", " +
+                "presenceConditionAfter=" + presenceConditionAfter + ']';
     }
 
     public String asCSVLine() {
-        return "%s;%s;%d;%d".formatted(normalizeCondition(this.featureMapping), normalizeCondition(this.presenceCondition), this.lineStartInclusive, this.lineEndInclusive);
+        return "%s;%s;%s;%s;%d;%d".formatted(normalizeCondition(this.featureMappingBefore.mapping()),
+                normalizeCondition(this.presenceConditionBefore.condition()),
+                normalizeCondition(this.featureMappingAfter.mapping()),
+                normalizeCondition(this.presenceConditionAfter.condition()),
+                this.lineStartInclusive,
+                this.lineEndInclusive);
     }
 
     /**

src/main/java/org/variantsync/vevos/extraction/FeatureMapping.java

@@ -0,0 +1,9 @@
+package org.variantsync.vevos.extraction;
+
+public record FeatureMapping(String mapping) {
+
+    @Override
+    public String toString() {
+        return mapping;
+    }
+}

src/main/java/org/variantsync/vevos/extraction/FileGT.java

@@ -1,5 +1,6 @@
 package org.variantsync.vevos.extraction;
 
+import org.tinylog.Logger;
 import org.variantsync.diffdetective.util.Assert;
 import org.variantsync.diffdetective.util.LineRange;
 
@@ -12,17 +13,17 @@
 public class FileGT implements Iterable<LineAnnotation>, Serializable {
     // The name of the file (its relative path from the root of the repo)
     protected final String file;
-    // List of annotation for each line
-    private final ArrayList<LineAnnotation> annotations;
     // A matching of this file's lines to counterparts associated with the same commit
     // i.e., the matching line numbers before or after the changes have been applied
     // a match is -1 if there is no counterpart
     protected final ArrayList<Integer> matching;
-    // The set of variables occurring in the annotations of this file
-    private final Set<String> variables;
     // Set of annotation block starts and ends
     protected final HashSet<Integer> blockEnds;
     protected final HashSet<Integer> blockStarts;
+    // List of annotation for each line
+    private final ArrayList<LineAnnotation> annotations;
+    // The set of variables occurring in the annotations of this file
+    private final Set<String> variables;
     // We can only use the before mapping until its being mutated
     protected boolean consumed;
 
@@ -83,7 +84,8 @@ protected LineAnnotation insert(int index, LineAnnotation annotation) {
 
     /**
      * Set the match for the given line number.
-     * @param lineNumber The line number in the current version of the file
+     *
+     * @param lineNumber  The line number in the current version of the file
      * @param matchedLine The matching line number in the counterpart version of the file
      */
     protected void setMatching(int lineNumber, int matchedLine) throws MatchingException {
@@ -92,7 +94,10 @@ protected void setMatching(int lineNumber, int matchedLine) throws MatchingExcep
             return;
         }
         if (this.matching.get(lineNumber) != -1 && this.matching.get(lineNumber) != matchedLine) {
-            throw new MatchingException("line number mismatch for " + this.file + " -- " + lineNumber
+            // TODO: Handle this case
+//            throw new MatchingException("line number mismatch for " + this.file + " -- " + lineNumber
+//                    + " : (" + this.matching.get(lineNumber) + " vs. " + matchedLine + ")");
+            Logger.error("line number mismatch for " + this.file + " -- " + lineNumber
                     + " : (" + this.matching.get(lineNumber) + " vs. " + matchedLine + ")");
         }
         this.matching.set(lineNumber, matchedLine);
@@ -161,7 +166,8 @@ public Mutable insert(LineAnnotation line) {
 
         /**
          * Set the matching of line numbers between current file version and counterpart file version.
-         * @param currentRange The range of lines in the current file version
+         *
+         * @param currentRange     The range of lines in the current file version
          * @param counterpartRange The range of lines in the counterpart file version
          */
         public void setMatching(LineRange currentRange, LineRange counterpartRange) throws MatchingException {
@@ -174,9 +180,9 @@ public void setMatching(LineRange currentRange, LineRange counterpartRange) thro
 
             if (matchedLine != -1) {
                 // If there is a match, the matched regions must have the same size
-                if(endNumber-lineNumber != matchEnd-matchedLine) {
+                if (endNumber - lineNumber != matchEnd - matchedLine) {
                     throw new MatchingException("line number mismatch for file" + this.file + " -- ; " +
-                            "ranges have different size " + (endNumber-lineNumber) + " : " + (matchEnd-matchedLine));
+                            "ranges have different size " + (endNumber - lineNumber) + " : " + (matchEnd - matchedLine));
                 }
                 // Set the matches
                 for (; lineNumber < currentRange.toExclusive(); lineNumber++, matchedLine++) {
@@ -273,7 +279,7 @@ private static String csvMatchingLines(Complete complete) {
         private static ArrayList<BlockAnnotation> aggregateBlocks(Complete complete) {
             ArrayList<BlockAnnotation> blocks = new ArrayList<>();
             // The root annotation is always true and covers all lines
-            BlockAnnotation rootBlock = new BlockAnnotation(1, complete.size(), "True", "True");
+            BlockAnnotation rootBlock = new BlockAnnotation(1, complete.size(), new FeatureMapping("True"), new PresenceCondition("True"), new FeatureMapping("True"), new PresenceCondition("True"));
 
             LinkedList<BlockAnnotation> blockStack = new LinkedList<>();
             blockStack.push(rootBlock);
@@ -282,24 +288,36 @@ private static ArrayList<BlockAnnotation> aggregateBlocks(Complete complete) {
 
                 if (blockStack.isEmpty()) {
                     // Push a new block onto the stack
-                    blockStack.push(new BlockAnnotation(line.lineNumber(), line.lineNumber(), line.featureMapping(), line.presenceCondition()));
-                    continue;
+//                    blockStack.push(new BlockAnnotation(line.lineNumber(), line.lineNumber(), line.featureMappingBefore(),
+//                            line.presenceConditionBefore(), line.featureMappingAfter(), line.presenceConditionAfter()));
+//                    continue;
+                    throw new IllegalStateException();
                 }
 
+                // Does the next line have a different annotation than the current block?
+                boolean annotationChange = !blockStack.peek().annotationEquals(line) && !blockStack.peek().equals(rootBlock);
+
                 // new block, we have to unwind the stack in reverse order to find all completed blocks
-                if (complete.blockEnds.contains(line.lineNumber())) {
+                if (annotationChange) {
                     // The current line is nested in retrieved block
                     // Collect a completed block
                     BlockAnnotation block = blockStack.pop();
                     block.setLineEndInclusive(line.lineNumber() - 1);
                     blocks.add(block);
                 }
 
+                if (blockStack.peek() == null) {
+                    continue;
+                }
+
+                // Does the next line have a different annotation than the current block?
+                annotationChange = !blockStack.peek().annotationEquals(line);
+
                 Assert.assertTrue(blockStack.peekFirst() != null, () -> "%s\nProblem while processing line %d of file %s".formatted(complete.toString(), line.lineNumber(), complete.file));
                 // If the current line is in a new block
-                if (complete.blockStarts.contains(line.lineNumber())) {
+                if (annotationChange) {
                     // Push a new block onto the stack
-                    blockStack.push(new BlockAnnotation(line.lineNumber(), line.lineNumber(), line.featureMapping(), line.presenceCondition()));
+                    blockStack.push(new BlockAnnotation(line.lineNumber(), line.lineNumber(), line.featureMappingBefore(), line.presenceConditionBefore(), line.featureMappingAfter(), line.presenceConditionAfter()));
                 }
             }
             // Unwind the stack fully
@@ -335,7 +353,9 @@ public String csvPCLines() {
          *
          * @return A String with the line matchings in csv format
          */
-        public String csvMatchingLines() { return this.csvMatchingText; }
+        public String csvMatchingLines() {
+            return this.csvMatchingText;
+        }
 
         /**
          * @return The list of block annotations for this file.

src/main/java/org/variantsync/vevos/extraction/GroundTruth.java

@@ -8,18 +8,36 @@
 /**
  * The ground truth for the files of a repository at a specific commit (i.e., version).
  *
- * @param fileGTs The ground truths for each file
+ * @param fileGTs   The ground truths for each file
  * @param variables The set of variables that can appear in the presence conditions
  */
 public record GroundTruth(HashMap<String, FileGT> fileGTs, Set<String> variables)
-                implements Serializable {
+        implements Serializable {
     private static final Pattern variableStart = Pattern.compile("\\$\\{");
     private static final Pattern variableEnd = Pattern.compile("}");
     private static final Pattern quotation = Pattern.compile("\"");
     private static final Pattern semicolon = Pattern.compile(";");
 
+    private static String variablesListAsString(Set<String> variables) {
+        List<String> variablesList = new ArrayList<>(variables);
+        Collections.sort(variablesList);
+
+        StringBuilder sb = new StringBuilder();
+        for (String name : variablesList) {
+            if (name.equals("True") || name.equals("False")) {
+                continue;
+            }
+            name = name.replaceAll(variableStart.pattern(), "");
+            name = name.replaceAll(variableEnd.pattern(), "");
+            name = name.replaceAll(quotation.pattern(), "");
+            name = name.replaceAll(semicolon.pattern(), "SEMICOLON");
+            sb.append(name).append(System.lineSeparator());
+        }
+        return sb.toString();
+    }
+
     public FileGT computeIfAbsent(String file,
-                    Function<? super String, ? extends FileGT> mappingFunction) {
+                                  Function<? super String, ? extends FileGT> mappingFunction) {
         return this.fileGTs.computeIfAbsent(file, mappingFunction);
     }
 
@@ -65,27 +83,9 @@ public String combinedVariablesListAsString(GroundTruth other) {
         return variablesListAsString(variables);
     }
 
-    private static String variablesListAsString(Set<String> variables) {
-        List<String> variablesList = new ArrayList<>(variables);
-        Collections.sort(variablesList);
-
-        StringBuilder sb = new StringBuilder();
-        for (String name : variablesList) {
-            if (name.equals("True") || name.equals("False")) {
-                continue;
-            }
-            name = name.replaceAll(variableStart.pattern(), "");
-            name = name.replaceAll(variableEnd.pattern(), "");
-            name = name.replaceAll(quotation.pattern(), "");
-            name = name.replaceAll(semicolon.pattern(), "SEMICOLON");
-            sb.append(name).append(System.lineSeparator());
-        }
-        return sb.toString();
-    }
-
     public String asPcCsvString() {
         return generateCsv(
-                "Path;File Condition;Block Condition;Presence Condition;start;end",
+                "Path;File Condition;Block Condition Before;Presence Condition Before;Block Condition After;Presence Condition After;start;end",
                 FileGT.Complete::csvPCLines
         );
     }

src/main/java/org/variantsync/vevos/extraction/LineAnnotation.java

@@ -8,28 +8,41 @@
 /**
  * Represents the ground truth annotation for a single line in a file
  * @param lineNumber
- * @param featureMapping
- * @param presenceCondition
+ * @param featureMappingBefore
+ * @param presenceConditionBefore
  * @param nodeType
  */
-public record LineAnnotation(int lineNumber, String featureMapping, String presenceCondition, String nodeType, Set<String> uniqueContainedFeatures) implements Serializable {
-    public final static LineAnnotation EMPTY = new LineAnnotation(-1, "True", "True", "", Collections.singleton("True"));
+public record LineAnnotation(int lineNumber,
+                             FeatureMapping featureMappingBefore, PresenceCondition presenceConditionBefore,
+                             FeatureMapping featureMappingAfter, PresenceCondition presenceConditionAfter,
+                             String nodeType, Set<String> uniqueContainedFeatures) implements Serializable {
+    public final static LineAnnotation EMPTY = new LineAnnotation(-1,
+            new FeatureMapping("True"), new PresenceCondition("True"),
+            new FeatureMapping("True"), new PresenceCondition("True"),
+            "", Collections.singleton("True"));
 
     public int index() {
         return this.lineNumber-1;
     }
 
     public LineAnnotation withOffset(int offset) {
-        return new LineAnnotation(this.lineNumber + offset, this.featureMapping, this.presenceCondition, this.nodeType, this.uniqueContainedFeatures);
+        return new LineAnnotation(this.lineNumber + offset,
+                this.featureMappingBefore, this.presenceConditionBefore,
+                this.featureMappingAfter, this.presenceConditionAfter,
+                this.nodeType, this.uniqueContainedFeatures);
     }
 
     public static LineAnnotation rootAnnotation(int lineNumber) {
-        return new LineAnnotation(lineNumber, "True", "True", "ROOT", Collections.singleton("True"));
+        return new LineAnnotation(lineNumber,
+                new FeatureMapping("True"), new PresenceCondition("True"),
+                new FeatureMapping("True"), new PresenceCondition("True"),
+                "ROOT", Collections.singleton("True"));
     }
 
     @Override
     public String toString() {
-        return "%d, %s, FM =%s, PC = %s".formatted(lineNumber, nodeType, featureMapping, presenceCondition);
+        return "%d, %s, FM Before =%s, PC Before = %s, FM After =%s, PC After =%s".formatted(lineNumber, nodeType,
+                featureMappingBefore, presenceConditionBefore, featureMappingAfter, presenceConditionAfter);
     }
 
 }