Update

Author: lazychaser

CHANGELOG.markdown

@@ -1,3 +1,10 @@
+### 4.2.3
+
+*   Added `whereAncestorOrSelf`, `ancestorsAndSelf`, `descendantsOrSelf`,
+    `whereDescendantOrSelf` helper methods
+*   #186: rebuild tree removes nodes softly when model uses SoftDeletes trait
+*   #191: added `whereIsLeaf` and `leaves` method, added `isLeaf` check on node
+
 ### 4.1.0
 
 *   #75: Converted to trait. Following methods were renamed:
@@ -21,7 +28,7 @@
 
 ### 3.1.1
 
-*   Fixed #42: model becomes dirty before save when parent is changed and using `appendTo`, 
+*   Fixed #42: model becomes dirty before save when parent is changed and using `appendTo`,
     `prependTo`, `insertBefore`, `insertAfter`.
 
 ### 3.1.0

README.markdown

@@ -375,6 +375,7 @@ $result = Category::whereDescendantOf($node)->get();
 $result = Category::whereNotDescendantOf($node)->get();
 $result = Category::orWhereDescendantOf($node)->get();
 $result = Category::orWhereNotDescendantOf($node)->get();
+$result = Category::whereDescendantAndSelf($id)->get();
 
 // Include target node into result set
 $result = Category::whereDescendantOrSelf($node)->get();
@@ -384,6 +385,7 @@ Ancestor constraints:
 
 ```php
 $result = Category::whereAncestorOf($node)->get();
+$result = Category::whereAncestorOrSelf($id)->get();
 ```
 
 `$node` can be either a primary key of the model or model instance.
@@ -490,6 +492,7 @@ Other checks:
 *   `$node->isChildOf($other);`
 *   `$node->isAncestorOf($other);`
 *   `$node->isSiblingOf($other);`
+*   `$node->isLeaf()`
 
 ### Checking consistency
 

src/NodeTrait.php

@@ -835,6 +835,14 @@ public function isRoot()
         return is_null($this->getParentId());
     }
 
+    /**
+     * @return bool
+     */
+    public function isLeaf()
+    {
+        return $this->getLft() + 1 == $this->getRgt();
+    }
+
     /**
      * Get the lft key name.
      *

src/QueryBuilder.php

@@ -2,6 +2,7 @@
 
 namespace Kalnoy\Nestedset;
 
+use Carbon\Carbon;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\ModelNotFoundException;
@@ -77,10 +78,11 @@ public function whereIsRoot()
      * @since 2.0
      *
      * @param mixed $id
+     * @param bool $andSelf
      *
      * @return $this
      */
-    public function whereAncestorOf($id)
+    public function whereAncestorOf($id, $andSelf = false)
     {
         $keyName = $this->model->getKeyName();
 
@@ -109,11 +111,23 @@ public function whereAncestorOf($id)
         $this->query->whereRaw("{$value} between {$lft} and {$rgt}");
 
         // Exclude the node
-        $this->where($keyName, '<>', $id);
+        if ( ! $andSelf) {
+            $this->where($keyName, '<>', $id);
+        }
 
         return $this;
     }
 
+    /**
+     * @param $id
+     *
+     * @return QueryBuilder
+     */
+    public function whereAncestorOrSelf($id)
+    {
+        return $this->whereAncestorOf($id, true);
+    }
+
     /**
      * Get ancestors of specified node.
      *
@@ -129,6 +143,17 @@ public function ancestorsOf($id, array $columns = array( '*' ))
         return $this->whereAncestorOf($id)->get($columns);
     }
 
+    /**
+     * @param $id
+     * @param array $columns
+     *
+     * @return \Kalnoy\Nestedset\Collection
+     */
+    public function ancestorsAndSelf($id, array $columns = [ '*' ])
+    {
+        return $this->whereAncestorOf($id, true)->get($columns);
+    }
+
     /**
      * Add node selection statement between specified range.
      *
@@ -329,6 +354,26 @@ public function whereIsBefore($id, $boolean = 'and')
         return $this->whereIsBeforeOrAfter($id, '<', $boolean);
     }
 
+    /**
+     * @return $this
+     */
+    public function whereIsLeaf()
+    {
+        list($lft, $rgt) = $this->wrappedColumns();
+
+        return $this->whereRaw("$lft = $rgt - 1");
+    }
+
+    /**
+     * @param array $columns
+     *
+     * @return Collection
+     */
+    public function leaves(array $columns = [ '*'])
+    {
+        return $this->whereIsLeaf()->get($columns);
+    }
+
     /**
      * Include depth level into the result.
      *
@@ -877,20 +922,32 @@ protected static function reorderNodes(array &$dictionary, &$fixed,
      */
     public function rebuildTree(array $data, $delete = false)
     {
+        if ($this->model->usesSoftDelete()) {
+            $this->withTrashed();
+        }
+
         $existing = $this->get()->getDictionary();
         $dictionary = [];
 
         $this->buildRebuildDictionary($dictionary, $data, $existing);
 
         if ( ! empty($existing)) {
-            if ($delete) {
+            if ($delete && ! $this->model->usesSoftDelete()) {
                 $this->model
                     ->newScopedQuery()
                     ->whereIn($this->model->getKeyName(), array_keys($existing))
-                    ->forceDelete();
+                    ->delete();
             } else {
                 foreach ($existing as $model) {
                     $dictionary[$model->getParentId()][] = $model;
+
+                    if ($this->model->usesSoftDelete()) {
+                        if ( ! $model->{$model->getDeletedAtColumn()}) {
+                            $time = $this->model->fromDateTime($this->model->freshTimestamp());
+
+                            $model->{$model->getDeletedAtColumn()} = $time;
+                        }
+                    }
                 }
             }
         }

tests/NodeTest.php

@@ -803,10 +803,16 @@ public function testRebuildTreeWithDeletion()
     {
         Category::rebuildTree([ [ 'name' => 'all deleted' ] ], true);
 
+        $this->assertTreeNotBroken();
+
         $nodes = Category::get();
 
         $this->assertEquals(1, $nodes->count());
         $this->assertEquals('all deleted', $nodes->first()->name);
+
+        $nodes = Category::withTrashed()->get();
+
+        $this->assertTrue($nodes->count() > 1);
     }
 
     /**
@@ -841,6 +847,19 @@ public function testSeveralNodesModelWork()
 
         $duplicate->saveAsRoot();
     }
+
+    public function testWhereIsLeaf()
+    {
+        $categories = Category::leaves();
+
+        $this->assertEquals(7, $categories->count());
+        $this->assertEquals('apple', $categories->first()->name);
+        $this->assertTrue($categories->first()->isLeaf());
+
+        $category = Category::whereIsRoot()->first();
+
+        $this->assertFalse($category->isLeaf());
+    }
 }
 
 function all($items)