Refactored ancestors and descendants relations

Author: lazychaser

CHANGELOG.markdown

@@ -1,3 +1,9 @@
+### 4.2.5
+
+*   #208: dirty parent and bounds when making a root
+*   #206: fixed where has on descendants
+*   refactored ancestors and descendants relations
+
 ### 4.2.4
 
 *   Fixed issues related to rebuilding tree when using `SoftDeletes` and scoping

phpunit.php

@@ -3,7 +3,7 @@
 include __DIR__.'/vendor/autoload.php';
 
 $capsule = new \Illuminate\Database\Capsule\Manager;
-$capsule->addConnection([ 'driver' => 'sqlite', 'database' => ':memory:', 'prefix' => 'prefix' ]);
+$capsule->addConnection([ 'driver' => 'sqlite', 'database' => ':memory:', 'prefix' => 'prfx_' ]);
 $capsule->setEventDispatcher(new \Illuminate\Events\Dispatcher);
 $capsule->bootEloquent();
 $capsule->setAsGlobal();

src/AncestorsRelation.php

@@ -2,101 +2,10 @@
 
 namespace Kalnoy\Nestedset;
 
-use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
-use Illuminate\Database\Eloquent\Collection as EloquentCollection;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Database\Eloquent\Relations\Relation;
-use Illuminate\Database\Query\Builder;
-use InvalidArgumentException;
-use RuntimeException;
 
-class AncestorsRelation extends Relation
+class AncestorsRelation extends BaseRelation
 {
-    /**
-     * @var QueryBuilder
-     */
-    protected $query;
-
-    /**
-     * @var NodeTrait|Model
-     */
-    protected $parent;
-
-    /**
-     * AncestorsRelation constructor.
-     *
-     * @param QueryBuilder $builder
-     * @param Model $model
-     */
-    public function __construct(QueryBuilder $builder, Model $model)
-    {
-        if ( ! NestedSet::isNode($model)) {
-            throw new InvalidArgumentException('Model must be node.');
-        }
-
-        parent::__construct($builder, $model);
-    }
-
-    /**
-     * @param EloquentBuilder $query
-     * @param EloquentBuilder $parentQuery
-     *
-     * @return null
-     */
-    public function getRelationExistenceCountQuery(EloquentBuilder $query, EloquentBuilder $parentQuery)
-    {
-        throw new RuntimeException('Cannot count ancestors, use depth functionality instead');
-    }
-
-    /**
-     * @param EloquentBuilder $query
-     * @param EloquentBuilder $parent
-     * @param array $columns
-     *
-     * @return mixed
-     */
-    public function getRelationExistenceQuery(EloquentBuilder $query, EloquentBuilder $parent,
-                                              $columns = [ '*' ]
-    ) {
-        $query->select($columns);
-
-        $table = $query->getModel()->getTable();
-
-        $query->from($table.' as '.$hash = $this->getRelationSubSelectHash());
-
-        $grammar = $query->getQuery()->getGrammar();
-
-        $table = $grammar->wrapTable($table);
-        $hash = $grammar->wrapTable($hash);
-        $parentIdName = $grammar->wrap($this->parent->getParentIdName());
-
-        return $query->whereRaw("{$hash}.{$parentIdName} = {$table}.{$parentIdName}");
-    }
-
-    /**
-     * @param EloquentBuilder $query
-     * @param EloquentBuilder $parent
-     * @param array $columns
-     *
-     * @return mixed
-     */
-    public function getRelationQuery(
-        EloquentBuilder $query, EloquentBuilder $parent,
-        $columns = [ '*' ]
-    ) {
-        return $this->getRelationExistenceQuery($query, $parent, $columns);
-    }
-
-    /**
-     * Get a relationship join table hash.
-     *
-     * @return string
-     */
-    public function getRelationSubSelectHash()
-    {
-        return 'self_'.md5(microtime(true));
-    }
-
     /**
      * Set the base constraints on the relation query.
      *
@@ -110,95 +19,39 @@ public function addConstraints()
     }
 
     /**
-     * Set the constraints for an eager load of the relation.
-     *
-     * @param  array $models
-     *
-     * @return void
-     */
-    public function addEagerConstraints(array $models)
-    {
-        $model = $this->query->getModel();
-        $table = $model->getTable();
-        $key = $model->getKeyName();
-
-        $grammar = $this->query->getQuery()->getGrammar();
-
-        $table = $grammar->wrapTable($table);
-        $hash = $grammar->wrap($this->getRelationSubSelectHash());
-        $key = $grammar->wrap($key);
-        $lft = $grammar->wrap($this->parent->getLftName());
-        $rgt = $grammar->wrap($this->parent->getRgtName());
-
-        $sql = "$key IN (SELECT DISTINCT($key) FROM {$table} INNER JOIN "
-            . "(SELECT {$lft}, {$rgt} FROM {$table} WHERE {$key} IN (" . implode(',', $this->getKeys($models))
-            . ")) AS $hash ON {$table}.{$lft} <= {$hash}.{$lft} AND {$table}.{$rgt} >= {$hash}.{$rgt})";
-
-        $this->query->whereNested(function (Builder $inner) use ($sql) {
-            $inner->whereRaw($sql);
-        });
-        $this->query->orderBy($this->parent->getLftName(), 'ASC');
-    }
-
-    /**
-     * Initialize the relation on a set of models.
-     *
-     * @param  array $models
-     * @param  string $relation
-     *
-     * @return array
-     */
-    public function initRelation(array $models, $relation)
-    {
-        return $models;
-    }
-
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param  array $models
-     * @param  EloquentCollection $results
-     * @param  string $relation
+     * @param Model $model
+     * @param $related
      *
-     * @return array
+     * @return bool
      */
-    public function match(array $models, EloquentCollection $results, $relation)
+    protected function matches(Model $model, $related)
     {
-        foreach ($models as $model) {
-            $ancestors = $this->getAncestorsForModel($model, $results);
-
-            $model->setRelation($relation, $ancestors);
-        }
-
-        return $models;
+        return $related->isAncestorOf($model);
     }
 
     /**
-     * Get the results of the relationship.
+     * @param QueryBuilder $query
+     * @param Model $model
      *
-     * @return mixed
+     * @return void
      */
-    public function getResults()
+    protected function addEagerConstraint($query, $model)
     {
-        return $this->query->get();
+        $query->orWhereAncestorOf($model);
     }
 
     /**
-     * @param Model $model
-     * @param EloquentCollection $results
+     * @param $hash
+     * @param $table
+     * @param $lft
+     * @param $rgt
      *
-     * @return Collection
+     * @return string
      */
-    protected function getAncestorsForModel(Model $model, EloquentCollection $results)
+    protected function relationExistenceCondition($hash, $table, $lft, $rgt)
     {
-        $result = $this->related->newCollection();
-
-        foreach ($results as $ancestor) {
-            if ($ancestor->isAncestorOf($model)) {
-                $result->push($ancestor);
-            }
-        }
+        $key = $this->getBaseQuery()->getGrammar()->wrap($this->parent->getKeyName());
 
-        return $result;
+        return "{$table}.{$rgt} between {$hash}.{$lft} and {$hash}.{$rgt} and $table.$key <> $hash.$key";
     }
 }