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());
+ }
}