kemitix/node
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge pull request #22 from kemitix/all-nodes-stream

Browse source 
All nodes stream
This commit is contained in:
Paul Campbell 2017-02-16 21:15:14 +00:00 committed by GitHub
commit 4c8404925a
5 changed files with 187 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
pom.xml
View file

@ -11,14 +11,16 @@
<parent>
<groupId>net.kemitix</groupId>
<artifactId>kemitix-parent</artifactId>
<version>2.1.0</version>
<version>2.4.0</version>
</parent>
<properties>
<lombok.version>1.16.10</lombok.version>
<assertj.version>3.5.2</assertj.version>
<coveralls-maven-plugin.version>4.2.0</coveralls-maven-plugin.version>
<assertj.version>3.6.2</assertj.version>
<coveralls-maven-plugin.version>4.3.0</coveralls-maven-plugin.version>
<trajano-commons-testing.version>2.1.0</trajano-commons-testing.version>
<junit.version>4.12</junit.version>
<hamcrest.version>1.3</hamcrest.version>
</properties>
<issueManagement>
@ -47,21 +49,16 @@
</build>
<dependencies>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${lombok.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest-core</artifactId>
<version>1.3</version>
<version>${hamcrest.version}</version>
<scope>test</scope>
</dependency>
<dependency>

8
src/main/java/net/kemitix/node/Node.java
View file

@ -27,6 +27,7 @@ package net.kemitix.node;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Stream;
/**
* An interface for tree node items.
@ -221,4 +222,11 @@ public interface Node<T> {
* Removes the parent from the node. Makes the node into a new root node.
*/
void removeParent();
/**
* Returns a stream containing the node and all its children and their children.
*
* @return a stream of all the nodes in the tree below this node
*/
Stream<Node<T>> streamAll();
}

27
src/main/java/net/kemitix/node/NodeItem.java
View file

@ -25,6 +25,7 @@ SOFTWARE.
package net.kemitix.node;
import lombok.NonNull;
import lombok.ToString;
import lombok.val;
import java.util.Arrays;
@ -32,6 +33,7 @@ import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Stream;
/**
* Represents a tree of nodes.
@ -40,6 +42,7 @@ import java.util.Set;
*
* @author Paul Campbell (pcampbell@kemitix.net)
*/
@ToString(exclude = "children")
class NodeItem<T> implements Node<T> {
private final Set<Node<T>> children = new HashSet<>();
@ -143,7 +146,13 @@ class NodeItem<T> implements Node<T> {
@Override
public void addChild(@NonNull final Node<T> child) {
verifyChildIsNotAnAncestor(child);
verifyChildWithSameNameDoesNotAlreadyExist(child);
//verifyChildWithSameNameDoesNotAlreadyExist
if (child.isNamed()) {
findChildByName(child.getName()).filter(existingChild -> existingChild != child)
.ifPresent(existingChild -> {
throw new NodeException("Node with that name already exists here");
});
}
children.add(child);
// update the child's parent if they don't have one or it is not this
val childParent = child.getParent();
@ -153,17 +162,6 @@ class NodeItem<T> implements Node<T> {
}
}
private void verifyChildWithSameNameDoesNotAlreadyExist(
final @NonNull Node<T> child
) {
if (child.isNamed()) {
findChildByName(child.getName()).filter(existingChild -> existingChild != child)
.ifPresent(existingChild -> {
throw new NodeException("Node with that name already exists here");
});
}
}
private void verifyChildIsNotAnAncestor(final @NonNull Node<T> child) {
if (this.equals(child) || isDescendantOf(child)) {
throw new NodeException("Child is an ancestor");
@ -352,4 +350,9 @@ class NodeItem<T> implements Node<T> {
}
}
@Override
public Stream<Node<T>> streamAll() {
return Stream.concat(Stream.of(this), getChildren().stream()
.flatMap(Node::streamAll));
}
}

61
src/test/java/net/kemitix/node/ImmutableNodeItemTest.java
View file

@ -10,6 +10,7 @@ import org.junit.rules.ExpectedException;
import java.util.Arrays;
import java.util.Collections;
import java.util.Optional;
import java.util.stream.Collectors;
import static org.assertj.core.api.Assertions.assertThat;
@ -39,8 +40,8 @@ public class ImmutableNodeItemTest {
//when
immutableNode = Nodes.asImmutable(Nodes.unnamedRoot(data));
//then
assertThat(immutableNode.getData()).as(
"can get the data from a immutableNode").
assertThat(immutableNode.getData()).as("can get the data from a immutableNode")
.
contains(data);
}
@ -73,8 +74,7 @@ public class ImmutableNodeItemTest {
//given
immutableNode = Nodes.asImmutable(Nodes.unnamedRoot("data"));
//then
assertThat(immutableNode.getParent()).as(
"immutableNode created without a parent has no parent")
assertThat(immutableNode.getParent()).as("immutableNode created without a parent has no parent")
.isEmpty();
}
@ -101,13 +101,11 @@ public class ImmutableNodeItemTest {
//then
// get the immutable node's child's parent
val immutableChild = immutableNode.getChildByName("child");
final Optional<Node<String>> optionalParent
= immutableChild.getParent();
final Optional<Node<String>> optionalParent = immutableChild.getParent();
if (optionalParent.isPresent()) {
val p = optionalParent.get();
assertThat(p).hasFieldOrPropertyWithValue("name", "root")
.hasFieldOrPropertyWithValue("data",
Optional.of("parent"));
.hasFieldOrPropertyWithValue("data", Optional.of("parent"));
}
}
@ -153,7 +151,8 @@ public class ImmutableNodeItemTest {
//then
assertThat(result.isPresent()).isTrue();
if (result.isPresent()) {
assertThat(result.get().getName()).isEqualTo("child");
assertThat(result.get()
.getName()).isEqualTo("child");
}
}
@ -169,8 +168,7 @@ public class ImmutableNodeItemTest {
Nodes.unnamedChild("child", Nodes.unnamedChild("parent", root));
immutableNode = Nodes.asImmutable(root);
//when
val result = immutableNode.findInPath(
Arrays.asList("parent", "no child"));
val result = immutableNode.findInPath(Arrays.asList("parent", "no child"));
//then
assertThat(result.isPresent()).isFalse();
}
@ -218,7 +216,8 @@ public class ImmutableNodeItemTest {
//then
assertThat(result.isPresent()).isTrue();
if (result.isPresent()) {
assertThat(result.get().getData()).contains("child");
assertThat(result.get()
.getData()).contains("child");
}
}
@ -324,8 +323,7 @@ public class ImmutableNodeItemTest {
val bob = Nodes.namedChild("bob data", "bob", root);
val alice = Nodes.namedChild("alice data", "alice", root);
Nodes.namedChild("dave data", "dave", alice);
Nodes.unnamedChild("bob's child's data",
bob); // has no name and no children so no included
Nodes.unnamedChild("bob's child's data", bob); // has no name and no children so no included
val kim = Nodes.unnamedChild("kim data", root); // nameless mother
Nodes.namedChild("lucy data", "lucy", kim);
immutableNode = Nodes.asImmutable(root);
@ -333,11 +331,9 @@ public class ImmutableNodeItemTest {
val tree = immutableNode.drawTree(0);
//then
String[] lines = tree.split("\n");
assertThat(lines).contains("[root]", "[ alice]", "[ dave]",
"[ (unnamed)]", "[ lucy]", "[ bob]");
assertThat(lines).contains("[root]", "[ alice]", "[ dave]", "[ (unnamed)]", "[ lucy]", "[ bob]");
assertThat(lines).containsSubsequence("[root]", "[ alice]", "[ dave]");
assertThat(lines).containsSubsequence("[root]", "[ (unnamed)]",
"[ lucy]");
assertThat(lines).containsSubsequence("[root]", "[ (unnamed)]", "[ lucy]");
assertThat(lines).containsSubsequence("[root]", "[ bob]");
}
@ -406,8 +402,7 @@ public class ImmutableNodeItemTest {
immutableNode = Nodes.asImmutable(Nodes.unnamedRoot(""));
expectImmutableException();
//when
immutableNode.createDescendantLine(
Arrays.asList("child", "grandchild"));
immutableNode.createDescendantLine(Arrays.asList("child", "grandchild"));
}
@Test
@ -427,4 +422,30 @@ public class ImmutableNodeItemTest {
//when
Nodes.asImmutable(Nodes.unnamedChild("child", Nodes.unnamedRoot("root")));
}
@Test
public void canStreamAll() throws Exception {
//given
val node = Nodes.namedRoot("root", "root");
val n1 = Nodes.namedChild("one", "one", node);
val n2 = Nodes.namedChild("two", "two", node);
Nodes.namedChild("three", "three", n1);
Nodes.namedChild("four", "four", n2);
val n5 = Nodes.namedChild("five", "five", n1);
val n6 = Nodes.namedChild("six", "six", n2);
Nodes.namedChild("seven", "seven", n5);
Nodes.namedChild("eight", "eight", n6);
val immutableRoot = Nodes.asImmutable(node);
//when
val result = immutableRoot.streamAll()
.collect(Collectors.toList());
//then
assertThat(result).as("full tree")
.hasSize(9);
// and
assertThat(immutableRoot.getChild("one")
.streamAll()
.collect(Collectors.toList())).as("sub-tree")
.hasSize(4);
}
}

212
src/test/java/net/kemitix/node/NodeItemTest.java
View file

@ -11,6 +11,7 @@ import java.util.Arrays;
import java.util.Collections;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import static org.assertj.core.api.Assertions.assertThat;
@ -33,8 +34,9 @@ public class NodeItemTest {
//when
node = Nodes.unnamedRoot(data);
//then
assertThat(node.getData()).as("can get the data from a node").
contains(data);
assertThat(node.getData()).as("can get the data from a node")
.
contains(data);
}
@Test
@ -43,8 +45,12 @@ public class NodeItemTest {
node = Nodes.unnamedRoot(null);
//then
SoftAssertions softly = new SoftAssertions();
softly.assertThat(node.isEmpty()).as("node is empty").isTrue();
softly.assertThat(node.isNamed()).as("node is unnamed").isFalse();
softly.assertThat(node.isEmpty())
.as("node is empty")
.isTrue();
softly.assertThat(node.isNamed())
.as("node is unnamed")
.isFalse();
softly.assertAll();
}
@ -66,8 +72,8 @@ public class NodeItemTest {
//given
node = Nodes.unnamedRoot("data");
//then
assertThat(node.getParent()).as(
"node created without a parent has no parent").isEmpty();
assertThat(node.getParent()).as("node created without a parent has no parent")
.isEmpty();
}
/**
@ -80,8 +86,7 @@ public class NodeItemTest {
//when
node = Nodes.unnamedChild("subject", parent);
//then
assertThat(node.getParent()).as(
"node created with a parent can return the parent")
assertThat(node.getParent()).as("node created with a parent can return the parent")
.contains(parent);
}
@ -124,8 +129,8 @@ public class NodeItemTest {
node = Nodes.unnamedChild("subject", parent);
//then
assertThat(parent.getChildren()).as(
"when a node is created with a parent, the parent has the new"
+ " node among it's children").contains(node);
"when a node is created with a parent, the parent has the new" + " node among it's children")
.contains(node);
}
/**
@ -139,9 +144,8 @@ public class NodeItemTest {
//when
node.setParent(parent);
//then
assertThat(node.getParent()).as(
"when a node is assigned a new parent that parent can be "
+ "returned").contains(parent);
assertThat(node.getParent()).as("when a node is assigned a new parent that parent can be " + "returned")
.contains(parent);
}
/**
@ -184,12 +188,12 @@ public class NodeItemTest {
//when
child.setParent(newParent);
//then
assertThat(child.getParent()).as(
"when a node is assigned a new parent, the old parent is "
+ "replaced").contains(newParent);
assertThat(node.findChild("child").isPresent()).as(
"when a node is assigned a new parent, the old parent no "
+ "longer has the node among it's children").isFalse();
assertThat(child.getParent()).as("when a node is assigned a new parent, the old parent is " + "replaced")
.contains(newParent);
assertThat(node.findChild("child")
.isPresent()).as(
"when a node is assigned a new parent, the old parent no " + "longer has the node among it's children")
.isFalse();
}
/**
@ -205,14 +209,14 @@ public class NodeItemTest {
//when
newParent.addChild(child);
//then
assertThat(child.getParent()).as(
"when a node with an existing parent is added as a child "
+ "to another node, then the old parent is replaced")
assertThat(child.getParent()).as("when a node with an existing parent is added as a child " +
"to another node, then the old parent is replaced")
.contains(newParent);
assertThat(node.findChild("child").isPresent()).as(
"when a node with an existing parent is added as a child to "
+ "another node, then the old parent no longer has "
+ "the node among it's children").isFalse();
assertThat(node.findChild("child")
.isPresent()).as("when a node with an existing parent is added as a child to " +
"another node, then the old parent no longer has " +
"the node among it's children")
.isFalse();
}
/**
@ -240,9 +244,8 @@ public class NodeItemTest {
//when
node.addChild(child);
//then
assertThat(node.getChildren()).as(
"when a node is added as a child, the node is among the "
+ "children").contains(child);
assertThat(node.getChildren()).as("when a node is added as a child, the node is among the " + "children")
.contains(child);
}
/**
@ -313,9 +316,8 @@ public class NodeItemTest {
//when
node.addChild(child);
//then
assertThat(child.getParent()).as(
"when a node is added as a child, the child has the node as "
+ "its parent").contains(node);
assertThat(child.getParent()).as("when a node is added as a child, the child has the node as " + "its parent")
.contains(node);
}
/**
@ -334,11 +336,10 @@ public class NodeItemTest {
//when
val result = grandParentNode.findInPath(Arrays.asList(parent, subject));
//then
assertThat(result.isPresent()).as(
"when we walk the tree to a node it is found").isTrue();
assertThat(result.isPresent()).as("when we walk the tree to a node it is found")
.isTrue();
if (result.isPresent()) {
assertThat(result.get()).as(
"when we walk the tree to a node the correct node is found")
assertThat(result.get()).as("when we walk the tree to a node the correct node is found")
.isSameAs(node);
}
}
@ -358,9 +359,8 @@ public class NodeItemTest {
//when
val result = parentNode.findInPath(Arrays.asList(subject, "no child"));
//then
assertThat(result.isPresent()).as(
"when we walk the tree to a node that doesn't exists, nothing"
+ " is found").isFalse();
assertThat(result.isPresent()).as("when we walk the tree to a node that doesn't exists, nothing" + " is found")
.isFalse();
}
/**
@ -403,37 +403,32 @@ public class NodeItemTest {
val betaData = "beta";
val gammaData = "gamma";
//when
node.createDescendantLine(
Arrays.asList(alphaData, betaData, gammaData));
node.createDescendantLine(Arrays.asList(alphaData, betaData, gammaData));
//then
val alphaOptional = node.findChild(alphaData);
assertThat(alphaOptional.isPresent()).as(
"when creating a descendant line, the first element is found")
assertThat(alphaOptional.isPresent()).as("when creating a descendant line, the first element is found")
.isTrue();
if (alphaOptional.isPresent()) {
val alpha = alphaOptional.get();
assertThat(alpha.getParent()).as(
"when creating a descendant line, the first element has "
+ "the current node as its parent").contains(node);
"when creating a descendant line, the first element has " + "the current node as its parent")
.contains(node);
val betaOptional = alpha.findChild(betaData);
assertThat(betaOptional.isPresent()).as(
"when creating a descendant line, the second element is "
+ "found").isTrue();
assertThat(betaOptional.isPresent()).as("when creating a descendant line, the second element is " + "found")
.isTrue();
if (betaOptional.isPresent()) {
val beta = betaOptional.get();
assertThat(beta.getParent()).as(
"when creating a descendant line, the second element "
+ "has the first as its parent")
"when creating a descendant line, the second element " + "has the first as its parent")
.contains(alpha);
val gammaOptional = beta.findChild(gammaData);
assertThat(gammaOptional.isPresent()).as(
"when creating a descendant line, the third element "
+ "is found").isTrue();
"when creating a descendant line, the third element " + "is found")
.isTrue();
if (gammaOptional.isPresent()) {
val gamma = gammaOptional.get();
assertThat(gamma.getParent()).as(
"when creating a descendant line, the third "
+ "element has the second as its parent")
"when creating a descendant line, the third " + "element has the second as its parent")
.contains(beta);
}
}
@ -464,9 +459,8 @@ public class NodeItemTest {
//when
node.createDescendantLine(Collections.emptyList());
//then
assertThat(node.getChildren()).as(
"when creating a descendant line from an empty list, nothing "
+ "is created").isEmpty();
assertThat(node.getChildren()).as("when creating a descendant line from an empty list, nothing " + "is created")
.isEmpty();
}
/**
@ -482,12 +476,11 @@ public class NodeItemTest {
//when
val found = node.findChild(childData);
//then
assertThat(found.isPresent()).as(
"when retrieving a child by its data, it is found").isTrue();
assertThat(found.isPresent()).as("when retrieving a child by its data, it is found")
.isTrue();
if (found.isPresent()) {
assertThat(found.get()).as(
"when retrieving a child by its data, it is the expected "
+ "node").isSameAs(child);
assertThat(found.get()).as("when retrieving a child by its data, it is the expected " + "node")
.isSameAs(child);
}
}
@ -517,16 +510,15 @@ public class NodeItemTest {
val child = node.createChild(childData);
//then
assertThat(child.getParent()).as(
"when creating a child node, the child has the current node "
+ "as its parent").contains(node);
"when creating a child node, the child has the current node " + "as its parent")
.contains(node);
val foundChild = node.findChild(childData);
assertThat(foundChild.isPresent()).as(
"when creating a child node, the child can be found by its "
+ "data").isTrue();
assertThat(foundChild.isPresent()).as("when creating a child node, the child can be found by its " + "data")
.isTrue();
if (foundChild.isPresent()) {
assertThat(foundChild.get()).as(
"when creating a child node, the correct child can be "
+ "found by its data").isSameAs(child);
"when creating a child node, the correct child can be " + "found by its data")
.isSameAs(child);
}
}
@ -598,14 +590,19 @@ public class NodeItemTest {
//when
node.insertInPath(four, "one", "two", "three");
//then
val three = four.getParent().get();
assertThat(four.getParent()).as("add node to a tree").isNotNull();
val three = four.getParent()
.get();
assertThat(four.getParent()).as("add node to a tree")
.isNotNull();
assertThat(three.getName()).isEqualTo("three");
val two = three.getParent().get();
val two = three.getParent()
.get();
assertThat(two.getName()).isEqualTo("two");
val one = two.getParent().get();
val one = two.getParent()
.get();
assertThat(one.getName()).isEqualTo("one");
assertThat(one.getParent().get()).isSameAs(node);
assertThat(one.getParent()
.get()).isSameAs(node);
assertThat(node.getChildByName("one")
.getChildByName("two")
.getChildByName("three")
@ -623,10 +620,11 @@ public class NodeItemTest {
node.insertInPath(child); // as root/child
node.insertInPath(grandchild, "child"); // as root/child/grandchild
//then
assertThat(node.getChildByName("child")).as("child").isSameAs(child);
assertThat(
node.getChildByName("child").getChildByName("grandchild")).as(
"grandchild").isSameAs(grandchild);
assertThat(node.getChildByName("child")).as("child")
.isSameAs(child);
assertThat(node.getChildByName("child")
.getChildByName("grandchild")).as("grandchild")
.isSameAs(grandchild);
}
@Test
@ -640,12 +638,12 @@ public class NodeItemTest {
node.insertInPath(grandchild, "child");
node.insertInPath(child);
//then
assertThat(node.getChildByName("child").getData()).as("data in tree")
.contains(
"child data");
assertThat(
node.getChildByName("child").getChildByName("grandchild")).as(
"grandchild").isSameAs(grandchild);
assertThat(node.getChildByName("child")
.getData()).as("data in tree")
.contains("child data");
assertThat(node.getChildByName("child")
.getChildByName("grandchild")).as("grandchild")
.isSameAs(grandchild);
}
@Test
@ -672,8 +670,7 @@ public class NodeItemTest {
public void placeNodeInTreeWhereNonEmptyNodeWithSameNameExists() {
//given
exception.expect(NodeException.class);
exception.expectMessage(
"A non-empty node named 'grandchild' already exists here");
exception.expectMessage("A non-empty node named 'grandchild' already exists here");
node = Nodes.unnamedRoot(null);
val child = Nodes.namedChild("child data", "child", node);
Nodes.namedChild("data", "grandchild", child);
@ -707,14 +704,16 @@ public class NodeItemTest {
child.addChild(target);
val addMe = Nodes.namedRoot("I'm new", "target");
assertThat(addMe.getParent()).isEmpty();
assertThat(child.getChildByName("target").isEmpty()).as(
"target starts empty").isTrue();
assertThat(child.getChildByName("target")
.isEmpty()).as("target starts empty")
.isTrue();
//when
// addMe should replace target as the sole descendant of child
node.insertInPath(addMe, "child");
//then
assertThat(child.getChildByName("target").getData()).as(
"target now contains data").contains("I'm new");
assertThat(child.getChildByName("target")
.getData()).as("target now contains data")
.contains("I'm new");
}
@Test
@ -772,19 +771,16 @@ public class NodeItemTest {
val bob = Nodes.namedChild("bob data", "bob", node);
val alice = Nodes.namedChild("alice data", "alice", node);
Nodes.namedChild("dave data", "dave", alice);
Nodes.unnamedChild("bob's child's data",
bob); // has no name and no children so no included
Nodes.unnamedChild("bob's child's data", bob); // has no name and no children so no included
val kim = Nodes.unnamedChild("kim data", node); // nameless mother
Nodes.namedChild("lucy data", "lucy", kim);
//when
val tree = node.drawTree(0);
//then
String[] lines = tree.split("\n");
assertThat(lines).contains("[root]", "[ alice]", "[ dave]",
"[ (unnamed)]", "[ lucy]", "[ bob]");
assertThat(lines).contains("[root]", "[ alice]", "[ dave]", "[ (unnamed)]", "[ lucy]", "[ bob]");
assertThat(lines).containsSubsequence("[root]", "[ alice]", "[ dave]");
assertThat(lines).containsSubsequence("[root]", "[ (unnamed)]",
"[ lucy]");
assertThat(lines).containsSubsequence("[root]", "[ (unnamed)]", "[ lucy]");
assertThat(lines).containsSubsequence("[root]", "[ bob]");
}
@ -852,4 +848,28 @@ public class NodeItemTest {
//when
node.findChild("data");
}
@Test
public void canStreamAll() throws Exception {
//given
node = Nodes.namedRoot("root", "root");
val n1 = Nodes.namedChild("one", "one", node);
val n2 = Nodes.namedChild("two", "two", node);
val n3 = Nodes.namedChild("three", "three", n1);
val n4 = Nodes.namedChild("four", "four", n2);
val n5 = Nodes.namedChild("five", "five", n1);
val n6 = Nodes.namedChild("six", "six", n2);
val n7 = Nodes.namedChild("seven", "seven", n5);
val n8 = Nodes.namedChild("eight", "eight", n6);
//when
val result = node.streamAll()
.collect(Collectors.toList());
//then
assertThat(result).as("full tree")
.contains(node, n1, n2, n3, n4, n5, n6, n7, n8);
// and
assertThat(n1.streamAll()
.collect(Collectors.toList())).as("sub-tree")
.containsExactlyInAnyOrder(n1, n3, n5, n7);
}
}