Use the term 'annotation' instead of 'macro'

Author: ibbem

src/main/java/org/variantsync/diffdetective/diff/difftree/DiffNode.java

@@ -653,7 +653,7 @@ public Lines getLinesAfterEdit() {
      * Returns the formula that is stored in this node.
      * The formula is null for artifact nodes (i.e., {@link NodeType#CODE}).
      * The formula is not null for mapping nodes
-     * @see NodeType#isMacro
+     * @see NodeType#isAnnotation
      */
     public Node getDirectFeatureMapping() {
         return featureMapping;
@@ -927,7 +927,7 @@ public DiffType getDiffType() {
     }
 
     /**
-     * Returns true if this node represents an ELIF macro.
+     * Returns true if this node represents an ELIF annotation.
      * @see NodeType#ELIF
      */
     public boolean isElif() {
@@ -960,7 +960,7 @@ public boolean isEndif() {
     }
 
     /**
-     * Returns true if this node represents an ELSE macro.
+     * Returns true if this node represents an ELSE annotation.
      * @see NodeType#ELSE
      */
     public boolean isElse() {
@@ -975,10 +975,10 @@ public boolean isRoot() {
     }
 
     /**
-     * Returns {@link NodeType#isMacro()} for this node's {@link DiffNode#nodeType}.
+     * Returns {@link NodeType#isAnnotation()} for this node's {@link DiffNode#nodeType}.
      */
-    public boolean isMacro() {
-        return this.nodeType.isMacro();
+    public boolean isAnnotation() {
+        return this.nodeType.isAnnotation();
     }
 
     /**
@@ -1115,7 +1115,7 @@ public String toTextDiff() {
         }
 
         // Add endif after macro
-        if (isMacro()) {
+        if (isAnnotation()) {
             diff
                     .append(toTextDiffLine(this.diffType, List.of(NodeType.ENDIF.asMacroText())))
                     .append(StringUtils.LINEBREAK);

src/main/java/org/variantsync/diffdetective/diff/difftree/DiffTree.java

@@ -214,7 +214,7 @@ public List<DiffNode> computeCodeNodes() {
      * @see DiffTree#computeAllNodesThat
      */
     public List<DiffNode> computeAnnotationNodes() {
-        return computeAllNodesThat(DiffNode::isMacro);
+        return computeAllNodesThat(DiffNode::isAnnotation);
     }
 
     /**

src/main/java/org/variantsync/diffdetective/diff/difftree/NodeType.java

@@ -28,7 +28,7 @@ public enum NodeType {
     /**
      * Returns true iff this node type represents a conditional feature annotation (i.e., if or elif).
      */
-    public boolean isConditionalMacro() {
+    public boolean isConditionalAnnotation() {
         return this == IF || this == ELIF;
     }
 

src/main/java/org/variantsync/diffdetective/diff/difftree/parse/MultiLineMacroParser.java

@@ -82,7 +82,7 @@ ParseResult consume(
         if (continuesMultilineDefinition(line)) {
             // If this multiline macro line is a header...
             final NodeType nodeType = NodeType.ofDiffLine(line);
-            if (nodeType.isConditionalMacro()) {
+            if (nodeType.isConditionalAnnotation()) {
                 // ... create a new multi line macro to complete.
                 if (!isAdd) {
                     if (beforeMLMacro != null) {

src/main/java/org/variantsync/diffdetective/diff/difftree/serialize/nodeformat/DebugDiffNodeFormat.java

@@ -4,14 +4,14 @@
 import org.variantsync.diffdetective.util.FileUtils;
 
 /**
- * Print NodeType and DiffType and Mappings if Macro and Text if Code.
+ * Print NodeType, DiffType and Mappings for Annotations and Text for Code.
  * @author Paul Bittner, Kevin Jedelhauser
  */
 public class DebugDiffNodeFormat implements DiffNodeLabelFormat {
 	@Override
 	public String toLabel(final DiffNode node) {
 		return node.diffType + "_" + node.nodeType + "_\"" +
-				DiffNodeLabelPrettyfier.prettyPrintIfMacroOr(
+				DiffNodeLabelPrettyfier.prettyPrintIfAnnotationOr(
 						node,
 						FileUtils.replaceLineEndings(node.getLabel().trim().replaceAll("\t", "  "), "<br>"))
 				+ "\"";

src/main/java/org/variantsync/diffdetective/diff/difftree/serialize/nodeformat/DiffNodeLabelPrettyfier.java

@@ -9,7 +9,7 @@
  */
 public abstract class DiffNodeLabelPrettyfier {
 	/**
-	 * Auxiliary method for {@link DiffNodeLabelPrettyfier#prettyPrintIfMacroOr(DiffNode, String)}.
+	 * Auxiliary method for {@link DiffNodeLabelPrettyfier#prettyPrintIfAnnotationOr(DiffNode, String)}.
 	 * Returns a string starting with the nodes {@link DiffNode#nodeType}, and its {@link DiffNode#getDirectFeatureMapping()}
      * if it has a formula.
 	 * @param node The {@link DiffNode} to print.
@@ -26,14 +26,14 @@ private static String prettyPrintTypeAndMapping(final DiffNode node) {
 
     /**
      * Invokes {@link #prettyPrintTypeAndMapping(DiffNode)} if the given
-     * node {@link NodeType#isMacro() is a macro}, and returns the elseValue otherwise.
+     * node {@link NodeType#isAnnotation() is an annotation}, and returns the elseValue otherwise.
      * @param node The {@link DiffNode} to prettyprint.
-     * @param elseValue The value to return in case the given node is not a macro.
+     * @param elseValue The value to return in case the given node is not an annotation.
      * @return The generated label.
      */
-    public static String prettyPrintIfMacroOr(final DiffNode node, final String elseValue) {
+    public static String prettyPrintIfAnnotationOr(final DiffNode node, final String elseValue) {
         String result = "";
-        if (node.nodeType.isMacro()) {
+        if (node.nodeType.isAnnotation()) {
             result += prettyPrintTypeAndMapping(node);
         } else {
             result += elseValue;

src/main/java/org/variantsync/diffdetective/diff/difftree/serialize/nodeformat/FormulasAndLineNumbersNodeFormat.java

@@ -3,7 +3,7 @@
 import org.variantsync.diffdetective.diff.difftree.DiffNode;
 
 /**
- * Produces labels of kind <code>fromLine-toLine: NodeType</code>, suffixed by the node's formula if it is a macro.
+ * Produces labels of kind <code>fromLine-toLine: NodeType</code>, suffixed by the node's formula if it is an annotation.
  * The line numbers reference the line numbers in the diff.
  * @see DiffNode#getFromLine()
  * @see DiffNode#getToLine()
@@ -14,7 +14,7 @@ public class FormulasAndLineNumbersNodeFormat implements DiffNodeLabelFormat {
     @Override
     public String toLabel(DiffNode node) {
         final String lineNumbers = node.getFromLine().inDiff + "-" + node.getToLine().inDiff + ": " + node.nodeType;
-        if (node.isMacro()) {
+        if (node.isAnnotation()) {
             return lineNumbers + " " + node.getDirectFeatureMapping();
         }
         return lineNumbers;

src/main/java/org/variantsync/diffdetective/diff/difftree/serialize/nodeformat/MappingsDiffNodeFormat.java

@@ -3,15 +3,15 @@
 import org.variantsync.diffdetective.diff.difftree.DiffNode;
 
 /**
- * Print NodeType and DiffType and Mappings of Macros.
- * The produced label will be <code>NodeType"macro formula"</code> for mapping nodes,
+ * Print NodeType and DiffType and Mappings of Annotations.
+ * The produced label will be <code>NodeType"annotation formula"</code> for mapping nodes,
  * and <code>NodeType""</code> for non-mapping nodes.
- * @see DiffNodeLabelPrettyfier#prettyPrintIfMacroOr(DiffNode, String)
+ * @see DiffNodeLabelPrettyfier#prettyPrintIfAnnotationOr(DiffNode, String)
  * @author Paul Bittner, Kevin Jedelhauser
  */
 public class MappingsDiffNodeFormat implements DiffNodeLabelFormat {
 	@Override
 	public String toLabel(final DiffNode node) {
-		return node.diffType + "_" + node.nodeType + "_\"" + DiffNodeLabelPrettyfier.prettyPrintIfMacroOr(node, "") + "\"";
+		return node.diffType + "_" + node.nodeType + "_\"" + DiffNodeLabelPrettyfier.prettyPrintIfAnnotationOr(node, "") + "\"";
 	}
 }

…sform/CollapseNestedNonEditedMacros.java …/CollapseNestedNonEditedAnnotations.javasrc/main/java/org/variantsync/diffdetective/diff/difftree/transform/CollapseNestedNonEditedMacros.java renamed to src/main/java/org/variantsync/diffdetective/diff/difftree/transform/CollapseNestedNonEditedAnnotations.java src/main/java/org/variantsync/diffdetective/diff/difftree/transform/CollapseNestedNonEditedMacros.java renamed to src/main/java/org/variantsync/diffdetective/diff/difftree/transform/CollapseNestedNonEditedAnnotations.java

@@ -14,19 +14,19 @@
 import java.util.Stack;
 
 /**
- * Collapses chains of nested non-edited macros.
- * Imagine a macro node that is unchanged and has the same parent before and after the edit that
- * is again an unchanged macro node that has the same parent before and after the edit, and so on.
- * Such chains <code>NON_IF -> NON_IF -> NON_IF -> ... -> NON_IF</code> can be collapsed
- * into a single unchanged macro node with the formulas of all nodes combined (by AND).
+ * Collapses chains of nested non-edited annotations.
+ * Imagine a annotation node that is unchanged and has the same parent before and after the edit
+ * that is again an unchanged annotation node that has the same parent before and after the edit,
+ * and so on. Such chains <code>NON_IF -> NON_IF -> NON_IF -> ... -> NON_IF</code> can be collapsed
+ * into a single unchanged annotation node with the formulas of all nodes combined (by AND).
  * This collapse is realized by this transformer.
  *
  * Fun fact: We implemented this transformation because of the
  * <a href="https://scryfall.com/card/2xm/308/wurmcoil-engine">wurmcoil edit in Marlin</a>.
  *
  * @author Paul Bittner
  */
-public class CollapseNestedNonEditedMacros implements DiffTreeTransformer {
+public class CollapseNestedNonEditedAnnotations implements DiffTreeTransformer {
     private final List<Stack<DiffNode>> chainCandidates = new ArrayList<>();
     private final List<Stack<DiffNode>> chains = new ArrayList<>();
 
@@ -66,7 +66,7 @@ private void finalize(Stack<DiffNode> chain) {
     }
 
     private void findChains(DiffTreeTraversal traversal, DiffNode subtree) {
-        if (subtree.isNon() && subtree.isMacro()) {
+        if (subtree.isNon() && subtree.isAnnotation()) {
             if (isHead(subtree)) {
                 final Stack<DiffNode> s = new Stack<>();
                 s.push(subtree);
@@ -114,7 +114,7 @@ private static void collapseChain(Stack<DiffNode> chain) {
                     }
                 }
                 case ROOT, CODE ->
-                    throw new RuntimeException("Unexpected node type " + lastPopped.nodeType + " within macro chain!");
+                    throw new RuntimeException("Unexpected node type " + lastPopped.nodeType + " within annotation chain!");
                 case ENDIF -> {}
             }
         }
@@ -178,6 +178,6 @@ private static boolean isEnd(DiffNode d) {
 
     @Override
     public String toString() {
-        return "CollapseNestedNonEditedMacros";
+        return "CollapseNestedNonEditedAnnotations";
     }
 }

src/main/java/org/variantsync/diffdetective/diff/difftree/transform/FeatureExpressionFilter.java

@@ -17,13 +17,13 @@ public record FeatureExpressionFilter(Predicate<DiffNode> isFeatureAnnotation) i
     public void transform(DiffTree diffTree) {
         final List<DiffNode> illegalNodes = new ArrayList<>();
         diffTree.forAll(node -> {
-            if (node.isMacro() && !isFeatureAnnotation.test(node)) {
+            if (node.isAnnotation() && !isFeatureAnnotation.test(node)) {
                 illegalNodes.add(node);
             }
         });
 
-        for (final DiffNode illegalMacro : illegalNodes) {
-            diffTree.removeNode(illegalMacro);
+        for (final DiffNode illegalAnnotation : illegalNodes) {
+            diffTree.removeNode(illegalAnnotation);
         }
     }
 }