This is an automated email from the ASF dual-hosted git repository.

slachiewicz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven-dependency-tree.git


The following commit(s) were added to refs/heads/master by this push:
     new 3abaa09  Add value-based equals/hashCode to DefaultDependencyNode, 
make getChildren() unmodifiable
3abaa09 is described below

commit 3abaa096110fdbd2ae373d76769f63a3dae8f19d
Author: Arturo Bernal <[email protected]>
AuthorDate: Tue Nov 10 07:11:47 2026 +0100

    Add value-based equals/hashCode to DefaultDependencyNode, make 
getChildren() unmodifiable
    
    DefaultDependencyNode never overrode equals()/hashCode(), so nodes
    compared by identity even when describing the same dependency across
    different builds of a tree. equals()/hashCode() are now based on the
    node's artifact coordinates only, not parent/children, avoiding
    recursion through those back-references.
    
    getChildren() returned the internal mutable list, letting callers
    corrupt the graph by adding/removing/replacing children behind the
    node's back. It now returns an unmodifiable view.
    
    BuildingDependencyNodeVisitor relied on mutating that list directly
    (parentNode.getChildren().add(newNode)) while cloning a tree, so it
    now accumulates each node's children internally and assigns them
    with setChildren() once the node is fully visited.
    
    Fixes #138
---
 .../graph/internal/DefaultDependencyNode.java      | 25 +++++++++++++-
 .../traversal/BuildingDependencyNodeVisitor.java   | 21 +++++++++---
 .../graph/internal/DefaultDependencyNodeTest.java  | 40 ++++++++++++++++++++++
 3 files changed, 80 insertions(+), 6 deletions(-)

diff --git 
a/src/main/java/org/apache/maven/shared/dependency/graph/internal/DefaultDependencyNode.java
 
b/src/main/java/org/apache/maven/shared/dependency/graph/internal/DefaultDependencyNode.java
index bd33d09..28f11d0 100644
--- 
a/src/main/java/org/apache/maven/shared/dependency/graph/internal/DefaultDependencyNode.java
+++ 
b/src/main/java/org/apache/maven/shared/dependency/graph/internal/DefaultDependencyNode.java
@@ -18,7 +18,9 @@
  */
 package org.apache.maven.shared.dependency.graph.internal;
 
+import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.model.Exclusion;
@@ -134,7 +136,7 @@ public class DefaultDependencyNode implements 
DependencyNode {
      */
     @Override
     public List<DependencyNode> getChildren() {
-        return children;
+        return children == null ? null : 
Collections.unmodifiableList(children);
     }
 
     /**
@@ -177,4 +179,25 @@ public class DefaultDependencyNode implements 
DependencyNode {
     public String toNodeString() {
         return artifact + (Boolean.TRUE.equals(optional) ? " (optional)" : "");
     }
+
+    /**
+     * Nodes are compared by artifact coordinates only, not by 
parent/children, so that two nodes describing the
+     * same dependency are considered equal even when they come from different 
builds of the same tree (e.g. a tree
+     * rebuilt by {@link 
org.apache.maven.shared.dependency.graph.traversal.BuildingDependencyNodeVisitor}).
+     */
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof DefaultDependencyNode)) {
+            return false;
+        }
+        return Objects.equals(artifact, ((DefaultDependencyNode) 
obj).artifact);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(artifact);
+    }
 }
diff --git 
a/src/main/java/org/apache/maven/shared/dependency/graph/traversal/BuildingDependencyNodeVisitor.java
 
b/src/main/java/org/apache/maven/shared/dependency/graph/traversal/BuildingDependencyNodeVisitor.java
index e2f3537..326827e 100644
--- 
a/src/main/java/org/apache/maven/shared/dependency/graph/traversal/BuildingDependencyNodeVisitor.java
+++ 
b/src/main/java/org/apache/maven/shared/dependency/graph/traversal/BuildingDependencyNodeVisitor.java
@@ -19,6 +19,9 @@
 package org.apache.maven.shared.dependency.graph.traversal;
 
 import java.util.ArrayList;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
 import java.util.Stack;
 
 import org.apache.maven.shared.dependency.graph.DependencyNode;
@@ -41,7 +44,13 @@ public class BuildingDependencyNodeVisitor implements 
DependencyNodeVisitor {
     /**
      * The resultant tree parent nodes for the currently visited node.
      */
-    private final Stack<DependencyNode> parentNodes;
+    private final Stack<DefaultDependencyNode> parentNodes;
+
+    /**
+     * The children accumulated so far for each node of the resultant tree, 
keyed by node identity since the clones
+     * are not yet complete (and so not yet safe to use as value-based map 
keys) while a node is still being built.
+     */
+    private final Map<DefaultDependencyNode, List<DependencyNode>> 
childrenByNode;
 
     /**
      * The root node of the resultant tree.
@@ -68,6 +77,7 @@ public class BuildingDependencyNodeVisitor implements 
DependencyNodeVisitor {
         this.visitor = visitor;
 
         parentNodes = new Stack<>();
+        childrenByNode = new IdentityHashMap<>();
     }
 
     // DependencyNodeVisitor methods ------------------------------------------
@@ -86,13 +96,12 @@ public class BuildingDependencyNodeVisitor implements 
DependencyNodeVisitor {
                 node.getVersionConstraint(),
                 node.getOptional(),
                 node.getExclusions());
-        newNode.setChildren(new ArrayList<>());
 
         if (parentNodes.empty()) {
             rootNode = newNode;
         } else {
-            DependencyNode parentNode = parentNodes.peek();
-            parentNode.getChildren().add(newNode);
+            DefaultDependencyNode parentNode = parentNodes.peek();
+            childrenByNode.computeIfAbsent(parentNode, key -> new 
ArrayList<>()).add(newNode);
         }
 
         parentNodes.push(newNode);
@@ -105,7 +114,9 @@ public class BuildingDependencyNodeVisitor implements 
DependencyNodeVisitor {
      */
     @Override
     public boolean endVisit(DependencyNode node) {
-        parentNodes.pop();
+        DefaultDependencyNode newNode = parentNodes.pop();
+        newNode.setChildren(childrenByNode.getOrDefault(newNode, new 
ArrayList<>()));
+        childrenByNode.remove(newNode);
 
         // apply the visitor to the resultant tree on the last visit
         if (parentNodes.empty() && visitor != null) {
diff --git 
a/src/test/java/org/apache/maven/shared/dependency/graph/internal/DefaultDependencyNodeTest.java
 
b/src/test/java/org/apache/maven/shared/dependency/graph/internal/DefaultDependencyNodeTest.java
index c900b7c..39fd2e0 100644
--- 
a/src/test/java/org/apache/maven/shared/dependency/graph/internal/DefaultDependencyNodeTest.java
+++ 
b/src/test/java/org/apache/maven/shared/dependency/graph/internal/DefaultDependencyNodeTest.java
@@ -18,12 +18,17 @@
  */
 package org.apache.maven.shared.dependency.graph.internal;
 
+import java.util.ArrayList;
+
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.artifact.DefaultArtifact;
 import org.junit.jupiter.api.Test;
 
 import static java.util.Collections.emptyList;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 class DefaultDependencyNodeTest {
 
@@ -42,4 +47,39 @@ class DefaultDependencyNodeTest {
                 new DefaultDependencyNode(null, artifact, "1.0", "compile", 
"1.0", false, emptyList());
         assertEquals("group:artifact:jar:1.2:compile", 
optionalNode.toNodeString());
     }
+
+    @Test
+    void nodesWithTheSameArtifactAreEqualEvenWhenNotTheSameInstance() {
+        DefaultDependencyNode node = new DefaultDependencyNode(null, artifact, 
null, null, null, false, emptyList());
+        DefaultDependencyNode sameCoordinates =
+                new DefaultDependencyNode(null, artifact, null, null, null, 
false, emptyList());
+
+        assertEquals(node, sameCoordinates);
+        assertEquals(node.hashCode(), sameCoordinates.hashCode());
+    }
+
+    @Test
+    void nodesWithDifferentArtifactsAreNotEqual() {
+        Artifact otherArtifact = new DefaultArtifact("group", "other", "1.2", 
"compile", "jar", "", null);
+        DefaultDependencyNode node = new DefaultDependencyNode(null, artifact, 
null, null, null, false, emptyList());
+        DefaultDependencyNode other =
+                new DefaultDependencyNode(null, otherArtifact, null, null, 
null, false, emptyList());
+
+        assertNotEquals(node, other);
+    }
+
+    @Test
+    void getChildrenReturnsAnUnmodifiableList() {
+        DefaultDependencyNode node = new DefaultDependencyNode(null, artifact, 
null, null, null, false, emptyList());
+        node.setChildren(new ArrayList<>());
+
+        assertThrows(
+                UnsupportedOperationException.class, () -> 
node.getChildren().add(new DefaultDependencyNode(artifact)));
+    }
+
+    @Test
+    void getChildrenStillReturnsNullWhenNeverSet() {
+        DefaultDependencyNode node = new DefaultDependencyNode(artifact);
+        assertNull(node.getChildren());
+    }
 }

Reply via email to