Update

Author: lazychaser

CHANGELOG.markdown

@@ -1,3 +1,8 @@
+### 4.2.8
+*   Support Laravel 5.5
+*   Added `fixSubtree` and `rebuildSubtree` methods
+*   Increased performance of tree rebuilding
+
 ### 4.2.7
 
 *   #217: parent_id, lft and rgt are reset when replicating a node

README.markdown

@@ -6,7 +6,7 @@
 
 This is a Laravel 4-5 package for working with trees in relational databases.
 
-*   **Laravel 5.2, 5.3, 5.4** is supported since v4
+*   **Laravel 5.2, 5.3, 5.4, 5.5** is supported since v4
 *   **Laravel 5.1** is supported in v3
 *   **Laravel 4** is supported in v2
 
@@ -214,6 +214,16 @@ Node `bar` has no primary key specified, so it will be created.
 `$delete` shows whether to delete nodes that are already exists but not present
 in `$data`. By default, nodes aren't deleted.
 
+##### Rebuilding a subtree
+
+As of 4.2.8 you can rebuild a subtree:
+
+```php
+Category::rebuildSubtree($root, $data);
+```
+
+This constraints tree rebuilding to descendants of `$root` node.
+
 ### Retrieving nodes
 
 *In some cases we will use an `$id` variable which is an id of the target node.*

src/QueryBuilder.php

@@ -841,9 +841,11 @@ public function isBroken()
      *
      * Nodes with invalid parent are saved as roots.
      *
-     * @return int The number of fixed nodes
+     * @param null|NodeTrait|Model $root
+     *
+     * @return int The number of changed nodes
      */
-    public function fixTree()
+    public function fixTree($root = null)
     {
         $columns = [
             $this->model->getKeyName(),
@@ -852,48 +854,78 @@ public function fixTree()
             $this->model->getRgtName(),
         ];
 
-        $dictionary = $this->model->newNestedSetQuery()
-                           ->defaultOrder()
-                           ->get($columns)
-                           ->groupBy($this->model->getParentIdName())
-                           ->all();
+        $dictionary = $this->model
+            ->newNestedSetQuery()
+            ->when($root, function (self $query, $root) {
+                $query->whereDescendantOf($root);
+            })
+            ->defaultOrder()
+            ->get($columns)
+            ->groupBy($this->model->getParentIdName())
+            ->all();
+
+        return $this->fixNodes($dictionary, $root);
+    }
 
-        return self::fixNodes($dictionary);
+    /**
+     * @param NodeTrait|Model $root
+     *
+     * @return int
+     */
+    public function fixSubtree($root)
+    {
+        return $this->fixTree($root);
     }
 
     /**
      * @param array $dictionary
+     * @param NodeTrait|Model|null $parent
      *
      * @return int
      */
-    protected static function fixNodes(array &$dictionary)
+    protected function fixNodes(array &$dictionary, $parent = null)
     {
-        $fixed = 0;
+        $parentId = $parent ? $parent->getKey() : null;
+        $cut = $parent ? $parent->getLft() + 1 : 1;
+
+        $updated = [];
+        $moved = 0;
 
-        $cut = self::reorderNodes($dictionary, $fixed);
+        $cut = self::reorderNodes($dictionary, $updated, $parentId, $cut);
 
         // Save nodes that have invalid parent as roots
         while ( ! empty($dictionary)) {
             $dictionary[null] = reset($dictionary);
 
             unset($dictionary[key($dictionary)]);
 
-            $cut = self::reorderNodes($dictionary, $fixed, null, $cut);
+            $cut = self::reorderNodes($dictionary, $updated, $parentId, $cut);
+        }
+
+        if ($parent && ($grown = $cut - $parent->getRgt()) != 0) {
+            $moved = $this->model->newScopedQuery()->makeGap($parent->getRgt() + 1, $grown);
+
+            $updated[] = $parent->rawNode($parent->getLft(), $cut, $parent->getParentId());
+        }
+
+        foreach ($updated as $model) {
+            $model->save();
         }
 
-        return $fixed;
+        return count($updated) + $moved;
     }
 
     /**
      * @param array $dictionary
-     * @param int $fixed
+     * @param array $updated
      * @param $parentId
      * @param int $cut
      *
      * @return int
+     * @internal param int $fixed
      */
-    protected static function reorderNodes(array &$dictionary, &$fixed,
-                                           $parentId = null, $cut = 1
+    protected static function reorderNodes(
+        array &$dictionary, array &$updated, $parentId = null, $cut = 1
     ) {
         if ( ! isset($dictionary[$parentId])) {
             return $cut;
@@ -903,17 +935,10 @@ protected static function reorderNodes(array &$dictionary, &$fixed,
         foreach ($dictionary[$parentId] as $model) {
             $lft = $cut;
 
-            $cut = self::reorderNodes($dictionary,
-                                      $fixed,
-                                      $model->getKey(),
-                                      $cut + 1);
+            $cut = self::reorderNodes($dictionary, $updated, $model->getKey(), $cut + 1);
 
-            $rgt = $cut;
-
-            if ($model->rawNode($lft, $rgt, $parentId)->isDirty()) {
-                $model->save();
-
-                $fixed++;
+            if ($model->rawNode($lft, $cut, $parentId)->isDirty()) {
+                $updated[] = $model;
             }
 
             ++$cut;
@@ -932,20 +957,29 @@ protected static function reorderNodes(array &$dictionary, &$fixed,
      * @param array $data
      * @param bool $delete Whether to delete nodes that exists but not in the data
      *                     array
+     * @param null $root
      *
      * @return int
      */
-    public function rebuildTree(array $data, $delete = false)
+    public function rebuildTree(array $data, $delete = false, $root = null)
     {
         if ($this->model->usesSoftDelete()) {
             $this->withTrashed();
         }
 
-        $existing = $this->get()->getDictionary();
+        $existing = $this
+            ->when($root, function (self $query, $root) {
+                $query->whereDescendantOf($root);
+            })
+            ->get()
+            ->getDictionary();
+
         $dictionary = [];
+        $parentId = $root ? $root->getKey() : null;
 
-        $this->buildRebuildDictionary($dictionary, $data, $existing);
+        $this->buildRebuildDictionary($dictionary, $data, $existing, $parentId);
 
+        /** @var Model|NodeTrait $model */
         if ( ! empty($existing)) {
             if ($delete && ! $this->model->usesSoftDelete()) {
                 $this->model
@@ -967,7 +1001,19 @@ public function rebuildTree(array $data, $delete = false)
             }
         }
 
-        return $this->fixNodes($dictionary);
+        return $this->fixNodes($dictionary, $root);
+    }
+
+    /**
+     * @param $root
+     * @param array $data
+     * @param bool $delete
+     *
+     * @return int
+     */
+    public function rebuildSubtree($root, array $data, $delete = false)
+    {
+        return $this->rebuildTree($data, $delete, $root);
     }
 
     /**
@@ -984,10 +1030,12 @@ protected function buildRebuildDictionary(array &$dictionary,
         $keyName = $this->model->getKeyName();
 
         foreach ($data as $itemData) {
+            /** @var NodeTrait|Model $model */
+
             if ( ! isset($itemData[$keyName])) {
                 $model = $this->model->newInstance($this->model->getAttributes());
 
-                // We will save it as raw node since tree will be fixed
+                // Set some values that will be fixed later
                 $model->rawNode(0, 0, $parentId);
             } else {
                 if ( ! isset($existing[$key = $itemData[$keyName]])) {
@@ -996,6 +1044,9 @@ protected function buildRebuildDictionary(array &$dictionary,
 
                 $model = $existing[$key];
 
+                // Disable any tree actions
+                $model->rawNode($model->getLft(), $model->getRgt(), $parentId);
+
                 unset($existing[$key]);
             }
 

tests/NodeTest.php

@@ -698,6 +698,16 @@ public function testTreeIsFixed()
         $this->assertEquals(null, $node->getParentId());
     }
 
+    public function testSubtreeIsFixed()
+    {
+        Category::where('id', '=', 8)->update([ '_lft' => 11 ]);
+
+        $fixed = Category::fixSubtree(Category::find(5));
+        $this->assertEquals($fixed, 1);
+        $this->assertTreeNotBroken();
+        $this->assertEquals(Category::find(8)->getLft(), 12);
+    }
+
     public function testParentIdDirtiness()
     {
         $node = $this->findCategory('apple');
@@ -810,6 +820,24 @@ public function testRebuildTree()
         $this->assertEquals(3, $node->getParentId());
     }
 
+    public function testRebuildSubtree()
+    {
+        $fixed = Category::rebuildSubtree(Category::find(7), [
+            [ 'name' => 'new node' ],
+            [ 'id' => '8' ],
+        ]);
+
+        echo PHP_EOL.$fixed.PHP_EOL;
+
+        $this->assertTrue($fixed > 0);
+        $this->assertTreeNotBroken();
+
+        $node = $this->findCategory('new node');
+
+        $this->assertNotNull($node);
+        $this->assertEquals($node->getLft(), 12);
+    }
+
     public function testRebuildTreeWithDeletion()
     {
         Category::rebuildTree([ [ 'name' => 'all deleted' ] ], true);