Refactor more and add UPGRADE guide and CHANGELOG

Author: lazychaser

CHANGELOG.markdown

@@ -1,3 +1,22 @@
+### 1.2.0
+
+*   Added `insertAfter`, `insertBefore` methods.
+*   `prepend` and `append` methods now save target model.
+*   You can now call `refreshNode` to make sure that node has updated structural
+    data (lft and rgt values).
+*   The root node is not required now. You can use `saveAsRoot` or `makeRoot` method.
+    New model is saved as root by default.
+*   You can now create as many nodes and in any order as possible within single 
+    request.
+*   Laravel 2 is supported but not required.
+*   `ancestorsOf` now doesn't include target node into results.
+*   New constraint methods `hasParent` and `hasChildren`.
+*   New method `isDescendantOf` that checks if node is a descendant of other node.
+*   Default order is not applied by default.
+*   New method `descendantsOf` that allows to get descendants by id of the node.
+*   Added `countErrors` and `isBroken` methods to check whether the tree is broken.
+
 ### 1.1.0
+
 *   `Collection::toDictionary` is now obsolete. Use `Collection::groupBy`.
 *   Laravel 4.2 is required

UPGRADE.markdown

@@ -0,0 +1,8 @@
+### Upgrading to 1.2
+
+Calling `$parent->append($node)` and `$parent->prepend($node)` now automatically
+saves `$node`. Those functions returns whether the node was saved.
+
+`ancestorsOf` now return ancestors only not including target node.
+
+Default order is not applied automatically.

src/Kalnoy/Nestedset/Node.php

@@ -66,7 +66,7 @@ class Node extends Eloquent {
      * 
      * @var int
      */
-    static $actionsPerformed = 0;
+    protected static $actionsPerformed = 0;
 
     /**
      * {@inheritdoc}
@@ -290,6 +290,7 @@ public function refreshNode()
         $attributes = $this->newServiceQuery()->getNodeData($this->getKey());
 
         $this->attributes = array_merge($this->attributes, $attributes);
+        $this->original = array_merge($this->original, $attributes);
     }
 
     /**
@@ -414,7 +415,7 @@ public function prev()
      */
     public function ancestors()
     {
-        return $this->newQuery()->whereAncestorOf($this->getKey());
+        return $this->newQuery()->whereAncestorOf($this->getKey())->defaultOrder();
     }
 
     /**
@@ -576,68 +577,36 @@ public function down($amount = 1)
      */
     protected function insertAt($position)
     {
-        $this->refreshNode();
-
-        if ($this->exists && $this->getLft() < $position && $position < $this->getRgt()) 
-        {
-            throw new Exception("Trying to insert node into one of it's descendants.");
-        }
+        ++static::$actionsPerformed;
 
-        if ($this->exists)
-        {
-            $this->moveNode($position);
-        }
-        else
-        {
-            $this->insertNode($position);
-        }
+        $result = $this->exists ? $this->moveNode($position) : $this->insertNode($position);
 
-        ++static::$actionsPerformed;
+        return $result;
     }
 
     /**
-     * Move a node to new position.
+     * Move a node to the new position.
+     * 
+     * @since 2.0
      *
-     * @param int $lft
-     * @param int $rgt
-     * @param int $pos
+     * @param int $position
      *
      * @return int
      */
-    protected function moveNode($pos)
+    protected function moveNode($position)
     {
-        $lft = $this->getLft();
-        $rgt = $this->getRgt();
-
-        $from = min($lft, $pos);
-        $to   = max($rgt, $pos - 1);
-
-        // The height of node that is being moved
-        $height = $rgt - $lft + 1;
-
-        // The distance that our node will travel to reach it's destination
-        $distance = $to - $from + 1 - $height;
-
-        if ($pos > $lft) $height *= -1; else $distance *= -1;
+        $updated = $this->newServiceQuery()->moveNode($this->getKey(), $position);
 
-        $params = compact('lft', 'rgt', 'from', 'to', 'height', 'distance');
+        if ($updated) $this->refreshNode();
 
-        $query = $this->newServiceQuery()->getQuery()
-            ->whereBetween(static::LFT, array($from, $to))
-            ->orWhereBetween(static::RGT, array($from, $to));
-
-        $grammar = $query->getGrammar();
-
-        // Sync with original since those attributes are updated after prev operation
-        $this->original[static::LFT] = $this->attributes[static::LFT] += $distance;
-        $this->original[static::RGT] = $this->attributes[static::RGT] += $distance;
-
-        return $query->update($this->getColumnsPatch($params, $grammar));
+        return $updated > 0;
     }
 
     /**
      * Insert new node at specified position.
      * 
+     * @since 2.0
+     * 
      * @param int $position
      */
     protected function insertNode($position)
@@ -648,74 +617,8 @@ protected function insertNode($position)
 
         $this->setAttribute(static::LFT, $position);
         $this->setAttribute(static::RGT, $position + $height - 1);
-    }
-
-    /**
-     * Make or remove gap in the tree. Negative height will remove gap.
-     *
-     * @param int $cut
-     * @param int $height
-     *
-     * @return int the number of updated nodes.
-     */
-    protected function makeGap($cut, $height)
-    {
-        $params = compact('cut', 'height');
-        
-        $query = $this->newServiceQuery()->getQuery();
-
-        return $query
-            ->where(static::LFT, '>=', $cut)
-            ->orWhere(static::RGT, '>=', $cut)
-            ->update($this->getColumnsPatch($params, $query->getGrammar()));
-    }
-
-    /**
-     * Get patch for columns.
-     *
-     * @param  array  $params
-     * @param  \Illuminate\Database\Query\Grammars\Grammar $grammar
-     *
-     * @return array
-     */
-    protected function getColumnsPatch(array $params, $grammar)
-    {
-        $columns = array();
-
-        foreach (array(static::LFT, static::RGT) as $col) 
-        {
-            $columns[$col] = $this->getColumnPatch($grammar->wrap($col), $params);
-        }
 
-        return $columns;
-    }
-
-    /**
-     * Get patch for single column.
-     *
-     * @param  string $col
-     * @param  array  $params
-     *
-     * @return string
-     */
-    protected function getColumnPatch($col, array $params)
-    {
-        extract($params);
-
-        if ($height > 0) $height = '+'.$height;
-
-        if (isset($cut)) 
-        {
-            return new Expression("case when $col >= $cut then $col $height else $col end");
-        }
-
-        if ($distance > 0) $distance = '+'.$distance;
-
-        return new Expression("case ".
-            "when $col between $lft and $rgt then $col $distance ".
-            "when $col between $from and $to then $col $height ".
-            "else $col end"
-        );
+        return true;
     }
 
     /**
@@ -737,7 +640,7 @@ protected function deleteNode()
     /**
      * {@inheritdoc}
      * 
-     * @since 1.2
+     * @since 2.0
      */
     public function newEloquentBuilder($query)
     {
@@ -775,7 +678,7 @@ public function newFromBuilder($attributes = array())
     }
 
     /**
-     * Get node size (rgt-lft).
+     * Get node height (rgt - lft + 1).
      *
      * @return int
      */
@@ -1002,4 +905,40 @@ public function isDescendantOf(Node $other)
     {
         return $this->getLft() > $other->getLft() and $this->getLft() < $other->getRgt();
     }
+
+    /**
+     * Get statistics of errors of the tree.
+     * 
+     * @since 2.0
+     * 
+     * @return array
+     */
+    public function countErrors()
+    {
+        return $this->newServiceQuery()->countErrors();
+    }
+
+    /**
+     * Get the number of total errors of the tree.
+     * 
+     * @since 2.0
+     * 
+     * @return int
+     */
+    public function getTotalErrors()
+    {
+        return array_sum($this->countErrors());
+    }
+
+    /**
+     * Get whether the tree is broken.
+     * 
+     * @since 2.0
+     * 
+     * @return bool
+     */
+    public function isBroken()
+    {
+        return $this->getTotalErrors() > 0;
+    }
 }