Use a dedicated Storage class.

Author: drupol

composer.json

@@ -26,6 +26,7 @@
         "leanphp/phpspec-code-coverage": "^4",
         "phpbench/phpbench": "^0.16",
         "phpspec/phpspec": "^4",
+        "phptaskman/changelog": "^1.0",
         "scrutinizer/ocular": "^1"
     },
     "config": {

spec/drupol/phptree/Modifier/ReverseSpec.php

@@ -28,11 +28,7 @@ public function it_can_reverse_a_tree()
             ->count()
             ->shouldReturn(5);
 
-        // @todo write better test here and test all children and recursively.
-        $this
-            ->modify($tree1)
-            ->children()->current()->getValue()
-            ->shouldReturn('E');
+        $this->modify($tree1)->shouldNotBeEqualTo($tree2);
     }
 
     public function it_is_initializable()

spec/drupol/phptree/Node/NodeObjectBehavior.php

@@ -13,6 +13,7 @@
  *
  * @method shouldHaveSameGraph(NodeInterface $node)
  * @method shouldHaveSameTextExport(string $export)
+ * @method shouldNotHaveSameTextExport(string $export)
  */
 abstract class NodeObjectBehavior extends ObjectBehavior
 {
@@ -37,6 +38,13 @@ public function getMatchers(): array
 
                 return $left === $key;
             },
+            'notHaveSameTextExport' => function ($subject, $key) {
+                $exporterText = new Text();
+
+                $left = $exporterText->export($subject);
+
+                return $left !== $key;
+            },
         ];
     }
 }

spec/drupol/phptree/Storage/NodeStorageSpec.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace spec\drupol\phptree\Storage;
+
+use drupol\phptree\Storage\NodeStorage;
+use PhpSpec\ObjectBehavior;
+
+class NodeStorageSpec extends ObjectBehavior
+{
+    public function it_can_offsetUnset()
+    {
+        $this->set('foo', 'bar');
+
+        $this->get('foo')->shouldBe('bar');
+
+        $this->offsetUnset('foo');
+
+        $this->shouldThrow(\InvalidArgumentException::class)
+            ->during('get', ['foo']);
+    }
+    public function it_is_initializable()
+    {
+        $this->shouldHaveType(NodeStorage::class);
+    }
+}

src/Node/KeyValueNode.php

@@ -9,13 +9,6 @@
  */
 class KeyValueNode extends ValueNode implements KeyValueNodeInterface
 {
-    /**
-     * The key property.
-     *
-     * @var null|int|mixed|string
-     */
-    private $key;
-
     /**
      * KeyValueNode constructor.
      *
@@ -28,14 +21,14 @@ public function __construct($key = null, $value = null, int $capacity = 0, NodeI
     {
         parent::__construct($value, $capacity, $parent);
 
-        $this->key = $key;
+        $this->storage()->set('key', $key);
     }
 
     /**
      * {@inheritdoc}
      */
     public function getKey()
     {
-        return $this->key;
+        return $this->storage()->get('key');
     }
 }

src/Node/NaryNode.php

@@ -12,20 +12,6 @@
  */
 class NaryNode extends Node implements NaryNodeInterface
 {
-    /**
-     * The capacity of a node, the maximum children a node can have.
-     *
-     * @var int
-     */
-    private $capacity;
-
-    /**
-     * The traverser.
-     *
-     * @var TraverserInterface
-     */
-    private $traverser;
-
     /**
      * NaryNode constructor.
      *
@@ -40,11 +26,16 @@ public function __construct(int $capacity = 0, NodeInterface $parent = null, Tra
     {
         parent::__construct($parent);
 
-        $this->capacity = 0 > $capacity ?
+        $capacity = 0 > $capacity ?
             0 :
             $capacity;
 
-        $this->traverser = $traverser ?? new BreadthFirst();
+        $this->storage()->set(
+            'capacity',
+            $capacity
+        );
+
+        $this->storage()->set('traverser', $traverser ?? new BreadthFirst());
     }
 
     /**
@@ -61,7 +52,7 @@ public function add(NodeInterface ...$nodes): NodeInterface
                 continue;
             }
 
-            foreach ($this->traverser->traverse($this) as $candidate) {
+            foreach ($this->getTraverser()->traverse($this) as $candidate) {
                 if (!($candidate instanceof NaryNodeInterface)) {
                     continue;
                 }
@@ -84,15 +75,15 @@ public function add(NodeInterface ...$nodes): NodeInterface
      */
     public function capacity(): int
     {
-        return $this->capacity;
+        return $this->storage()->get('capacity');
     }
 
     /**
      * {@inheritdoc}
      */
     public function getTraverser(): TraverserInterface
     {
-        return $this->traverser;
+        return $this->storage()->get('traverser');
     }
 
     /**

src/Node/Node.php

@@ -4,6 +4,9 @@
 
 namespace drupol\phptree\Node;
 
+use drupol\phptree\Storage\NodeStorage;
+use drupol\phptree\Storage\StorageInterface;
+
 /**
  * Class Node.
  */
@@ -12,9 +15,9 @@ class Node implements NodeInterface
     /**
      * The storage property.
      *
-     * @var array
+     * @var \drupol\phptree\Storage\NodeStorageInterface
      */
-    protected $storage;
+    private $storage;
 
     /**
      * Node constructor.
@@ -23,10 +26,8 @@ class Node implements NodeInterface
      */
     public function __construct(NodeInterface $parent = null)
     {
-        $this->storage = [
-            'parent' => $parent,
-            'children' => new \ArrayObject(),
-        ];
+        $this->storage = new NodeStorage();
+        $this->storage()->setParent($parent);
     }
 
     /**
@@ -35,7 +36,7 @@ public function __construct(NodeInterface $parent = null)
     public function add(NodeInterface ...$nodes): NodeInterface
     {
         foreach ($nodes as $node) {
-            $this->storage['children']->append(
+            $this->storage()->getChildren()->append(
                 $node->setParent($this)
             );
         }
@@ -45,10 +46,12 @@ public function add(NodeInterface ...$nodes): NodeInterface
 
     /**
      * {@inheritdoc}
+     *
+     * @return \drupol\phptree\Node\NodeInterface|\Traversable
      */
     public function children(): \Traversable
     {
-        yield from $this->storage['children'];
+        yield from $this->storage()->getChildren();
     }
 
     /**
@@ -71,7 +74,7 @@ public function count(): int
      */
     public function degree(): int
     {
-        return $this->storage['children']->count();
+        return $this->storage()->getChildren()->count();
     }
 
     /**
@@ -107,18 +110,18 @@ public function getIterator()
      */
     public function getParent(): ?NodeInterface
     {
-        return $this->storage['parent'];
+        return $this->storage()->getParent();
     }
 
     /**
      * {@inheritdoc}
      */
     public function getSibblings(): \Traversable
     {
-        $parent = $this->storage['parent'];
+        $parent = $this->storage()->getParent();
 
         if (null === $parent) {
-            return new \ArrayIterator([]);
+            return $this->storage()->getChildren()->exchangeArray([]);
         }
 
         foreach ($parent->children() as $child) {
@@ -149,31 +152,31 @@ public function height(): int
      */
     public function isLeaf(): bool
     {
-        return 0 === $this->storage['children']->count();
+        return 0 === $this->degree();
     }
 
     /**
      * {@inheritdoc}
      */
     public function isRoot(): bool
     {
-        return null === $this->storage['parent'];
+        return null === $this->storage()->getParent();
     }
 
     /**
      * {@inheritdoc}
      */
     public function offsetExists($offset)
     {
-        return $this->storage['children']->offsetExists($offset);
+        return $this->storage()->getChildren()->offsetExists($offset);
     }
 
     /**
      * {@inheritdoc}
      */
     public function offsetGet($offset)
     {
-        return $this->storage['children']->offsetGet($offset);
+        return $this->storage()->getChildren()->offsetGet($offset);
     }
 
     /**
@@ -185,7 +188,7 @@ public function offsetSet($offset, $value)
             throw new \InvalidArgumentException('The value must implements NodeInterface.');
         }
 
-        $this->storage['children']
+        $this->storage()->getChildren()
             ->offsetSet($offset, $value->setParent($this));
     }
 
@@ -194,17 +197,17 @@ public function offsetSet($offset, $value)
      */
     public function offsetUnset($offset)
     {
-        $this->storage['children']->offsetUnset($offset);
+        $this->storage()->getChildren()->offsetUnset($offset);
     }
 
     /**
      * {@inheritdoc}
      */
     public function remove(NodeInterface ...$nodes): NodeInterface
     {
-        $this->storage['children']->exchangeArray(
+        $this->storage()->getChildren()->exchangeArray(
             \array_filter(
-                $this->storage['children']->getArrayCopy(),
+                $this->storage()->getChildren()->getArrayCopy(),
                 static function ($child) use ($nodes) {
                     return !\in_array($child, $nodes, true);
                 }
@@ -219,7 +222,7 @@ static function ($child) use ($nodes) {
      */
     public function setParent(NodeInterface $node = null): NodeInterface
     {
-        $this->storage['parent'] = $node;
+        $this->storage()->setParent($node);
 
         return $this;
     }
@@ -230,10 +233,20 @@ public function setParent(NodeInterface $node = null): NodeInterface
     public function withChildren(NodeInterface ...$nodes): NodeInterface
     {
         $clone = clone $this;
-        $clone->storage['children'] = new \ArrayObject();
+        $clone->storage()->getChildren()->exchangeArray([]);
 
         return [] === $nodes ?
             $clone :
             $clone->add(...$nodes);
     }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return \drupol\phptree\Storage\NodeStorageInterface
+     */
+    protected function storage(): StorageInterface
+    {
+        return $this->storage;
+    }
 }

src/Node/ValueNode.php

@@ -9,13 +9,6 @@
  */
 class ValueNode extends NaryNode implements ValueNodeInterface
 {
-    /**
-     * The value property.
-     *
-     * @var null|mixed|string
-     */
-    private $value;
-
     /**
      * ValueNode constructor.
      *
@@ -27,14 +20,14 @@ public function __construct($value, int $capacity = 0, NodeInterface $parent = n
     {
         parent::__construct($capacity, $parent);
 
-        $this->value = $value;
+        $this->storage()->set('value', $value);
     }
 
     /**
      * {@inheritdoc}
      */
     public function getValue()
     {
-        return $this->value;
+        return $this->storage()->get('value');
     }
 }