Update MerkleNode.

Author: drupol

src/Modifier/FulfillCapacity.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace drupol\phptree\Modifier;
+
+use drupol\phptree\Node\NodeInterface;
+
+/**
+ * Class FulfillCapacity.
+ */
+class FulfillCapacity implements ModifierInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function modify(NodeInterface $tree): NodeInterface
+    {
+        /** @var \drupol\phptree\Node\MerkleNode $item */
+        foreach ($tree->all() as $item) {
+            $capacity = $item->capacity();
+
+            if (false === $item->isLeaf()) {
+                $children = iterator_to_array($item->children());
+
+                while ($item->degree() !== $capacity) {
+                    $item->add(current($children)->clone());
+                }
+            }
+        }
+
+        return $tree;
+    }
+}

src/Modifier/RemoveNullNode.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace drupol\phptree\Modifier;
+
+use drupol\phptree\Node\NodeInterface;
+
+/**
+ * Class RemoveNullNode.
+ */
+class RemoveNullNode implements ModifierInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function modify(NodeInterface $tree): NodeInterface
+    {
+        /** @var \drupol\phptree\Node\MerkleNode $item */
+        foreach ($tree->all() as $item) {
+            if (null === $parent = $item->getParent()) {
+                continue;
+            }
+
+            if (true !== $item->isLeaf()) {
+                continue;
+            }
+
+            if (null !== $item->getValue()) {
+                continue;
+            }
+
+            $parent->remove($item);
+        }
+
+        return $tree;
+    }
+}

src/Node/MerkleNode.php

@@ -6,17 +6,24 @@
 
 use drupol\phpmerkle\Hasher\DoubleSha256;
 use drupol\phpmerkle\Hasher\HasherInterface;
+use drupol\phptree\Modifier\FulfillCapacity;
+use drupol\phptree\Modifier\RemoveNullNode;
 
 /**
  * Class MerkleNode.
  */
-class MerkleNode extends ValueNode
+class MerkleNode extends ValueNode implements MerkleNodeInterface
 {
     /**
      * @var \drupol\phpmerkle\Hasher\HasherInterface
      */
     private $hasher;
 
+    /**
+     * @var \drupol\phptree\Modifier\ModifierInterface[]
+     */
+    private $modifiers;
+
     /**
      * MerkleNode constructor.
      *
@@ -32,6 +39,10 @@ public function __construct(
         parent::__construct($value, $capacity, null, null);
 
         $this->hasher = $hasher ?? new DoubleSha256();
+        $this->modifiers = [
+            new RemoveNullNode(),
+            new FulfillCapacity(),
+        ];
     }
 
     /**
@@ -43,60 +54,40 @@ public function getValue()
             return parent::getValue();
         }
 
-        return $this->clone()->hash();
+        return $this->hash();
     }
 
     /**
      * {@inheritdoc}
      */
-    private function doHash(): string
+    public function normalize(): MerkleNodeInterface
     {
-        // If node is a leaf, then compute its hash from its value.
-        if (true === $this->isLeaf()) {
-            $value = $this->getValue();
-
-            if (null === $value) {
-                return '';
-            }
+        $tree = $this->clone();
 
-            return $this->hasher->hash($value);
+        foreach ($this->modifiers as $modifier) {
+            $tree = $modifier->modify($tree);
         }
 
-        // Remove all nodes with null value.
-        if (null !== $parent = $this->getParent()) {
-            /** @var \drupol\phptree\Node\MerkleNode $node */
-            foreach ($parent->all() as $node) {
-                if (false === $node->isLeaf()) {
-                    continue;
-                }
-
-                if (null !== $node->getValue()) {
-                    continue;
-                }
-
-                $node->getParent()->remove($node);
+        /** @var \drupol\phptree\Node\MerkleNodeInterface $tree */
+        return $tree;
+    }
 
-                return $this->hash();
-            }
+    /**
+     * {@inheritdoc}
+     */
+    private function doHash(MerkleNodeInterface $node): string
+    {
+        // If node is a leaf, then compute its hash from its value.
+        if (true === $node->isLeaf()) {
+            return $this->hasher->hash($node->getValue());
         }
 
-        // If node with children is not fulfilled, make sure it is complete.
-        if ($this->degree() !== $this->capacity()) {
-            $children = iterator_to_array($this->children());
-
-            if ([] !== $children) {
-                $this->add(current($children)->clone());
-            }
+        $hash = '';
+        /** @var \drupol\phptree\Node\MerkleNodeInterface $child */
+        foreach ($node->children() as $child) {
+            $hash .= $this->doHash($child);
         }
 
-        $hash = array_reduce(
-            iterator_to_array($this->children()),
-            static function ($carry, MerkleNode $node): string {
-                return $carry . $node->doHash();
-            },
-            ''
-        );
-
         return $this->hasher->hash($hash);
     }
 
@@ -105,6 +96,6 @@ static function ($carry, MerkleNode $node): string {
      */
     private function hash(): string
     {
-        return $this->hasher->unpack($this->doHash());
+        return $this->hasher->unpack($this->doHash($this->normalize()));
     }
 }

src/Node/MerkleNodeInterface.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace drupol\phptree\Node;
+
+/**
+ * Interface MerkleNodeInterface.
+ */
+interface MerkleNodeInterface extends ValueNodeInterface
+{
+    /**
+     * @return \drupol\phptree\Node\MerkleNodeInterface
+     */
+    public function normalize(): MerkleNodeInterface;
+}