Node: streamAll(): added

src/main/java/net/kemitix/node/Node.java

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

src/main/java/net/kemitix/node/NodeItem.java

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

src/test/java/net/kemitix/node/ImmutableNodeItemTest.java

@@ -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(
+        assertThat(immutableNode.getData()).as("can get the data from a immutableNode")
-                "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(
+        assertThat(immutableNode.getParent()).as("immutableNode created without a parent has no parent")
-                "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
+        final Optional<Node<String>> optionalParent = immutableChild.getParent();
-                = immutableChild.getParent();
         if (optionalParent.isPresent()) {
             val p = optionalParent.get();
             assertThat(p).hasFieldOrPropertyWithValue("name", "root")
-                         .hasFieldOrPropertyWithValue("data",
+                         .hasFieldOrPropertyWithValue("data", Optional.of("parent"));
-                                 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(
+        val result = immutableNode.findInPath(Arrays.asList("parent", "no child"));
-                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",
+        Nodes.unnamedChild("bob's child's data", bob); // has no name and no children so no included
-                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]",
+        assertThat(lines).contains("[root]", "[ alice]", "[  dave]", "[ (unnamed)]", "[  lucy]", "[ bob]");
-                "[ (unnamed)]", "[  lucy]", "[ bob]");
         assertThat(lines).containsSubsequence("[root]", "[ alice]", "[  dave]");
-        assertThat(lines).containsSubsequence("[root]", "[ (unnamed)]",
+        assertThat(lines).containsSubsequence("[root]", "[ (unnamed)]", "[  lucy]");
-                "[  lucy]");
         assertThat(lines).containsSubsequence("[root]", "[ bob]");
     }
 
@@ -406,8 +402,7 @@ public class ImmutableNodeItemTest {
         immutableNode = Nodes.asImmutable(Nodes.unnamedRoot(""));
         expectImmutableException();
         //when
-        immutableNode.createDescendantLine(
+        immutableNode.createDescendantLine(Arrays.asList("child", "grandchild"));
-                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);
+    }
 }

src/test/java/net/kemitix/node/NodeItemTest.java

@@ -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").
+        assertThat(node.getData()).as("can get the data from a node")
-                contains(data);
+                                  .
+                                          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.isEmpty())
-        softly.assertThat(node.isNamed()).as("node is unnamed").isFalse();
+              .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(
+        assertThat(node.getParent()).as("node created without a parent has no parent")
-                "node created without a parent has no parent").isEmpty();
+                                    .isEmpty();
     }
 
     /**
@@ -80,8 +86,7 @@ public class NodeItemTest {
         //when
         node = Nodes.unnamedChild("subject", parent);
         //then
-        assertThat(node.getParent()).as(
+        assertThat(node.getParent()).as("node created with a parent can return the parent")
-                "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"
+                "when a node is created with a parent, the parent has the new" + " node among it's children")
-                        + " node among it's children").contains(node);
+                                        .contains(node);
     }
 
     /**
@@ -139,9 +144,8 @@ public class NodeItemTest {
         //when
         node.setParent(parent);
         //then
-        assertThat(node.getParent()).as(
+        assertThat(node.getParent()).as("when a node is assigned a new parent that parent can be " + "returned")
-                "when a node is assigned a new parent that parent can be "
+                                    .contains(parent);
-                        + "returned").contains(parent);
     }
 
     /**
@@ -184,12 +188,12 @@ public class NodeItemTest {
         //when
         child.setParent(newParent);
         //then
-        assertThat(child.getParent()).as(
+        assertThat(child.getParent()).as("when a node is assigned a new parent, the old parent is " + "replaced")
-                "when a node is assigned a new parent, the old parent is "
+                                     .contains(newParent);
-                        + "replaced").contains(newParent);
+        assertThat(node.findChild("child")
-        assertThat(node.findChild("child").isPresent()).as(
+                       .isPresent()).as(
-                "when a node is assigned a new parent, the old parent no "
+                "when a node is assigned a new parent, the old parent no " + "longer has the node among it's children")
-                        + "longer has the node among it's children").isFalse();
+                                    .isFalse();
     }
 
     /**
@@ -205,14 +209,14 @@ public class NodeItemTest {
         //when
         newParent.addChild(child);
         //then
-        assertThat(child.getParent()).as(
+        assertThat(child.getParent()).as("when a node with an existing parent is added as a child " +
-                "when a node with an existing parent is added as a child "
+                                         "to another node, then the old parent is replaced")
-                        + "to another node, then the old parent is replaced")
                                      .contains(newParent);
-        assertThat(node.findChild("child").isPresent()).as(
+        assertThat(node.findChild("child")
-                "when a node with an existing parent is added as a child to "
+                       .isPresent()).as("when a node with an existing parent is added as a child to " +
-                        + "another node, then the old parent no longer has "
+                                        "another node, then the old parent no longer has " +
-                        + "the node among it's children").isFalse();
+                                        "the node among it's children")
+                                    .isFalse();
     }
 
     /**
@@ -240,9 +244,8 @@ public class NodeItemTest {
         //when
         node.addChild(child);
         //then
-        assertThat(node.getChildren()).as(
+        assertThat(node.getChildren()).as("when a node is added as a child, the node is among the " + "children")
-                "when a node is added as a child, the node is among the "
+                                      .contains(child);
-                        + "children").contains(child);
     }
 
     /**
@@ -313,9 +316,8 @@ public class NodeItemTest {
         //when
         node.addChild(child);
         //then
-        assertThat(child.getParent()).as(
+        assertThat(child.getParent()).as("when a node is added as a child, the child has the node as " + "its parent")
-                "when a node is added as a child, the child has the node as "
+                                     .contains(node);
-                        + "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(
+        assertThat(result.isPresent()).as("when we walk the tree to a node it is found")
-                "when we walk the tree to a node it is found").isTrue();
+                                      .isTrue();
         if (result.isPresent()) {
-            assertThat(result.get()).as(
+            assertThat(result.get()).as("when we walk the tree to a node the correct node is found")
-                    "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(
+        assertThat(result.isPresent()).as("when we walk the tree to a node that doesn't exists, nothing" + " is found")
-                "when we walk the tree to a node that doesn't exists, nothing"
+                                      .isFalse();
-                        + " is found").isFalse();
     }
 
     /**
@@ -403,37 +403,32 @@ public class NodeItemTest {
         val betaData = "beta";
         val gammaData = "gamma";
         //when
-        node.createDescendantLine(
+        node.createDescendantLine(Arrays.asList(alphaData, betaData, gammaData));
-                Arrays.asList(alphaData, betaData, gammaData));
         //then
         val alphaOptional = node.findChild(alphaData);
-        assertThat(alphaOptional.isPresent()).as(
+        assertThat(alphaOptional.isPresent()).as("when creating a descendant line, the first element is found")
-                "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 "
+                    "when creating a descendant line, the first element has " + "the current node as its parent")
-                            + "the current node as its parent").contains(node);
+                                         .contains(node);
             val betaOptional = alpha.findChild(betaData);
-            assertThat(betaOptional.isPresent()).as(
+            assertThat(betaOptional.isPresent()).as("when creating a descendant line, the second element is " + "found")
-                    "when creating a descendant line, the second element is "
+                                                .isTrue();
-                            + "found").isTrue();
             if (betaOptional.isPresent()) {
                 val beta = betaOptional.get();
                 assertThat(beta.getParent()).as(
-                        "when creating a descendant line, the second element "
+                        "when creating a descendant line, the second element " + "has the first as its parent")
-                                + "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 "
+                        "when creating a descendant line, the third element " + "is found")
-                                + "is found").isTrue();
+                                                     .isTrue();
                 if (gammaOptional.isPresent()) {
                     val gamma = gammaOptional.get();
                     assertThat(gamma.getParent()).as(
-                            "when creating a descendant line, the third "
+                            "when creating a descendant line, the third " + "element has the second as its parent")
-                                    + "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(
+        assertThat(node.getChildren()).as("when creating a descendant line from an empty list, nothing " + "is created")
-                "when creating a descendant line from an empty list, nothing "
+                                      .isEmpty();
-                        + "is created").isEmpty();
     }
 
     /**
@@ -482,12 +476,11 @@ public class NodeItemTest {
         //when
         val found = node.findChild(childData);
         //then
-        assertThat(found.isPresent()).as(
+        assertThat(found.isPresent()).as("when retrieving a child by its data, it is found")
-                "when retrieving a child by its data, it is found").isTrue();
+                                     .isTrue();
         if (found.isPresent()) {
-            assertThat(found.get()).as(
+            assertThat(found.get()).as("when retrieving a child by its data, it is the expected " + "node")
-                    "when retrieving a child by its data, it is the expected "
+                                   .isSameAs(child);
-                            + "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 "
+                "when creating a child node, the child has the current node " + "as its parent")
-                        + "as its parent").contains(node);
+                                     .contains(node);
         val foundChild = node.findChild(childData);
-        assertThat(foundChild.isPresent()).as(
+        assertThat(foundChild.isPresent()).as("when creating a child node, the child can be found by its " + "data")
-                "when creating a child node, the child can be found by its "
+                                          .isTrue();
-                        + "data").isTrue();
         if (foundChild.isPresent()) {
             assertThat(foundChild.get()).as(
-                    "when creating a child node, the correct child can be "
+                    "when creating a child node, the correct child can be " + "found by its data")
-                            + "found by its data").isSameAs(child);
+                                        .isSameAs(child);
         }
     }
 
@@ -598,14 +590,19 @@ public class NodeItemTest {
         //when
         node.insertInPath(four, "one", "two", "three");
         //then
-        val three = four.getParent().get();
+        val three = four.getParent()
-        assertThat(four.getParent()).as("add node to a tree").isNotNull();
+                        .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")).as("child")
-        assertThat(
+                                                .isSameAs(child);
-                node.getChildByName("child").getChildByName("grandchild")).as(
+        assertThat(node.getChildByName("child")
-                "grandchild").isSameAs(grandchild);
+                       .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")
+        assertThat(node.getChildByName("child")
-                                                          .contains(
+                       .getData()).as("data in tree")
-                                                                  "child data");
+                                  .contains("child data");
-        assertThat(
+        assertThat(node.getChildByName("child")
-                node.getChildByName("child").getChildByName("grandchild")).as(
+                       .getChildByName("grandchild")).as("grandchild")
-                "grandchild").isSameAs(grandchild);
+                                                     .isSameAs(grandchild);
     }
 
     @Test
@@ -672,8 +670,7 @@ public class NodeItemTest {
     public void placeNodeInTreeWhereNonEmptyNodeWithSameNameExists() {
         //given
         exception.expect(NodeException.class);
-        exception.expectMessage(
+        exception.expectMessage("A non-empty node named 'grandchild' already exists here");
-                "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(
+        assertThat(child.getChildByName("target")
-                "target starts empty").isTrue();
+                        .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(
+        assertThat(child.getChildByName("target")
-                "target now contains data").contains("I'm new");
+                        .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",
+        Nodes.unnamedChild("bob's child's data", bob); // has no name and no children so no included
-                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]",
+        assertThat(lines).contains("[root]", "[ alice]", "[  dave]", "[ (unnamed)]", "[  lucy]", "[ bob]");
-                "[ (unnamed)]", "[  lucy]", "[ bob]");
         assertThat(lines).containsSubsequence("[root]", "[ alice]", "[  dave]");
-        assertThat(lines).containsSubsequence("[root]", "[ (unnamed)]",
+        assertThat(lines).containsSubsequence("[root]", "[ (unnamed)]", "[  lucy]");
-                "[  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);
+    }
 }