Use the term 'artifact' instead of 'code'

Note the American English spelling.

Author: ibbem

STATUS.md

@@ -28,7 +28,7 @@ The `proofs` Haskell project provides an extended formal specification of our th
 The library is accompanied by a small demo application that shows an example test case for our proof for completeness, by creating a variation tree diff from two variation trees and re-projecting them.
 
 ## Claims
-We claim the _Artifacts Available_ badge as we made our artefacts publicly available on [Github][ddgithub] and [Zenodo][ddzenodo].
+We claim the _Artifacts Available_ badge as we made our artifacts publicly available on [Github][ddgithub] and [Zenodo][ddzenodo].
 
 We claim the _Artifacts Evaluated Reusable_ badge as we implemented DiffDetective as a reusable library (see above).
 Furthermore, both DiffDetective and our Haskell formalization serve as reference implementations if researchers or practitioners want to reimplement our theory in other programming languages.

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

@@ -76,7 +76,7 @@ public class DiffNode {
      * @param nodeType The type of this node (i.e., mapping or artifact).
      * @param fromLines The starting line number of the corresponding text.
      * @param toLines The ending line number of the corresponding text.
-     * @param featureMapping The formula stored in this node. Should be null for code (/artifact) nodes.
+     * @param featureMapping The formula stored in this node. Should be null for artifact nodes.
      * @param label A text label containing information to identify the node (such as the corresponding source code).
      */
     public DiffNode(DiffType diffType, NodeType nodeType,
@@ -123,16 +123,16 @@ public static DiffNode createRoot() {
      * For parameter descriptions, see {@link DiffNode#DiffNode(DiffType, NodeType, DiffLineNumber, DiffLineNumber, Node, String)}.
      * The <code>code</code> parameter will be set as the node's label.
      */
-    public static DiffNode createCode(DiffType diffType, DiffLineNumber fromLines, DiffLineNumber toLines, String code) {
-        return new DiffNode(diffType, NodeType.CODE, fromLines, toLines, null, code);
+    public static DiffNode createArtifact(DiffType diffType, DiffLineNumber fromLines, DiffLineNumber toLines, String code) {
+        return new DiffNode(diffType, NodeType.ARTIFACT, fromLines, toLines, null, code);
     }
 
     /**
-     * The same as {@link DiffNode#createCode(DiffType, DiffLineNumber, DiffLineNumber, String)} but with the code for the label
+     * The same as {@link DiffNode#createArtifact(DiffType, DiffLineNumber, DiffLineNumber, String)} but with the code for the label
      * given as a list of individual lines instead of a single String with linebreaks to identify newlines.
      */
-    public static DiffNode createCode(DiffType diffType, DiffLineNumber fromLines, DiffLineNumber toLines, List<String> lines) {
-        return new DiffNode(diffType, NodeType.CODE, fromLines, toLines, null, lines);
+    public static DiffNode createArtifact(DiffType diffType, DiffLineNumber fromLines, DiffLineNumber toLines, List<String> lines) {
+        return new DiffNode(diffType, NodeType.ARTIFACT, fromLines, toLines, null, lines);
     }
 
     /**
@@ -651,7 +651,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 null for artifact nodes (i.e., {@link NodeType#ARTIFACT}).
      * The formula is not null for mapping nodes
      * @see NodeType#isAnnotation
      */
@@ -693,7 +693,7 @@ public boolean isMultilineMacro() {
      * Returns the full feature mapping formula of this node.
      * The feature mapping of an {@link NodeType#IF} node is its {@link DiffNode#getDirectFeatureMapping direct feature mapping}.
      * The feature mapping of {@link NodeType#ELSE} and {@link NodeType#ELIF} nodes is determined by all formulas in the respective if-elif-else chain.
-     * The feature mapping of an {@link NodeType#CODE artifact} node is the feature mapping of its parent.
+     * The feature mapping of an {@link NodeType#ARTIFACT artifact} node is the feature mapping of its parent.
      * See Equation (1) in our paper (+ its extension to time for variation tree diffs described in Section 3.1).
      * @param parentOf Function that returns the parent of a node.
      *                 This function decides whether the before or after parent should be visited.
@@ -718,14 +718,14 @@ private List<Node> getFeatureMappingClauses(final Function<DiffNode, DiffNode> p
                     and.add(negate(ancestor.getDirectFeatureMapping()));
                 } else {
                     throw new RuntimeException("Expected If or Elif above Else or Elif but got " + ancestor.nodeType + " from " + ancestor);
-                    // Assert.assertTrue(ancestor.isCode());
+                    // Assert.assertTrue(ancestor.isArtifact());
                 }
                 ancestor = parentOf.apply(ancestor);
             }
             and.add(negate(ancestor.getDirectFeatureMapping()));
 
             return and;
-        } else if (isCode()) {
+        } else if (isArtifact()) {
             return parent.getFeatureMappingClauses(parentOf);
         }
 
@@ -747,7 +747,7 @@ private Node getFeatureMapping(Function<DiffNode, DiffNode> parentOf) {
      * Returns the full feature mapping formula of this node before the edit.
      * The feature mapping of an {@link NodeType#IF} node is its {@link DiffNode#getDirectFeatureMapping direct feature mapping}.
      * The feature mapping of {@link NodeType#ELSE} and {@link NodeType#ELIF} nodes is determined by all formulas in the respective if-elif-else chain.
-     * The feature mapping of an {@link NodeType#CODE artifact} node is the feature mapping of its parent.
+     * The feature mapping of an {@link NodeType#ARTIFACT artifact} node is the feature mapping of its parent.
      * See Equation (1) in our paper (+ its extension to time for variation tree diffs described in Section 3.1).
      * @return The feature mapping of this node for the given parent edges.
      */
@@ -759,7 +759,7 @@ public Node getBeforeFeatureMapping() {
      * Returns the full feature mapping formula of this node after the edit.
      * The feature mapping of an {@link NodeType#IF} node is its {@link DiffNode#getDirectFeatureMapping direct feature mapping}.
      * The feature mapping of {@link NodeType#ELSE} and {@link NodeType#ELIF} nodes is determined by all formulas in the respective if-elif-else chain.
-     * The feature mapping of an {@link NodeType#CODE artifact} node is the feature mapping of its parent.
+     * The feature mapping of an {@link NodeType#ARTIFACT artifact} node is the feature mapping of its parent.
      * See Equation (1) in our paper (+ its extension to time for variation tree diffs described in Section 3.1).
      * @return The feature mapping of this node for the given parent edges.
      */
@@ -807,7 +807,7 @@ private List<Node> getPresenceCondition(Function<DiffNode, DiffNode> parentOf) {
             }
 
             return clauses;
-        } else if (isCode()) {
+        } else if (isArtifact()) {
             return parent.getPresenceCondition(parentOf);
         }
 
@@ -944,10 +944,10 @@ public boolean isIf() {
 
     /**
      * Returns true if this node is an artifact node.
-     * @see NodeType#CODE
+     * @see NodeType#ARTIFACT
      */
-    public boolean isCode() {
-        return this.nodeType.equals(NodeType.CODE);
+    public boolean isArtifact() {
+        return this.nodeType.equals(NodeType.ARTIFACT);
     }
 
     /**
@@ -1127,7 +1127,7 @@ public String toTextDiff() {
     @Override
     public String toString() {
         String s;
-        if (isCode()) {
+        if (isArtifact()) {
             s = String.format("%s_%s from %d to %d", diffType, nodeType, from.inDiff, to.inDiff);
         } else if (isRoot()) {
             s = "ROOT";

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

@@ -205,8 +205,8 @@ public List<DiffNode> computeAllNodesThat(final Predicate<DiffNode> property) {
      * Returns all artifact nodes of this DiffTree.
      * @see DiffTree#computeAllNodesThat
      */
-    public List<DiffNode> computeCodeNodes() {
-        return computeAllNodesThat(DiffNode::isCode);
+    public List<DiffNode> computeArtifactNodes() {
+        return computeAllNodesThat(DiffNode::isArtifact);
     }
 
     /**

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

@@ -32,12 +32,12 @@ public static DiffType thatExistsOnlyAt(Time time) {
 
     /**
      * Runs the given procedure depending whether this diff types exists at the respective times.
-     * Runs the first given procedure if the edited artefact existed before the edit (DiffType != ADD).
-     * Runs the second given procedure if the edited artefact exists after the edit (DiffType != REM).
-     * Note: Runs both procedures sequentially if the artefact was not edited and thus
+     * Runs the first given procedure if the edited artifact existed before the edit (DiffType != ADD).
+     * Runs the second given procedure if the edited artifact exists after the edit (DiffType != REM).
+     * Note: Runs both procedures sequentially if the artifact was not edited and thus
      *       exists before and after the edit (DiffType = NON).
-     * @param ifExistsBefore Procedure to run if the edited artefact existed before the edit (DiffType != ADD).
-     * @param ifExistsAfter Procedure to run if the edited artefact exists after the edit (DiffType != REM).
+     * @param ifExistsBefore Procedure to run if the edited artifact existed before the edit (DiffType != ADD).
+     * @param ifExistsAfter Procedure to run if the edited artifact exists after the edit (DiffType != REM).
      */
     public void matchBeforeAfter(final Runnable ifExistsBefore, final Runnable ifExistsAfter) {
         if (this != DiffType.ADD) {
@@ -52,7 +52,7 @@ public void matchBeforeAfter(final Runnable ifExistsBefore, final Runnable ifExi
      * Runs the given task once for each argument that would exist at a certain time if it had this diff type.
      * Runs task on ifExistsBefore if the value existed before the edit (DiffType != ADD).
      * Runs task on ifExistsAfter if the value exists after the edit (DiffType != ADD).
-     * Note: Runs task on both arguments sequentially if the artefact was not edited (DiffType == NON).
+     * Note: Runs task on both arguments sequentially if the artifact was not edited (DiffType == NON).
      *
      * @param ifExistsBefore Argument that is valid if the diff did not add.
      * @param ifExistsAfter Argument that is valid if the edit did not remove.

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

@@ -14,8 +14,8 @@ public enum NodeType {
     ELSE("else"),
     ELIF("elif"),
 
-    // Code types
-    CODE("code"),
+    // Artifact types
+    ARTIFACT("artifact"),
 
     // Extra type for the root
     ROOT("ROOT");
@@ -36,7 +36,7 @@ public boolean isConditionalAnnotation() {
      * Returns true iff this node type represents a feature mapping.
      */
     public boolean isAnnotation() {
-        return this != ROOT && this != CODE;
+        return this != ROOT && this != ARTIFACT;
     }
 
     final static Pattern annotationRegex = Pattern.compile("^[+-]?\\s*#\\s*(if|endif|else|elif)");
@@ -61,7 +61,7 @@ public static NodeType ofDiffLine(String line) {
             }
         }
 
-        return CODE;
+        return ARTIFACT;
     }
 
     /**

src/main/java/org/variantsync/diffdetective/diff/difftree/filter/DiffTreeFilter.java

@@ -28,13 +28,13 @@ public static TaggedPredicate<String, DiffTree> Any() {
 
     /**
      * Returns a tagged predicate that returns true iff
-     * the DiffTree has more than one artifact node ({@link DiffNode#isCode()}.
+     * the DiffTree has more than one artifact node ({@link DiffNode#isArtifact()}.
      * The predicate is tagged with a String description of the predicate.
      */
-    public static TaggedPredicate<String, DiffTree> moreThanOneCodeNode() {
+    public static TaggedPredicate<String, DiffTree> moreThanOneArtifactNode() {
         return new TaggedPredicate<>(
                 "has more than one elementary pattern",
-                tree -> tree.count(DiffNode::isCode) > 1
+                tree -> tree.count(DiffNode::isArtifact) > 1
         );
     }
 
@@ -64,7 +64,7 @@ public static TaggedPredicate<String, DiffTree> consistent() {
 
     /**
      * Returns a tagged predicate that returns true iff
-     * the DiffTree has at least one artifact node ({@link DiffNode#isCode()})
+     * the DiffTree has at least one artifact node ({@link DiffNode#isArtifact()})
      * that does not match any pattern of
      * {@link org.variantsync.diffdetective.pattern.elementary.proposed.ProposedElementaryPatterns#AddToPC},
      * {@link org.variantsync.diffdetective.pattern.elementary.proposed.ProposedElementaryPatterns#RemFromPC},
@@ -75,7 +75,7 @@ public static TaggedPredicate<String, DiffTree> hasAtLeastOneEditToVariability()
         return new TaggedPredicate<>(
                 "has edits to variability",
                 tree -> tree.anyMatch(n ->
-                        n.isCode() && !AddToPC.matches(n) && !RemFromPC.matches(n) && !Untouched.matches(n)
+                        n.isArtifact() && !AddToPC.matches(n) && !RemFromPC.matches(n) && !Untouched.matches(n)
                 )
         );
     }

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

@@ -31,7 +31,7 @@ public DiffNode fromDiffLine(String diffLine) throws IllFormedAnnotationExceptio
         String label = diffLine.isEmpty() ? diffLine : diffLine.substring(1);
         Node featureMapping;
 
-        if (nodeType == NodeType.CODE || nodeType == NodeType.ENDIF || nodeType == NodeType.ELSE) {
+        if (nodeType == NodeType.ARTIFACT || nodeType == NodeType.ENDIF || nodeType == NodeType.ELSE) {
             featureMapping = null;
         } else {
             featureMapping = annotationParser.parseDiffLine(diffLine);

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

@@ -55,7 +55,7 @@ public static DiffResult<DiffTree> createDiffTree(
      *
      * @param fullDiff                  The full diff of a patch obtained from a buffered reader.
      * @param collapseMultipleCodeLines Whether multiple consecutive code lines with the same diff type
-     *                                  should be collapsed into a single code node.
+     *                                  should be collapsed into a single artifact node.
      * @param ignoreEmptyLines          Whether empty lines (no matter if they are added removed
      *                                  or remained unchanged) should be ignored.
      * @param nodeParser                The parser to parse individual lines in the diff to DiffNodes.
@@ -74,7 +74,7 @@ public static DiffResult<DiffTree> createDiffTree(
         final DiffLineNumber lineNo = new DiffLineNumber(0, 0, 0);
         final DiffLineNumber lastLineNo = DiffLineNumber.Copy(lineNo);
 
-        DiffNode lastCode = null;
+        DiffNode lastArtifact = null;
         final AtomicReference<DiffResult<DiffTree>> error = new AtomicReference<>();
         final BiConsumer<DiffError, String> errorPropagation = (errType, message) -> {
             if (error.get() == null) {
@@ -115,8 +115,8 @@ public static DiffResult<DiffTree> createDiffTree(
 
             switch (isMLMacro.type()) {
                 case Success: {
-                    if (lastCode != null) {
-                        lastCode = endCodeBlock(lastCode, lastLineNo);
+                    if (lastArtifact != null) {
+                        lastArtifact = endCodeBlock(lastArtifact, lastLineNo);
                     }
                     // This line belongs to a multiline macro and was handled, so go to the next line.
                     continue;
@@ -139,12 +139,12 @@ public static DiffResult<DiffTree> createDiffTree(
             }
 
             // collapse multiple code lines
-            if (lastCode != null) {
-                if (collapseMultipleCodeLines && newNode.isCode() && lastCode.diffType.equals(newNode.diffType)) {
-                    lastCode.addLines(newNode.getLines());
+            if (lastArtifact != null) {
+                if (collapseMultipleCodeLines && newNode.isArtifact() && lastArtifact.diffType.equals(newNode.diffType)) {
+                    lastArtifact.addLines(newNode.getLines());
                     continue;
                 } else {
-                    lastCode = endCodeBlock(lastCode, lastLineNo);
+                    lastArtifact = endCodeBlock(lastArtifact, lastLineNo);
                 }
             }
 
@@ -154,8 +154,8 @@ public static DiffResult<DiffTree> createDiffTree(
                 nodes.add(newNode);
             }
 
-            if (newNode.isCode()) {
-                lastCode = newNode;
+            if (newNode.isArtifact()) {
+                lastArtifact = newNode;
             } else if (newNode.isEndif()) {
                 final String currentLineFinal = currentLine;
                 diffType.matchBeforeAfter(beforeStack, afterStack,
@@ -187,8 +187,8 @@ public static DiffResult<DiffTree> createDiffTree(
             return DiffResult.Failure(DiffError.NOT_ALL_ANNOTATIONS_CLOSED);
         }
 
-        if (lastCode != null) {
-            lastCode = endCodeBlock(lastCode, lineNo);
+        if (lastArtifact != null) {
+            lastArtifact = endCodeBlock(lastArtifact, lineNo);
         }
 
         endCodeBlock(root, lineNo);

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

@@ -103,7 +103,7 @@ ParseResult consume(
                         /* If this happens (at least) one of this happened
                          * 1. Found line of a multiline macro without header at line " + line + "!
                          * 2. Backslash in a comment.
-                         * 3. It is the head of a multiline #define macro that we classify as code.
+                         * 3. It is the head of a multiline #define macro that we classify as artifact.
                          *
                          * As 2 and 3 are most likely we just assume those.
                          */

src/main/java/org/variantsync/diffdetective/diff/difftree/serialize/TikzExporter.java

@@ -98,7 +98,7 @@ public void exportDiffTree(
                     .joining(" \\\\ "));
 
             output.format("%n\t\\node[%s, %s] (node_%s) at (%s) {};%n",
-                node.isCode() ? "artefact" : "annotation",
+                node.isArtifact() ? "artifact" : "annotation",
                 node.getDiffType().toString().toLowerCase(Locale.ROOT),
                 node.getID(),
                 node.getID());