Fixed lazychaser#53: support l5.1.9

Author: lazychaser

CHANGELOG.markdown

@@ -1,3 +1,10 @@
+### 3.0.0
+
+*   Support Laravel 5.1.9
+*   Renamed `append` to `appendNode`, `prepend` to `prependNode`
+*   Renamed `next` to `nextNodes`, `prev` to `prevNodes`
+*   Renamed `after` to `afterNode`, `before` to `beforeNode`
+
 ### 2.4.0
 
 *   Added query methods `whereNotDescendantOf`, `orWhereDescendantOf`, `orWhereNotDescendantOf`

README.markdown

@@ -106,7 +106,7 @@ There are few ways to append a node:
 $node->appendTo($parent)->save();
 
 // #2 Using parent node
-$parent->append($node);
+$parent->appendNode($node);
 
 // #3 Using parent's children relationship
 $parent->children()->create($attributes);
@@ -129,7 +129,7 @@ And only a couple ways to prepend:
 $node->prependTo($parent)->save();
 
 // #2
-$parent->prepend($node);
+$parent->prependNode($node);
 ```
 
 #### Inserting before or after specified node
@@ -141,8 +141,8 @@ it will be moved to the new position and parent will be changed if it's needed.*
 
 ```php
 # Explicit save
-$node->after($neighbor)->save();
-$node->before($neighbor)->save();
+$node->afterNode($neighbor)->save();
+$node->beforeNode($neighbor)->save();
 
 # Implicit save
 $node->insertAfter($neighbor);

UPGRADE.markdown

@@ -1,3 +1,7 @@
+### Upgrading to 3.0
+
+Some methods were renamed, see changelog for more details.
+
 ### Upgrading to 2.0
 
 Calling `$parent->append($node)` and `$parent->prepend($node)` now automatically

src/Node.php

@@ -430,12 +430,12 @@ public function siblings($dir = null)
         switch ($dir)
         {
             case self::AFTER:
-                $query = $this->next();
+                $query = $this->nextNodes();
 
                 break;
 
             case self::BEFORE:
-                $query = $this->prev();
+                $query = $this->prevNodes();
 
                 break;
 
@@ -477,7 +477,7 @@ public function prevSiblings()
      *
      * @return QueryBuilder
      */
-    public function next()
+    public function nextNodes()
     {
         return $this->newQuery()->whereIsAfter($this->getKey())->defaultOrder();
     }
@@ -487,7 +487,7 @@ public function next()
      *
      * @return QueryBuilder
      */
-    public function prev()
+    public function prevNodes()
     {
         return $this->newQuery()->whereIsBefore($this->getKey())->reversed();
     }
@@ -529,7 +529,7 @@ public function saveAsRoot()
      *
      * @return bool
      */
-    public function append(Node $node)
+    public function appendNode(Node $node)
     {
         return $node->appendTo($this)->save();
     }
@@ -541,7 +541,7 @@ public function append(Node $node)
      *
      * @return bool
      */
-    public function prepend(Node $node)
+    public function prependNode(Node $node)
     {
         return $node->prependTo($this)->save();
     }
@@ -577,7 +577,7 @@ public function prependTo(Node $parent)
      *
      * @return $this
      */
-    public function after(Node $node)
+    public function afterNode(Node $node)
     {
         return $this->setAction('after', $node);
     }
@@ -591,7 +591,7 @@ public function after(Node $node)
      */
     public function insertAfter(Node $node)
     {
-        return $this->after($node)->save();
+        return $this->afterNode($node)->save();
     }
 
     /**
@@ -601,7 +601,7 @@ public function insertAfter(Node $node)
      *
      * @return $this
      */
-    public function before(Node $node)
+    public function beforeNode(Node $node)
     {
         return $this->setAction('before', $node);
     }
@@ -615,7 +615,7 @@ public function before(Node $node)
      */
     public function insertBefore(Node $node)
     {
-        if ($this->before($node)->save())
+        if ($this->beforeNode($node)->save())
         {
             // We'll' update the target node since it will be moved
             $node->refreshNode();
@@ -817,7 +817,6 @@ public function newFromBuilder($attributes = array(), $connection = null)
      * Use `children` key on `$attributes` to create child nodes.
      *
      * @param Node $parent
-     *
      */
     public static function create(array $attributes = array(), Node $parent = null)
     {
@@ -967,7 +966,7 @@ public function getParentId()
      */
     public function getNext(array $columns = array('*'))
     {
-        return $this->next()->first($columns);
+        return $this->nextNodes()->first($columns);
     }
 
     /**
@@ -979,7 +978,7 @@ public function getNext(array $columns = array('*'))
      */
     public function getPrev(array $columns = array('*'))
     {
-        return $this->prev()->first($columns);
+        return $this->prevNodes()->first($columns);
     }
 
     /**

tests/NodeTest.php

@@ -63,7 +63,7 @@ public function assertTreeNotBroken($table = 'categories')
 
         $sql = 'select max(error) as errors from ('.implode(' union ', $checks).') _';
 
-        $actual = Capsule::connection()->selectOne($sql);
+        $actual = (array)Capsule::connection()->selectOne($sql);
 
         $this->assertEquals(array('errors' => null), $actual, "The tree structure of $table is broken!");
     }
@@ -137,7 +137,7 @@ public function testRecievesValidValuesWhenAppendedTo()
 
         $accepted = array($root->_rgt, $root->_rgt + 1, $root->id);
 
-        $root->append($node);
+        $root->appendNode($node);
 
         $this->assertTrue($node->hasMoved());
         $this->assertEquals($accepted, $this->nodeValues($node));
@@ -150,7 +150,7 @@ public function testRecievesValidValuesWhenPrependedTo()
     {
         $root = Category::root();
         $node = new Category([ 'name' => 'test' ]);
-        $root->prepend($node);
+        $root->prependNode($node);
 
         $this->assertTrue($node->hasMoved());
         $this->assertEquals(array($root->_lft + 1, $root->_lft + 2, $root->id), $this->nodeValues($node));
@@ -164,7 +164,7 @@ public function testRecievesValidValuesWhenInsertedAfter()
     {
         $target = $this->findCategory('apple');
         $node = new Category([ 'name' => 'test' ]);
-        $node->after($target)->save();
+        $node->afterNode($target)->save();
 
         $this->assertTrue($node->hasMoved());
         $this->assertEquals(array($target->_rgt + 1, $target->_rgt + 2, $target->parent->id), $this->nodeValues($node));
@@ -177,7 +177,7 @@ public function testRecievesValidValuesWhenInsertedBefore()
     {
         $target = $this->findCategory('apple');
         $node = new Category([ 'name' => 'test' ]);
-        $node->before($target)->save();
+        $node->beforeNode($target)->save();
 
         $this->assertTrue($node->hasMoved());
         $this->assertEquals(array($target->_lft, $target->_lft + 1, $target->parent->id), $this->nodeValues($node));
@@ -189,7 +189,7 @@ public function testCategoryMovesDown()
         $node = $this->findCategory('apple');
         $target = $this->findCategory('mobile');
 
-        $target->append($node);
+        $target->appendNode($node);
 
         $this->assertTrue($node->hasMoved());
         $this->assertNodeRecievesValidValues($node);
@@ -201,7 +201,7 @@ public function testCategoryMovesUp()
         $node = $this->findCategory('samsung');
         $target = $this->findCategory('notebooks');
 
-        $target->append($node);
+        $target->appendNode($node);
 
         $this->assertTrue($node->hasMoved());
         $this->assertTreeNotBroken();
@@ -216,7 +216,7 @@ public function testFailsToInsertIntoItself()
         $node = $this->findCategory('notebooks');
         $target = $node->children()->first();
 
-        $node->after($target)->save();
+        $node->afterNode($target)->save();
     }
 
     public function testWithoutRootWorks()
@@ -229,42 +229,42 @@ public function testWithoutRootWorks()
     public function testAncestorsReturnsAncestorsWithoutNodeItself()
     {
         $node = $this->findCategory('apple');
-        $path = $node->ancestors()->lists('name');
+        $path = $node->ancestors()->lists('name')->all();
 
         $this->assertEquals(array('store', 'notebooks'), $path);
     }
 
     public function testGetsAncestorsByStatic()
     {
-        $path = Category::ancestorsOf(3)->lists('name');
+        $path = Category::ancestorsOf(3)->lists('name')->all();
 
         $this->assertEquals(array('store', 'notebooks'), $path);
     }
 
     public function testGetsAncestorsDirect()
     {
-        $path = Category::find(8)->getAncestors()->lists('id');
+        $path = Category::find(8)->getAncestors()->lists('id')->all();
 
         $this->assertEquals(array(1, 5, 7), $path);
     }
 
     public function testDescendants()
     {
         $node = $this->findCategory('mobile');
-        $descendants = $node->descendants()->lists('name');
+        $descendants = $node->descendants()->lists('name')->all();
         $expected = array('nokia', 'samsung', 'galaxy', 'sony', 'lenovo');
 
         $this->assertEquals($expected, $descendants);
 
-        $descendants = $node->getDescendants()->lists('name');
+        $descendants = $node->getDescendants()->lists('name')->all();
 
         $this->assertEquals(count($descendants), $node->getDescendantCount());
         $this->assertEquals($expected, $descendants);
     }
 
     public function testWithDepthWorks()
     {
-        $nodes = Category::withDepth()->limit(4)->lists('depth');
+        $nodes = Category::withDepth()->limit(4)->lists('depth')->all();
 
         $this->assertEquals(array(0, 1, 2, 2), $nodes);
     }
@@ -378,17 +378,17 @@ public function testFailsToSaveNodeUntilParentIsSaved()
     public function testSiblings()
     {
         $node = $this->findCategory('samsung');
-        $siblings = $node->siblings()->lists('id');
-        $next = $node->nextSiblings()->lists('id');
-        $prev = $node->prevSiblings()->lists('id');
+        $siblings = $node->siblings()->lists('id')->all();
+        $next = $node->nextSiblings()->lists('id')->all();
+        $prev = $node->prevSiblings()->lists('id')->all();
 
         $this->assertEquals(array(6, 9, 10), $siblings);
         $this->assertEquals(array(9, 10), $next);
         $this->assertEquals(array(6), $prev);
 
-        $siblings = $node->getSiblings()->lists('id');
-        $next = $node->getNextSiblings()->lists('id');
-        $prev = $node->getPrevSiblings()->lists('id');
+        $siblings = $node->getSiblings()->lists('id')->all();
+        $next = $node->getNextSiblings()->lists('id')->all();
+        $prev = $node->getPrevSiblings()->lists('id')->all();
 
         $this->assertEquals(array(6, 9, 10), $siblings);
         $this->assertEquals(array(9, 10), $next);
@@ -404,7 +404,7 @@ public function testSiblings()
     public function testFetchesReversed()
     {
         $node = $this->findCategory('sony');
-        $siblings = $node->prevSiblings()->reversed()->pluck('id');
+        $siblings = $node->prevSiblings()->reversed()->value('id');
 
         $this->assertEquals(7, $siblings);
     }
@@ -468,15 +468,15 @@ public function testToTreeBuildsWithRootItemIdProvided()
     public function testRetrievesNextNode()
     {
         $node = $this->findCategory('apple');
-        $next = $node->next()->first();
+        $next = $node->nextNodes()->first();
 
         $this->assertEquals('lenovo', $next->name);
     }
 
     public function testRetrievesPrevNode()
     {
         $node = $this->findCategory('apple');
-        $next = $node->prev()->first();
+        $next = $node->prevNodes()->first();
 
         $this->assertEquals('notebooks', $next->name);
     }
@@ -487,11 +487,11 @@ public function testMultipleAppendageWorks()
 
         $child = new Category([ 'name' => 'test' ]);
 
-        $parent->append($child);
+        $parent->appendNode($child);
 
-        $child->append(new Category([ 'name' => 'sub' ]));
+        $child->appendNode(new Category([ 'name' => 'sub' ]));
 
-        $parent->append(new Category([ 'name' => 'test2' ]));
+        $parent->appendNode(new Category([ 'name' => 'test2' ]));
 
         $this->assertTreeNotBroken();
     }
@@ -592,15 +592,15 @@ public function testWhereDescendantsOf()
     public function testAncestorsByNode()
     {
         $category = $this->findCategory('apple');
-        $ancestors = Category::whereAncestorOf($category)->lists('id');
+        $ancestors = Category::whereAncestorOf($category)->lists('id')->all();
 
         $this->assertEquals([ 1, 2 ], $ancestors);
     }
 
     public function testDescendantsByNode()
     {
         $category = $this->findCategory('notebooks');
-        $res = Category::whereDescendantOf($category)->lists('id');
+        $res = Category::whereDescendantOf($category)->lists('id')->all();
 
         $this->assertEquals([ 3, 4 ], $res);
     }