analogueorm / analogue

src/MagicCasting.php

Indentation +102 added lines, -102 removed lines

@@ -8,117 +8,117 @@
 
 trait MagicCasting
 {
-    /**
-     * Determine if the given attribute exists.
-     *
-     * @param mixed $offset
-     *
-     * @return bool
-     */
-    public function offsetExists($offset)
-    {
-        return isset($this->$offset);
-    }
+	/**
+	 * Determine if the given attribute exists.
+	 *
+	 * @param mixed $offset
+	 *
+	 * @return bool
+	 */
+	public function offsetExists($offset)
+	{
+		return isset($this->$offset);
+	}
 
-    /**
-     * Get the value for a given offset.
-     *
-     * @param mixed $offset
-     *
-     * @return mixed
-     */
-    public function offsetGet($offset)
-    {
-        return $this->$offset;
-    }
+	/**
+	 * Get the value for a given offset.
+	 *
+	 * @param mixed $offset
+	 *
+	 * @return mixed
+	 */
+	public function offsetGet($offset)
+	{
+		return $this->$offset;
+	}
 
-    /**
-     * Set the value for a given offset.
-     *
-     * @param mixed $offset
-     * @param mixed $value
-     *
-     * @return void
-     */
-    public function offsetSet($offset, $value)
-    {
-        $this->$offset = $value;
-    }
+	/**
+	 * Set the value for a given offset.
+	 *
+	 * @param mixed $offset
+	 * @param mixed $value
+	 *
+	 * @return void
+	 */
+	public function offsetSet($offset, $value)
+	{
+		$this->$offset = $value;
+	}
 
-    /**
-     * Unset the value for a given offset.
-     *
-     * @param mixed $offset
-     *
-     * @return void
-     */
-    public function offsetUnset($offset)
-    {
-        unset($this->$offset);
-    }
+	/**
+	 * Unset the value for a given offset.
+	 *
+	 * @param mixed $offset
+	 *
+	 * @return void
+	 */
+	public function offsetUnset($offset)
+	{
+		unset($this->$offset);
+	}
 
-    /**
-     * Convert the object into something JSON serializable.
-     *
-     * @return array
-     */
-    public function jsonSerialize()
-    {
-        return $this->toArray();
-    }
+	/**
+	 * Convert the object into something JSON serializable.
+	 *
+	 * @return array
+	 */
+	public function jsonSerialize()
+	{
+		return $this->toArray();
+	}
 
-    /**
-     * Convert the entity instance to JSON.
-     *
-     * @param int $options
-     *
-     * @return string
-     */
-    public function toJson($options = 0)
-    {
-        return json_encode($this->toArray(), $options);
-    }
+	/**
+	 * Convert the entity instance to JSON.
+	 *
+	 * @param int $options
+	 *
+	 * @return string
+	 */
+	public function toJson($options = 0)
+	{
+		return json_encode($this->toArray(), $options);
+	}
 
-    /**
-     * Convert Mappable object to array;.
-     *
-     * @return array
-     */
-    public function toArray()
-    {
-        return $this->attributesToArray($this->attributes);
-    }
+	/**
+	 * Convert Mappable object to array;.
+	 *
+	 * @return array
+	 */
+	public function toArray()
+	{
+		return $this->attributesToArray($this->attributes);
+	}
 
-    /**
-     * Transform the Object to array/json,.
-     *
-     * @param array $sourceAttributes
-     *
-     * @return array
-     */
-    protected function attributesToArray(array $sourceAttributes)
-    {
-        $attributes = [];
+	/**
+	 * Transform the Object to array/json,.
+	 *
+	 * @param array $sourceAttributes
+	 *
+	 * @return array
+	 */
+	protected function attributesToArray(array $sourceAttributes)
+	{
+		$attributes = [];
 
-        foreach ($sourceAttributes as $key => $attribute) {
-            // If the attribute is a proxy, and hasn't be loaded, we discard
-            // it from the returned set.
-            if ($attribute instanceof ProxyInterface && !$attribute->isProxyInitialized()) {
-                continue;
-            }
+		foreach ($sourceAttributes as $key => $attribute) {
+			// If the attribute is a proxy, and hasn't be loaded, we discard
+			// it from the returned set.
+			if ($attribute instanceof ProxyInterface && !$attribute->isProxyInitialized()) {
+				continue;
+			}
 
-            if ($attribute instanceof Carbon) {
-                $attributes[$key] = $attribute->__toString();
-                continue;
-            }
+			if ($attribute instanceof Carbon) {
+				$attributes[$key] = $attribute->__toString();
+				continue;
+			}
 
-            if ($attribute instanceof Arrayable) {
-                $attributes[$key] = $attribute->toArray();
-            } else {
-                $attributes[$key] = $attribute;
-            }
-        }
+			if ($attribute instanceof Arrayable) {
+				$attributes[$key] = $attribute->toArray();
+			} else {
+				$attributes[$key] = $attribute;
+			}
+		}
 
-        return $attributes;
-    }
+		return $attributes;
+	}
 }

src/System/Query.php

Spacing +1 added lines, -1 removed lines

@@ -514,7 +514,7 @@
      */
     protected function getHasRelationQuery($relation, $entity)
     {
-        return Relationship::noConstraints(function () use ($relation, $entity) {
+        return Relationship::noConstraints(function() use ($relation, $entity) {
             return $this->entityMap->$relation($entity);
         });
     }

Doc Comments +2 added lines, -2 removed lines

@@ -176,7 +176,7 @@ 
      *
      * @throws \Analogue\ORM\Exceptions\EntityNotFoundException
      *
-     * @return mixed|self
+     * @return \Analogue\ORM\Mappable
      */
     public function findOrFail($id, $columns = ['*'])
     {
@@ -247,7 +247,7 @@ 
      * @param string $column
      * @param string $key
      *
-     * @return array
+     * @return Collection
      */
     public function lists($column, $key = null)
     {

Indentation +653 added lines, -653 removed lines

@@ -20,657 +20,657 @@
  */
 class Query
 {
-    /**
-     * Mapper Instance.
-     *
-     * @var \Analogue\ORM\System\Mapper
-     */
-    protected $mapper;
-
-    /**
-     * DB Adatper.
-     *
-     * @var \Analogue\ORM\Drivers\DBAdapter
-     */
-    protected $adapter;
-
-    /**
-     * Query Builder Instance.
-     *
-     * @var \Illuminate\Database\Query\Builder
-     */
-    protected $query;
-
-    /**
-     * Entity Map Instance.
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * The relationships that should be eager loaded.
-     *
-     * @var array
-     */
-    protected $eagerLoad = [];
-
-    /**
-     * All of the registered builder macros.
-     *
-     * @var array
-     */
-    protected $macros = [];
-
-    /**
-     * The methods that should be returned from query builder.
-     *
-     * @var array
-     */
-    protected $passthru = [
-        'cursor',
-        'toSql',
-        'lists',
-        'pluck',
-        'count',
-        'min',
-        'max',
-        'avg',
-        'sum',
-        'exists',
-        'getBindings',
-    ];
-
-    /**
-     * Query Builder Blacklist.
-     */
-    protected $blacklist = [
-        'insert',
-        'insertGetId',
-        'lock',
-        'lockForUpdate',
-        'sharedLock',
-        'update',
-        'increment',
-        'decrement',
-        'delete',
-        'truncate',
-        'raw',
-    ];
-
-    /**
-     * Create a new Analogue Query Builder instance.
-     *
-     * @param Mapper    $mapper
-     * @param DBAdapter $adapter
-     */
-    public function __construct(Mapper $mapper, DBAdapter $adapter)
-    {
-        $this->mapper = $mapper;
-
-        $this->adapter = $adapter;
-
-        $this->entityMap = $mapper->getEntityMap();
-
-        // Specify the table to work on
-        $this->query = $adapter->getQuery()->from($this->entityMap->getTable());
-
-        $this->with($this->entityMap->getEagerloadedRelationships());
-    }
-
-    /**
-     * Run the query and return the result.
-     *
-     * @param array $columns
-     *
-     * @return \Illuminate\Support\Collection
-     */
-    public function get($columns = ['*']) : Collection
-    {
-        return $this->getEntities($columns);
-    }
-
-    /**
-     * Find an entity by its primary key.
-     *
-     * @param string|int $id
-     * @param array      $columns
-     *
-     * @return \Analogue\ORM\Mappable
-     */
-    public function find($id, $columns = ['*'])
-    {
-        if (is_array($id)) {
-            return $this->findMany($id, $columns);
-        }
-
-        $this->query->where($this->entityMap->getKeyName(), '=', $id);
-
-        return $this->first($columns);
-    }
-
-    /**
-     * Find many entities by their primary keys.
-     *
-     * @param array $id
-     * @param array $columns
-     *
-     * @return \Illuminate\Support\Collection
-     */
-    public function findMany($id, $columns = ['*'])
-    {
-        if (empty($id)) {
-            return new EntityCollection();
-        }
-
-        $this->query->whereIn($this->entityMap->getKeyName(), $id);
-
-        return $this->get($columns);
-    }
-
-    /**
-     * Find a model by its primary key or throw an exception.
-     *
-     * @param mixed $id
-     * @param array $columns
-     *
-     * @throws \Analogue\ORM\Exceptions\EntityNotFoundException
-     *
-     * @return mixed|self
-     */
-    public function findOrFail($id, $columns = ['*'])
-    {
-        if (!is_null($entity = $this->find($id, $columns))) {
-            return $entity;
-        }
-
-        throw (new EntityNotFoundException())->setEntity(get_class($this->entityMap));
-    }
-
-    /**
-     * Execute the query and get the first result.
-     *
-     * @param array $columns
-     *
-     * @return \Analogue\ORM\Entity
-     */
-    public function first($columns = ['*'])
-    {
-        return $this->take(1)->get($columns)->first();
-    }
-
-    /**
-     * Execute the query and get the first result or throw an exception.
-     *
-     * @param array $columns
-     *
-     * @throws EntityNotFoundException
-     *
-     * @return \Analogue\ORM\Entity
-     */
-    public function firstOrFail($columns = ['*'])
-    {
-        if (!is_null($entity = $this->first($columns))) {
-            return $entity;
-        }
-
-        throw (new EntityNotFoundException())->setEntity(get_class($this->entityMap));
-    }
-
-    /**
-     * Chunk the results of the query.
-     *
-     * @param int      $count
-     * @param callable $callback
-     *
-     * @return void
-     */
-    public function chunk($count, callable $callback)
-    {
-        $results = $this->forPage($page = 1, $count)->get();
-
-        while (count($results) > 0) {
-            // On each chunk result set, we will pass them to the callback and then let the
-            // developer take care of everything within the callback, which allows us to
-            // keep the memory low for spinning through large result sets for working.
-            call_user_func($callback, $results);
-
-            $page++;
-
-            $results = $this->forPage($page, $count)->get();
-        }
-    }
-
-    /**
-     * Get an array with the values of a given column.
-     *
-     * @param string $column
-     * @param string $key
-     *
-     * @return array
-     */
-    public function lists($column, $key = null)
-    {
-        return $this->query->pluck($column, $key);
-    }
-
-    /**
-     * Get a paginator for the "select" statement.
-     *
-     * @param int   $perPage
-     * @param array $columns
-     *
-     * @return LengthAwarePaginator
-     */
-    public function paginate($perPage = null, $columns = ['*'])
-    {
-        $total = $this->query->getCountForPagination();
-
-        $this->query->forPage(
-            $page = Paginator::resolveCurrentPage(),
-            $perPage = $perPage ?: $this->entityMap->getPerPage()
-        );
-
-        return new LengthAwarePaginator($this->get($columns)->all(), $total, $perPage, $page, [
-            'path' => Paginator::resolveCurrentPath(),
-        ]);
-    }
-
-    /**
-     * Get a paginator for a grouped statement.
-     *
-     * @param \Illuminate\Pagination\Factory $paginator
-     * @param int                            $perPage
-     * @param array                          $columns
-     *
-     * @return \Illuminate\Pagination\Paginator
-     */
-    protected function groupedPaginate($paginator, $perPage, $columns)
-    {
-        $results = $this->get($columns)->all();
-
-        return $this->query->buildRawPaginator($paginator, $results, $perPage);
-    }
-
-    /**
-     * Get a paginator for an ungrouped statement.
-     *
-     * @param \Illuminate\Pagination\Factory $paginator
-     * @param int                            $perPage
-     * @param array                          $columns
-     *
-     * @return \Illuminate\Pagination\Paginator
-     */
-    protected function ungroupedPaginate($paginator, $perPage, $columns)
-    {
-        $total = $this->query->getPaginationCount();
-
-        // Once we have the paginator we need to set the limit and offset values for
-        // the query so we can get the properly paginated items. Once we have an
-        // array of items we can create the paginator instances for the items.
-        $page = $paginator->getCurrentPage($total);
-
-        $this->query->forPage($page, $perPage);
-
-        return $paginator->make($this->get($columns)->all(), $total, $perPage);
-    }
-
-    /**
-     * Paginate the given query into a simple paginator.
-     *
-     * @param int   $perPage
-     * @param array $columns
-     *
-     * @return \Illuminate\Contracts\Pagination\Paginator
-     */
-    public function simplePaginate($perPage = null, $columns = ['*'])
-    {
-        $page = Paginator::resolveCurrentPage();
-
-        $perPage = $perPage ?: $this->entityMap->getPerPage();
-
-        $this->skip(($page - 1) * $perPage)->take($perPage + 1);
-
-        return new Paginator($this->get($columns)->all(), $perPage, $page, ['path' => Paginator::resolveCurrentPath()]);
-    }
-
-    /**
-     * Add a basic where clause to the query.
-     *
-     * @param string $column
-     * @param string $operator
-     * @param mixed  $value
-     * @param string $boolean
-     *
-     * @return $this
-     */
-    public function where($column, $operator = null, $value = null, $boolean = 'and')
-    {
-        if ($column instanceof Closure) {
-            $query = $this->newQueryWithoutScopes();
-
-            call_user_func($column, $query);
-
-            $this->query->addNestedWhereQuery($query->getQuery(), $boolean);
-        } else {
-            call_user_func_array([$this->query, 'where'], func_get_args());
-        }
-
-        return $this;
-    }
-
-    /**
-     * Add an "or where" clause to the query.
-     *
-     * @param string $column
-     * @param string $operator
-     * @param mixed  $value
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function orWhere($column, $operator = null, $value = null)
-    {
-        return $this->where($column, $operator, $value, 'or');
-    }
-
-    /**
-     * Add a relationship count condition to the query.
-     *
-     * @param string   $relation
-     * @param string   $operator
-     * @param int      $count
-     * @param string   $boolean
-     * @param \Closure $callback
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function has($relation, $operator = '>=', $count = 1, $boolean = 'and', $callback = null)
-    {
-        $entity = $this->mapper->newInstance();
-
-        $relation = $this->getHasRelationQuery($relation, $entity);
-
-        $query = $relation->getRelationCountQuery($relation->getRelatedMapper()->getQuery(), $this);
-
-        if ($callback) {
-            call_user_func($callback, $query);
-        }
-
-        return $this->addHasWhere($query, $relation, $operator, $count, $boolean);
-    }
-
-    /**
-     * Add a relationship count condition to the query with where clauses.
-     *
-     * @param string   $relation
-     * @param \Closure $callback
-     * @param string   $operator
-     * @param int      $count
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function whereHas($relation, Closure $callback, $operator = '>=', $count = 1)
-    {
-        return $this->has($relation, $operator, $count, 'and', $callback);
-    }
-
-    /**
-     * Add a relationship count condition to the query with an "or".
-     *
-     * @param string $relation
-     * @param string $operator
-     * @param int    $count
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function orHas($relation, $operator = '>=', $count = 1)
-    {
-        return $this->has($relation, $operator, $count, 'or');
-    }
-
-    /**
-     * Add a relationship count condition to the query with where clauses and an "or".
-     *
-     * @param string   $relation
-     * @param \Closure $callback
-     * @param string   $operator
-     * @param int      $count
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function orWhereHas($relation, Closure $callback, $operator = '>=', $count = 1)
-    {
-        return $this->has($relation, $operator, $count, 'or', $callback);
-    }
-
-    /**
-     * Add the "has" condition where clause to the query.
-     *
-     * @param \Analogue\ORM\System\Query               $hasQuery
-     * @param \Analogue\ORM\Relationships\Relationship $relation
-     * @param string                                   $operator
-     * @param int                                      $count
-     * @param string                                   $boolean
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    protected function addHasWhere(self $hasQuery, Relationship $relation, $operator, $count, $boolean)
-    {
-        $this->mergeWheresToHas($hasQuery, $relation);
-
-        if (is_numeric($count)) {
-            $count = new Expression($count);
-        }
-
-        return $this->where(new Expression('('.$hasQuery->toSql().')'), $operator, $count, $boolean);
-    }
-
-    /**
-     * Merge the "wheres" from a relation query to a has query.
-     *
-     * @param \Analogue\ORM\System\Query               $hasQuery
-     * @param \Analogue\ORM\Relationships\Relationship $relation
-     *
-     * @return void
-     */
-    protected function mergeWheresToHas(self $hasQuery, Relationship $relation)
-    {
-        // Here we have the "has" query and the original relation. We need to copy over any
-        // where clauses the developer may have put in the relationship function over to
-        // the has query, and then copy the bindings from the "has" query to the main.
-        $relationQuery = $relation->getBaseQuery();
-
-        $hasQuery->mergeWheres(
-            $relationQuery->wheres, $relationQuery->getBindings()
-        );
-
-        $this->query->mergeBindings($hasQuery->getQuery());
-    }
-
-    /**
-     * Get the "has relation" base query instance.
-     *
-     * @param string $relation
-     * @param        $entity
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    protected function getHasRelationQuery($relation, $entity)
-    {
-        return Relationship::noConstraints(function () use ($relation, $entity) {
-            return $this->entityMap->$relation($entity);
-        });
-    }
-
-    /**
-     * Get the table for the current query object.
-     *
-     * @return string
-     */
-    public function getTable()
-    {
-        return $this->entityMap->getTable();
-    }
-
-    /**
-     * Set the relationships that should be eager loaded.
-     *
-     * @param mixed $relations
-     *
-     * @return $this
-     */
-    public function with($relations)
-    {
-        if (is_string($relations)) {
-            $relations = func_get_args();
-        }
-
-        $this->eagerLoad = array_merge($this->eagerLoad, $relations);
-
-        return $this;
-    }
-
-    /**
-     * Get the relationships being eagerly loaded.
-     *
-     * @return array
-     */
-    public function getEagerLoads()
-    {
-        return $this->eagerLoad;
-    }
-
-    /**
-     * Add the Entity primary key if not in requested columns.
-     *
-     * @param array $columns
-     *
-     * @return array
-     */
-    protected function enforceIdColumn($columns)
-    {
-        if (!in_array($this->entityMap->getKeyName(), $columns)) {
-            $columns[] = $this->entityMap->getKeyName();
-        }
-
-        return $columns;
-    }
-
-    /**
-     * Get the hydrated models without eager loading.
-     *
-     * @param array $columns
-     *
-     * @return \Illuminate\Support\Collection
-     */
-    public function getEntities($columns = ['*'])
-    {
-        // As we need the primary key to feed the
-        // entity cache, we need it loaded on each
-        // request
-        $columns = $this->enforceIdColumn($columns);
-
-        // Run the query
-        $results = $this->query->get($columns);
-
-        // Pass result set to the mapper and return the EntityCollection
-        return $this->mapper->map($results, $this->getEagerLoads());
-    }
-
-    /**
-     * Extend the builder with a given callback.
-     *
-     * @param string   $name
-     * @param \Closure $callback
-     *
-     * @return void
-     */
-    public function macro($name, Closure $callback)
-    {
-        $this->macros[$name] = $callback;
-    }
-
-    /**
-     * Get the given macro by name.
-     *
-     * @param string $name
-     *
-     * @return \Closure
-     */
-    public function getMacro($name)
-    {
-        return array_get($this->macros, $name);
-    }
-
-    /**
-     * Get a new query builder for the model's table.
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function newQuery()
-    {
-        $builder = new self($this->mapper, $this->adapter);
-
-        return $this->applyGlobalScopes($builder);
-    }
-
-    /**
-     * Get a new query builder without any scope applied.
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function newQueryWithoutScopes()
-    {
-        return new self($this->mapper, $this->adapter);
-    }
-
-    /**
-     * Get the Mapper instance for this Query Builder.
-     *
-     * @return \Analogue\ORM\System\Mapper
-     */
-    public function getMapper()
-    {
-        return $this->mapper;
-    }
-
-    /**
-     * Get the underlying query adapter.
-     *
-     * (REFACTOR: this method should move out, we need to provide the client classes
-     * with the adapter instead.)
-     *
-     * @return \Illuminate\Database\Query\Builder
-     */
-    public function getQuery()
-    {
-        return $this->query;
-    }
-
-    /**
-     * Dynamically handle calls into the query instance.
-     *
-     * @param string $method
-     * @param array  $parameters
-     *
-     * @throws Exception
-     *
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        if (isset($this->macros[$method])) {
-            array_unshift($parameters, $this);
-
-            return call_user_func_array($this->macros[$method], $parameters);
-        }
-
-        if (in_array($method, $this->blacklist)) {
-            throw new Exception("Method $method doesn't exist");
-        }
-
-        $result = call_user_func_array([$this->query, $method], $parameters);
-
-        return in_array($method, $this->passthru) ? $result : $this;
-    }
+	/**
+	 * Mapper Instance.
+	 *
+	 * @var \Analogue\ORM\System\Mapper
+	 */
+	protected $mapper;
+
+	/**
+	 * DB Adatper.
+	 *
+	 * @var \Analogue\ORM\Drivers\DBAdapter
+	 */
+	protected $adapter;
+
+	/**
+	 * Query Builder Instance.
+	 *
+	 * @var \Illuminate\Database\Query\Builder
+	 */
+	protected $query;
+
+	/**
+	 * Entity Map Instance.
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * The relationships that should be eager loaded.
+	 *
+	 * @var array
+	 */
+	protected $eagerLoad = [];
+
+	/**
+	 * All of the registered builder macros.
+	 *
+	 * @var array
+	 */
+	protected $macros = [];
+
+	/**
+	 * The methods that should be returned from query builder.
+	 *
+	 * @var array
+	 */
+	protected $passthru = [
+		'cursor',
+		'toSql',
+		'lists',
+		'pluck',
+		'count',
+		'min',
+		'max',
+		'avg',
+		'sum',
+		'exists',
+		'getBindings',
+	];
+
+	/**
+	 * Query Builder Blacklist.
+	 */
+	protected $blacklist = [
+		'insert',
+		'insertGetId',
+		'lock',
+		'lockForUpdate',
+		'sharedLock',
+		'update',
+		'increment',
+		'decrement',
+		'delete',
+		'truncate',
+		'raw',
+	];
+
+	/**
+	 * Create a new Analogue Query Builder instance.
+	 *
+	 * @param Mapper    $mapper
+	 * @param DBAdapter $adapter
+	 */
+	public function __construct(Mapper $mapper, DBAdapter $adapter)
+	{
+		$this->mapper = $mapper;
+
+		$this->adapter = $adapter;
+
+		$this->entityMap = $mapper->getEntityMap();
+
+		// Specify the table to work on
+		$this->query = $adapter->getQuery()->from($this->entityMap->getTable());
+
+		$this->with($this->entityMap->getEagerloadedRelationships());
+	}
+
+	/**
+	 * Run the query and return the result.
+	 *
+	 * @param array $columns
+	 *
+	 * @return \Illuminate\Support\Collection
+	 */
+	public function get($columns = ['*']) : Collection
+	{
+		return $this->getEntities($columns);
+	}
+
+	/**
+	 * Find an entity by its primary key.
+	 *
+	 * @param string|int $id
+	 * @param array      $columns
+	 *
+	 * @return \Analogue\ORM\Mappable
+	 */
+	public function find($id, $columns = ['*'])
+	{
+		if (is_array($id)) {
+			return $this->findMany($id, $columns);
+		}
+
+		$this->query->where($this->entityMap->getKeyName(), '=', $id);
+
+		return $this->first($columns);
+	}
+
+	/**
+	 * Find many entities by their primary keys.
+	 *
+	 * @param array $id
+	 * @param array $columns
+	 *
+	 * @return \Illuminate\Support\Collection
+	 */
+	public function findMany($id, $columns = ['*'])
+	{
+		if (empty($id)) {
+			return new EntityCollection();
+		}
+
+		$this->query->whereIn($this->entityMap->getKeyName(), $id);
+
+		return $this->get($columns);
+	}
+
+	/**
+	 * Find a model by its primary key or throw an exception.
+	 *
+	 * @param mixed $id
+	 * @param array $columns
+	 *
+	 * @throws \Analogue\ORM\Exceptions\EntityNotFoundException
+	 *
+	 * @return mixed|self
+	 */
+	public function findOrFail($id, $columns = ['*'])
+	{
+		if (!is_null($entity = $this->find($id, $columns))) {
+			return $entity;
+		}
+
+		throw (new EntityNotFoundException())->setEntity(get_class($this->entityMap));
+	}
+
+	/**
+	 * Execute the query and get the first result.
+	 *
+	 * @param array $columns
+	 *
+	 * @return \Analogue\ORM\Entity
+	 */
+	public function first($columns = ['*'])
+	{
+		return $this->take(1)->get($columns)->first();
+	}
+
+	/**
+	 * Execute the query and get the first result or throw an exception.
+	 *
+	 * @param array $columns
+	 *
+	 * @throws EntityNotFoundException
+	 *
+	 * @return \Analogue\ORM\Entity
+	 */
+	public function firstOrFail($columns = ['*'])
+	{
+		if (!is_null($entity = $this->first($columns))) {
+			return $entity;
+		}
+
+		throw (new EntityNotFoundException())->setEntity(get_class($this->entityMap));
+	}
+
+	/**
+	 * Chunk the results of the query.
+	 *
+	 * @param int      $count
+	 * @param callable $callback
+	 *
+	 * @return void
+	 */
+	public function chunk($count, callable $callback)
+	{
+		$results = $this->forPage($page = 1, $count)->get();
+
+		while (count($results) > 0) {
+			// On each chunk result set, we will pass them to the callback and then let the
+			// developer take care of everything within the callback, which allows us to
+			// keep the memory low for spinning through large result sets for working.
+			call_user_func($callback, $results);
+
+			$page++;
+
+			$results = $this->forPage($page, $count)->get();
+		}
+	}
+
+	/**
+	 * Get an array with the values of a given column.
+	 *
+	 * @param string $column
+	 * @param string $key
+	 *
+	 * @return array
+	 */
+	public function lists($column, $key = null)
+	{
+		return $this->query->pluck($column, $key);
+	}
+
+	/**
+	 * Get a paginator for the "select" statement.
+	 *
+	 * @param int   $perPage
+	 * @param array $columns
+	 *
+	 * @return LengthAwarePaginator
+	 */
+	public function paginate($perPage = null, $columns = ['*'])
+	{
+		$total = $this->query->getCountForPagination();
+
+		$this->query->forPage(
+			$page = Paginator::resolveCurrentPage(),
+			$perPage = $perPage ?: $this->entityMap->getPerPage()
+		);
+
+		return new LengthAwarePaginator($this->get($columns)->all(), $total, $perPage, $page, [
+			'path' => Paginator::resolveCurrentPath(),
+		]);
+	}
+
+	/**
+	 * Get a paginator for a grouped statement.
+	 *
+	 * @param \Illuminate\Pagination\Factory $paginator
+	 * @param int                            $perPage
+	 * @param array                          $columns
+	 *
+	 * @return \Illuminate\Pagination\Paginator
+	 */
+	protected function groupedPaginate($paginator, $perPage, $columns)
+	{
+		$results = $this->get($columns)->all();
+
+		return $this->query->buildRawPaginator($paginator, $results, $perPage);
+	}
+
+	/**
+	 * Get a paginator for an ungrouped statement.
+	 *
+	 * @param \Illuminate\Pagination\Factory $paginator
+	 * @param int                            $perPage
+	 * @param array                          $columns
+	 *
+	 * @return \Illuminate\Pagination\Paginator
+	 */
+	protected function ungroupedPaginate($paginator, $perPage, $columns)
+	{
+		$total = $this->query->getPaginationCount();
+
+		// Once we have the paginator we need to set the limit and offset values for
+		// the query so we can get the properly paginated items. Once we have an
+		// array of items we can create the paginator instances for the items.
+		$page = $paginator->getCurrentPage($total);
+
+		$this->query->forPage($page, $perPage);
+
+		return $paginator->make($this->get($columns)->all(), $total, $perPage);
+	}
+
+	/**
+	 * Paginate the given query into a simple paginator.
+	 *
+	 * @param int   $perPage
+	 * @param array $columns
+	 *
+	 * @return \Illuminate\Contracts\Pagination\Paginator
+	 */
+	public function simplePaginate($perPage = null, $columns = ['*'])
+	{
+		$page = Paginator::resolveCurrentPage();
+
+		$perPage = $perPage ?: $this->entityMap->getPerPage();
+
+		$this->skip(($page - 1) * $perPage)->take($perPage + 1);
+
+		return new Paginator($this->get($columns)->all(), $perPage, $page, ['path' => Paginator::resolveCurrentPath()]);
+	}
+
+	/**
+	 * Add a basic where clause to the query.
+	 *
+	 * @param string $column
+	 * @param string $operator
+	 * @param mixed  $value
+	 * @param string $boolean
+	 *
+	 * @return $this
+	 */
+	public function where($column, $operator = null, $value = null, $boolean = 'and')
+	{
+		if ($column instanceof Closure) {
+			$query = $this->newQueryWithoutScopes();
+
+			call_user_func($column, $query);
+
+			$this->query->addNestedWhereQuery($query->getQuery(), $boolean);
+		} else {
+			call_user_func_array([$this->query, 'where'], func_get_args());
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Add an "or where" clause to the query.
+	 *
+	 * @param string $column
+	 * @param string $operator
+	 * @param mixed  $value
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function orWhere($column, $operator = null, $value = null)
+	{
+		return $this->where($column, $operator, $value, 'or');
+	}
+
+	/**
+	 * Add a relationship count condition to the query.
+	 *
+	 * @param string   $relation
+	 * @param string   $operator
+	 * @param int      $count
+	 * @param string   $boolean
+	 * @param \Closure $callback
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function has($relation, $operator = '>=', $count = 1, $boolean = 'and', $callback = null)
+	{
+		$entity = $this->mapper->newInstance();
+
+		$relation = $this->getHasRelationQuery($relation, $entity);
+
+		$query = $relation->getRelationCountQuery($relation->getRelatedMapper()->getQuery(), $this);
+
+		if ($callback) {
+			call_user_func($callback, $query);
+		}
+
+		return $this->addHasWhere($query, $relation, $operator, $count, $boolean);
+	}
+
+	/**
+	 * Add a relationship count condition to the query with where clauses.
+	 *
+	 * @param string   $relation
+	 * @param \Closure $callback
+	 * @param string   $operator
+	 * @param int      $count
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function whereHas($relation, Closure $callback, $operator = '>=', $count = 1)
+	{
+		return $this->has($relation, $operator, $count, 'and', $callback);
+	}
+
+	/**
+	 * Add a relationship count condition to the query with an "or".
+	 *
+	 * @param string $relation
+	 * @param string $operator
+	 * @param int    $count
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function orHas($relation, $operator = '>=', $count = 1)
+	{
+		return $this->has($relation, $operator, $count, 'or');
+	}
+
+	/**
+	 * Add a relationship count condition to the query with where clauses and an "or".
+	 *
+	 * @param string   $relation
+	 * @param \Closure $callback
+	 * @param string   $operator
+	 * @param int      $count
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function orWhereHas($relation, Closure $callback, $operator = '>=', $count = 1)
+	{
+		return $this->has($relation, $operator, $count, 'or', $callback);
+	}
+
+	/**
+	 * Add the "has" condition where clause to the query.
+	 *
+	 * @param \Analogue\ORM\System\Query               $hasQuery
+	 * @param \Analogue\ORM\Relationships\Relationship $relation
+	 * @param string                                   $operator
+	 * @param int                                      $count
+	 * @param string                                   $boolean
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	protected function addHasWhere(self $hasQuery, Relationship $relation, $operator, $count, $boolean)
+	{
+		$this->mergeWheresToHas($hasQuery, $relation);
+
+		if (is_numeric($count)) {
+			$count = new Expression($count);
+		}
+
+		return $this->where(new Expression('('.$hasQuery->toSql().')'), $operator, $count, $boolean);
+	}
+
+	/**
+	 * Merge the "wheres" from a relation query to a has query.
+	 *
+	 * @param \Analogue\ORM\System\Query               $hasQuery
+	 * @param \Analogue\ORM\Relationships\Relationship $relation
+	 *
+	 * @return void
+	 */
+	protected function mergeWheresToHas(self $hasQuery, Relationship $relation)
+	{
+		// Here we have the "has" query and the original relation. We need to copy over any
+		// where clauses the developer may have put in the relationship function over to
+		// the has query, and then copy the bindings from the "has" query to the main.
+		$relationQuery = $relation->getBaseQuery();
+
+		$hasQuery->mergeWheres(
+			$relationQuery->wheres, $relationQuery->getBindings()
+		);
+
+		$this->query->mergeBindings($hasQuery->getQuery());
+	}
+
+	/**
+	 * Get the "has relation" base query instance.
+	 *
+	 * @param string $relation
+	 * @param        $entity
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	protected function getHasRelationQuery($relation, $entity)
+	{
+		return Relationship::noConstraints(function () use ($relation, $entity) {
+			return $this->entityMap->$relation($entity);
+		});
+	}
+
+	/**
+	 * Get the table for the current query object.
+	 *
+	 * @return string
+	 */
+	public function getTable()
+	{
+		return $this->entityMap->getTable();
+	}
+
+	/**
+	 * Set the relationships that should be eager loaded.
+	 *
+	 * @param mixed $relations
+	 *
+	 * @return $this
+	 */
+	public function with($relations)
+	{
+		if (is_string($relations)) {
+			$relations = func_get_args();
+		}
+
+		$this->eagerLoad = array_merge($this->eagerLoad, $relations);
+
+		return $this;
+	}
+
+	/**
+	 * Get the relationships being eagerly loaded.
+	 *
+	 * @return array
+	 */
+	public function getEagerLoads()
+	{
+		return $this->eagerLoad;
+	}
+
+	/**
+	 * Add the Entity primary key if not in requested columns.
+	 *
+	 * @param array $columns
+	 *
+	 * @return array
+	 */
+	protected function enforceIdColumn($columns)
+	{
+		if (!in_array($this->entityMap->getKeyName(), $columns)) {
+			$columns[] = $this->entityMap->getKeyName();
+		}
+
+		return $columns;
+	}
+
+	/**
+	 * Get the hydrated models without eager loading.
+	 *
+	 * @param array $columns
+	 *
+	 * @return \Illuminate\Support\Collection
+	 */
+	public function getEntities($columns = ['*'])
+	{
+		// As we need the primary key to feed the
+		// entity cache, we need it loaded on each
+		// request
+		$columns = $this->enforceIdColumn($columns);
+
+		// Run the query
+		$results = $this->query->get($columns);
+
+		// Pass result set to the mapper and return the EntityCollection
+		return $this->mapper->map($results, $this->getEagerLoads());
+	}
+
+	/**
+	 * Extend the builder with a given callback.
+	 *
+	 * @param string   $name
+	 * @param \Closure $callback
+	 *
+	 * @return void
+	 */
+	public function macro($name, Closure $callback)
+	{
+		$this->macros[$name] = $callback;
+	}
+
+	/**
+	 * Get the given macro by name.
+	 *
+	 * @param string $name
+	 *
+	 * @return \Closure
+	 */
+	public function getMacro($name)
+	{
+		return array_get($this->macros, $name);
+	}
+
+	/**
+	 * Get a new query builder for the model's table.
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function newQuery()
+	{
+		$builder = new self($this->mapper, $this->adapter);
+
+		return $this->applyGlobalScopes($builder);
+	}
+
+	/**
+	 * Get a new query builder without any scope applied.
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function newQueryWithoutScopes()
+	{
+		return new self($this->mapper, $this->adapter);
+	}
+
+	/**
+	 * Get the Mapper instance for this Query Builder.
+	 *
+	 * @return \Analogue\ORM\System\Mapper
+	 */
+	public function getMapper()
+	{
+		return $this->mapper;
+	}
+
+	/**
+	 * Get the underlying query adapter.
+	 *
+	 * (REFACTOR: this method should move out, we need to provide the client classes
+	 * with the adapter instead.)
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	public function getQuery()
+	{
+		return $this->query;
+	}
+
+	/**
+	 * Dynamically handle calls into the query instance.
+	 *
+	 * @param string $method
+	 * @param array  $parameters
+	 *
+	 * @throws Exception
+	 *
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		if (isset($this->macros[$method])) {
+			array_unshift($parameters, $this);
+
+			return call_user_func_array($this->macros[$method], $parameters);
+		}
+
+		if (in_array($method, $this->blacklist)) {
+			throw new Exception("Method $method doesn't exist");
+		}
+
+		$result = call_user_func_array([$this->query, $method], $parameters);
+
+		return in_array($method, $this->passthru) ? $result : $this;
+	}
 }

src/System/ScopeInterface.php

Indentation +16 added lines, -16 removed lines

@@ -4,21 +4,21 @@
 
 interface ScopeInterface
 {
-    /**
-     * Apply the scope to a given Query builder.
-     *
-     * @param \Analogue\ORM\System\Query $builder
-     *
-     * @return void
-     */
-    public function apply(Query $builder);
+	/**
+	 * Apply the scope to a given Query builder.
+	 *
+	 * @param \Analogue\ORM\System\Query $builder
+	 *
+	 * @return void
+	 */
+	public function apply(Query $builder);
 
-    /**
-     * Remove the scope from the Query builder.
-     *
-     * @param \Analogue\ORM\System\Query $builder
-     *
-     * @return void
-     */
-    public function remove(Query $builder);
+	/**
+	 * Remove the scope from the Query builder.
+	 *
+	 * @param \Analogue\ORM\System\Query $builder
+	 *
+	 * @return void
+	 */
+	public function remove(Query $builder);
 }

src/System/SingleTableInheritanceScope.php

Indentation +106 added lines, -106 removed lines

@@ -6,110 +6,110 @@
 
 class SingleTableInheritanceScope implements ScopeInterface
 {
-    /**
-     * Discriminator column name.
-     *
-     * @var string
-     */
-    protected $column;
-
-    /**
-     * Discriminator column allowed types.
-     *
-     * @var array
-     */
-    protected $types = [];
-
-    public function __construct(EntityMap $entityMap)
-    {
-        // Putting the heavy logic in here, so we won't have
-        // to go through it each time we reach for a query
-        // builder.
-
-        $this->column = $entityMap->getDiscriminatorColumn();
-
-        // First we need to retrieve the base class & it's normalized
-        // type string
-        $class = $entityMap->getClass();
-        $this->types[] = $this->getTypeStringForEntity($class, $entityMap);
-
-        // Then, we parse all registered entities for any potential
-        // child class.
-        $classes = Manager::getInstance()->getRegisteredEntities();
-
-        foreach ($classes as $otherClass => $entityMap) {
-            if (is_subclass_of($otherClass, $class)) {
-                $this->types[] = $this->getTypeStringForEntity($otherClass, $entityMap);
-            }
-        }
-    }
-
-    /**
-     * Get the normalized value to use for query on discriminator column.
-     *
-     * @param string    $class
-     * @param EntityMap $entityMap
-     *
-     * @return string
-     */
-    protected function getTypeStringForEntity($class, EntityMap $entityMap)
-    {
-        $class = $entityMap->getClass();
-
-        $type = array_keys(
-            $entityMap->getDiscriminatorColumnMap(),
-            $class
-        );
-
-        if (count($type) == 0) {
-            return $class;
-        }
-
-        return $type[0];
-    }
-
-    /**
-     * Apply the scope to a given Analogue query builder.
-     *
-     * @param \Analogue\ORM\System\Query $query
-     *
-     * @return void
-     */
-    public function apply(Query $query)
-    {
-        $query->whereIn($this->column, $this->types);
-    }
-
-    /**
-     * Remove the scope from the given Analogue query builder.
-     *
-     * @param mixed $query
-     *
-     * @return void
-     */
-    public function remove(Query $query)
-    {
-        $query = $query->getQuery();
-
-        foreach ((array) $query->wheres as $key => $where) {
-            if ($this->isSingleTableConstraint($where, $this->column)) {
-                unset($query->wheres[$key]);
-
-                $query->wheres = array_values($query->wheres);
-            }
-        }
-    }
-
-    /**
-     * Determine if the given where clause is a single table inheritance constraint.
-     *
-     * @param array  $where
-     * @param string $column
-     *
-     * @return bool
-     */
-    protected function isSingleTableConstraint(array $where, $column)
-    {
-        return $where['column'] == $column;
-    }
+	/**
+	 * Discriminator column name.
+	 *
+	 * @var string
+	 */
+	protected $column;
+
+	/**
+	 * Discriminator column allowed types.
+	 *
+	 * @var array
+	 */
+	protected $types = [];
+
+	public function __construct(EntityMap $entityMap)
+	{
+		// Putting the heavy logic in here, so we won't have
+		// to go through it each time we reach for a query
+		// builder.
+
+		$this->column = $entityMap->getDiscriminatorColumn();
+
+		// First we need to retrieve the base class & it's normalized
+		// type string
+		$class = $entityMap->getClass();
+		$this->types[] = $this->getTypeStringForEntity($class, $entityMap);
+
+		// Then, we parse all registered entities for any potential
+		// child class.
+		$classes = Manager::getInstance()->getRegisteredEntities();
+
+		foreach ($classes as $otherClass => $entityMap) {
+			if (is_subclass_of($otherClass, $class)) {
+				$this->types[] = $this->getTypeStringForEntity($otherClass, $entityMap);
+			}
+		}
+	}
+
+	/**
+	 * Get the normalized value to use for query on discriminator column.
+	 *
+	 * @param string    $class
+	 * @param EntityMap $entityMap
+	 *
+	 * @return string
+	 */
+	protected function getTypeStringForEntity($class, EntityMap $entityMap)
+	{
+		$class = $entityMap->getClass();
+
+		$type = array_keys(
+			$entityMap->getDiscriminatorColumnMap(),
+			$class
+		);
+
+		if (count($type) == 0) {
+			return $class;
+		}
+
+		return $type[0];
+	}
+
+	/**
+	 * Apply the scope to a given Analogue query builder.
+	 *
+	 * @param \Analogue\ORM\System\Query $query
+	 *
+	 * @return void
+	 */
+	public function apply(Query $query)
+	{
+		$query->whereIn($this->column, $this->types);
+	}
+
+	/**
+	 * Remove the scope from the given Analogue query builder.
+	 *
+	 * @param mixed $query
+	 *
+	 * @return void
+	 */
+	public function remove(Query $query)
+	{
+		$query = $query->getQuery();
+
+		foreach ((array) $query->wheres as $key => $where) {
+			if ($this->isSingleTableConstraint($where, $this->column)) {
+				unset($query->wheres[$key]);
+
+				$query->wheres = array_values($query->wheres);
+			}
+		}
+	}
+
+	/**
+	 * Determine if the given where clause is a single table inheritance constraint.
+	 *
+	 * @param array  $where
+	 * @param string $column
+	 *
+	 * @return bool
+	 */
+	protected function isSingleTableConstraint(array $where, $column)
+	{
+		return $where['column'] == $column;
+	}
 }

Doc Comments +1 added lines, -1 removed lines

@@ -33,7 +33,7 @@
     /**
      * Remove the scope from the given Analogue query builder.
      *
-     * @param mixed $query
+     * @param Query $query
      *
      * @return void
      */

src/MappableTrait.php

Indentation +57 added lines, -57 removed lines

@@ -8,65 +8,65 @@
  */
 trait MappableTrait
 {
-    /**
-     * The Entity's Attributes.
-     *
-     * @var array
-     */
-    //protected $attributes = [];
+	/**
+	 * The Entity's Attributes.
+	 *
+	 * @var array
+	 */
+	//protected $attributes = [];
 
-    /**
-     * Method used by the mapper to set the object
-     * attribute raw values (hydration).
-     *
-     * @param array $attributes
-     *
-     * @return void
-     */
-    public function setEntityAttributes(array $attributes)
-    {
-        $this->attributes = $attributes;
-    }
+	/**
+	 * Method used by the mapper to set the object
+	 * attribute raw values (hydration).
+	 *
+	 * @param array $attributes
+	 *
+	 * @return void
+	 */
+	public function setEntityAttributes(array $attributes)
+	{
+		$this->attributes = $attributes;
+	}
 
-    /**
-     * Method used by the mapper to get the
-     * raw object's values.
-     *
-     * @return array
-     */
-    public function getEntityAttributes()
-    {
-        return $this->attributes;
-    }
+	/**
+	 * Method used by the mapper to get the
+	 * raw object's values.
+	 *
+	 * @return array
+	 */
+	public function getEntityAttributes()
+	{
+		return $this->attributes;
+	}
 
-    /**
-     * Method used by the mapper to set raw
-     * key-value pair.
-     *
-     * @param string $key
-     * @param string $value
-     *
-     * @return void
-     */
-    public function setEntityAttribute($key, $value)
-    {
-        $this->attributes[$key] = $value;
-    }
+	/**
+	 * Method used by the mapper to set raw
+	 * key-value pair.
+	 *
+	 * @param string $key
+	 * @param string $value
+	 *
+	 * @return void
+	 */
+	public function setEntityAttribute($key, $value)
+	{
+		$this->attributes[$key] = $value;
+	}
 
-    /**
-     * Method used by the mapper to get single
-     * key-value pair.
-     *
-     * @param string $key
-     *
-     * @return mixed|null
-     */
-    public function getEntityAttribute($key)
-    {
-        if (array_key_exists($key, $this->attributes)) {
-            return $this->attributes[$key];
-        } else {
-            return;
-        }
-    }
+	/**
+	 * Method used by the mapper to get single
+	 * key-value pair.
+	 *
+	 * @param string $key
+	 *
+	 * @return mixed|null
+	 */
+	public function getEntityAttribute($key)
+	{
+		if (array_key_exists($key, $this->attributes)) {
+			return $this->attributes[$key];
+		} else {
+			return;
+		}
+	}
 }

src/Relationships/MorphPivot.php

Indentation +52 added lines, -52 removed lines

@@ -6,63 +6,63 @@
 
 class MorphPivot extends Pivot
 {
-    /**
-     * The type of the polymorphic relation.
-     *
-     * Explicitly define this so it's not included in saved attributes.
-     *
-     * @var string
-     */
-    protected $morphType;
+	/**
+	 * The type of the polymorphic relation.
+	 *
+	 * Explicitly define this so it's not included in saved attributes.
+	 *
+	 * @var string
+	 */
+	protected $morphType;
 
-    /**
-     * The value of the polymorphic relation.
-     *
-     * Explicitly define this so it's not included in saved attributes.
-     *
-     * @var string
-     */
-    protected $morphClass;
+	/**
+	 * The value of the polymorphic relation.
+	 *
+	 * Explicitly define this so it's not included in saved attributes.
+	 *
+	 * @var string
+	 */
+	protected $morphClass;
 
-    /**
-     * Set the keys for a save update query.
-     *
-     * @param Query $query
-     *
-     * @return Query
-     */
-    protected function setKeysForSaveQuery(Query $query)
-    {
-        $query->where($this->morphType, $this->morphClass);
+	/**
+	 * Set the keys for a save update query.
+	 *
+	 * @param Query $query
+	 *
+	 * @return Query
+	 */
+	protected function setKeysForSaveQuery(Query $query)
+	{
+		$query->where($this->morphType, $this->morphClass);
 
-        return parent::setKeysForSaveQuery($query);
-    }
+		return parent::setKeysForSaveQuery($query);
+	}
 
-    /**
-     * Set the morph type for the pivot.
-     *
-     * @param string $morphType
-     *
-     * @return self
-     */
-    public function setMorphType($morphType)
-    {
-        $this->morphType = $morphType;
+	/**
+	 * Set the morph type for the pivot.
+	 *
+	 * @param string $morphType
+	 *
+	 * @return self
+	 */
+	public function setMorphType($morphType)
+	{
+		$this->morphType = $morphType;
 
-        return $this;
-    }
+		return $this;
+	}
 
-    /**
-     * Set the morph class for the pivot.
-     *
-     * @param string $morphClass
-     *
-     * @return self
-     */
-    public function setMorphClass($morphClass)
-    {
-        $this->morphClass = $morphClass;
+	/**
+	 * Set the morph class for the pivot.
+	 *
+	 * @param string $morphClass
+	 *
+	 * @return self
+	 */
+	public function setMorphClass($morphClass)
+	{
+		$this->morphClass = $morphClass;
 
-        return $this;
-    }
+		return $this;
+	}
 }

src/Relationships/MorphOne.php

Indentation +25 added lines, -25 removed lines

@@ -4,32 +4,32 @@
 
 class MorphOne extends MorphOneOrMany
 {
-    /**
-     * Get the results of the relationship.
-     *
-     * @param  $relation
-     *
-     * @return mixed
-     */
-    public function getResults($relation)
-    {
-        $result = $this->query->first();
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @param  $relation
+	 *
+	 * @return mixed
+	 */
+	public function getResults($relation)
+	{
+		$result = $this->query->first();
 
-        $this->cacheRelation($result, $relation);
+		$this->cacheRelation($result, $relation);
 
-        return $result;
-    }
+		return $result;
+	}
 
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param array  $results
-     * @param string $relation
-     *
-     * @return array
-     */
-    public function match(array $results, $relation)
-    {
-        return $this->matchOne($results, $relation);
-    }
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param array  $results
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	public function match(array $results, $relation)
+	{
+		return $this->matchOne($results, $relation);
+	}
 }

src/Relationships/BelongsToMany.php

Spacing +3 added lines, -3 removed lines

@@ -224,7 +224,7 @@ 
         // release, as this is not quite relevant in a datamapper context.
         $host = $this;
 
-        return array_map(function ($entity) use ($host) {
+        return array_map(function($entity) use ($host) {
             $entityWrapper = $this->factory->make($entity);
 
             $pivot = $this->newExistingPivot($this->cleanPivotAttributes($entityWrapper));
@@ -440,7 +440,7 @@ 
         // Once we have an array dictionary of child objects we can easily match the
         // children back to their parent using the dictionary and the keys on the
         // the parent models. Then we will return the hydrated models back out.
-        return array_map(function ($result) use ($dictionary, $keyName, $cache, $relation, $host) {
+        return array_map(function($result) use ($dictionary, $keyName, $cache, $relation, $host) {
             if (isset($dictionary[$key = $result[$keyName]])) {
                 $collection = $host->relatedMap->newCollection($dictionary[$key]);
 
@@ -739,7 +739,7 @@ 
     {
         $keyName = $this->relatedMap->getKeyName();
 
-        return array_map(function ($m) use ($keyName) {
+        return array_map(function($m) use ($keyName) {
             return $m->$keyName;
         }, $entities);
     }

Doc Comments +1 added lines

@@ -369,6 +369,7 @@
      * Set the join clause for the relation query.
      *
      * @param  \Analogue\ORM\Query|null
+     * @param Query $query
      *
      * @return $this
      */

Indentation +925 added lines, -925 removed lines

@@ -13,929 +13,929 @@
 
 class BelongsToMany extends Relationship
 {
-    /**
-     * The intermediate table for the relation.
-     *
-     * @var string
-     */
-    protected $table;
-
-    /**
-     * The foreign key of the parent model.
-     *
-     * @var string
-     */
-    protected $foreignKey;
-
-    /**
-     * The associated key of the relation.
-     *
-     * @var string
-     */
-    protected $otherKey;
-
-    /**
-     * The "name" of the relationship.
-     *
-     * @var string
-     */
-    protected $relation;
-
-    /**
-     * The pivot table columns to retrieve.
-     *
-     * @var array
-     */
-    protected $pivotColumns = [];
-
-    /**
-     * This relationship has pivot attributes.
-     *
-     * @var bool
-     */
-    protected static $hasPivot = true;
-
-    /**
-     * Create a new has many relationship instance.
-     *
-     * @param Mapper   $mapper
-     * @param Mappable $parent
-     * @param string   $table
-     * @param string   $foreignKey
-     * @param string   $otherKey
-     * @param string   $relation
-     */
-    public function __construct(Mapper $mapper, $parent, $table, $foreignKey, $otherKey, $relation)
-    {
-        $this->table = $table;
-        $this->otherKey = $otherKey;
-        $this->foreignKey = $foreignKey;
-        $this->relation = $relation;
-
-        parent::__construct($mapper, $parent);
-    }
-
-    /**
-     * @param $related
-     */
-    public function detachMany($related)
-    {
-        $ids = $this->getIdsFromHashes($related);
-
-        $this->detach($ids);
-    }
-
-    /**
-     * @param array $hashes
-     *
-     * @return array
-     */
-    protected function getIdsFromHashes(array $hashes)
-    {
-        $ids = [];
-
-        foreach ($hashes as $hash) {
-            $split = explode('.', $hash);
-            $ids[] = $split[1];
-        }
-
-        return $ids;
-    }
-
-    /**
-     * Get the results of the relationship.
-     *
-     * @param $relation
-     *
-     * @return EntityCollection
-     */
-    public function getResults($relation)
-    {
-        $results = $this->get();
-
-        $this->cacheRelation($results, $relation);
-
-        return $results;
-    }
-
-    /**
-     * Set a where clause for a pivot table column.
-     *
-     * @param string $column
-     * @param string $operator
-     * @param mixed  $value
-     * @param string $boolean
-     *
-     * @return self
-     */
-    public function wherePivot($column, $operator = null, $value = null, $boolean = 'and')
-    {
-        return $this->where($this->table.'.'.$column, $operator, $value, $boolean);
-    }
-
-    /**
-     * Set an or where clause for a pivot table column.
-     *
-     * @param string $column
-     * @param string $operator
-     * @param mixed  $value
-     *
-     * @return self
-     */
-    public function orWherePivot($column, $operator = null, $value = null)
-    {
-        return $this->wherePivot($column, $operator, $value, 'or');
-    }
-
-    /**
-     * Return Pivot attributes when available on a relationship.
-     *
-     * @return array
-     */
-    public function getPivotAttributes()
-    {
-        return $this->pivotColumns;
-    }
-
-    /**
-     * Execute the query and get the first result.
-     *
-     * @param array $columns
-     *
-     * @return mixed
-     */
-    public function first($columns = ['*'])
-    {
-        $results = $this->take(1)->get($columns);
-
-        return count($results) > 0 ? $results->first() : null;
-    }
-
-    /**
-     * Execute the query and get the first result or throw an exception.
-     *
-     * @param array $columns
-     *
-     * @throws EntityNotFoundException
-     *
-     * @return Mappable|self
-     */
-    public function firstOrFail($columns = ['*'])
-    {
-        if (!is_null($entity = $this->first($columns))) {
-            return $entity;
-        }
-
-        throw new EntityNotFoundException();
-    }
-
-    /**
-     * Execute the query as a "select" statement.
-     *
-     * @param array $columns
-     *
-     * @return \Illuminate\Support\Collection
-     */
-    public function get($columns = ['*']) : Collection
-    {
-        // First we'll add the proper select columns onto the query so it is run with
-        // the proper columns. Then, we will get the results and hydrate out pivot
-        // models with the result of those columns as a separate model relation.
-        $columns = $this->query->getQuery()->columns ? [] : $columns;
-
-        $select = $this->getSelectColumns($columns);
-
-        $entities = $this->query->addSelect($select)->get()->all();
-
-        $entities = $this->hydratePivotRelation($entities);
-
-        return $this->relatedMap->newCollection($entities);
-    }
-
-    /**
-     * Hydrate the pivot table relationship on the models.
-     *
-     * @param array $entities
-     *
-     * @return void
-     */
-    protected function hydratePivotRelation(array $entities)
-    {
-        // TODO (note) We should definitely get rid of the pivot in a next
-        // release, as this is not quite relevant in a datamapper context.
-        $host = $this;
-
-        return array_map(function ($entity) use ($host) {
-            $entityWrapper = $this->factory->make($entity);
-
-            $pivot = $this->newExistingPivot($this->cleanPivotAttributes($entityWrapper));
-            $entityWrapper->setEntityAttribute('pivot', $pivot);
-
-            return $entityWrapper->getObject();
-        }, $entities);
-    }
-
-    /**
-     * Get the pivot attributes from a model.
-     *
-     * @param  $entity
-     *
-     * @return array
-     */
-    protected function cleanPivotAttributes(InternallyMappable $entity)
-    {
-        $values = [];
-
-        $attributes = $entity->getEntityAttributes();
-
-        foreach ($attributes as $key => $value) {
-            // To get the pivots attributes we will just take any of the attributes which
-            // begin with "pivot_" and add those to this arrays, as well as unsetting
-            // them from the parent's models since they exist in a different table.
-            if (strpos($key, 'pivot_') === 0) {
-                $values[substr($key, 6)] = $value;
-
-                unset($attributes[$key]);
-            }
-        }
-
-        // Rehydrate Entity with cleaned array.
-        $entity->setEntityAttributes($attributes);
-
-        return $values;
-    }
-
-    /**
-     * Set the base constraints on the relation query.
-     *
-     * @return void
-     */
-    public function addConstraints()
-    {
-        $this->setJoin();
-
-        if (static::$constraints) {
-            $this->setWhere();
-        }
-    }
-
-    /**
-     * Add the constraints for a relationship count query.
-     *
-     * @param Query $query
-     * @param Query $parent
-     *
-     * @return Query
-     */
-    public function getRelationCountQuery(Query $query, Query $parent)
-    {
-        if ($parent->getQuery()->from == $query->getQuery()->from) {
-            return $this->getRelationCountQueryForSelfJoin($query, $parent);
-        }
-
-        $this->setJoin($query);
-
-        return parent::getRelationCountQuery($query, $parent);
-    }
-
-    /**
-     * Add the constraints for a relationship count query on the same table.
-     *
-     * @param Query $query
-     * @param Query $parent
-     *
-     * @return Query
-     */
-    public function getRelationCountQueryForSelfJoin(Query $query, Query $parent)
-    {
-        $query->select(new Expression('count(*)'));
-
-        $tablePrefix = $this->query->getQuery()->getConnection()->getTablePrefix();
-
-        $query->from($this->table.' as '.$tablePrefix.$hash = $this->getRelationCountHash());
-
-        $key = $this->wrap($this->getQualifiedParentKeyName());
-
-        return $query->where($hash.'.'.$this->foreignKey, '=', new Expression($key));
-    }
-
-    /**
-     * Get a relationship join table hash.
-     *
-     * @return string
-     */
-    public function getRelationCountHash()
-    {
-        return 'self_'.md5(microtime(true));
-    }
-
-    /**
-     * Set the select clause for the relation query.
-     *
-     * @param array $columns
-     *
-     * @return \Analogue\ORM\Relationships\BelongsToMany
-     */
-    protected function getSelectColumns(array $columns = ['*'])
-    {
-        if ($columns == ['*']) {
-            $columns = [$this->relatedMap->getTable().'.*'];
-        }
-
-        return array_merge($columns, $this->getAliasedPivotColumns());
-    }
-
-    /**
-     * Get the pivot columns for the relation.
-     *
-     * @return array
-     */
-    protected function getAliasedPivotColumns()
-    {
-        $defaults = [$this->foreignKey, $this->otherKey];
-
-        // We need to alias all of the pivot columns with the "pivot_" prefix so we
-        // can easily extract them out of the models and put them into the pivot
-        // relationships when they are retrieved and hydrated into the models.
-        $columns = [];
-
-        foreach (array_merge($defaults, $this->pivotColumns) as $column) {
-            $columns[] = $this->table.'.'.$column.' as pivot_'.$column;
-        }
-
-        return array_unique($columns);
-    }
-
-    /**
-     * Set the join clause for the relation query.
-     *
-     * @param  \Analogue\ORM\Query|null
-     *
-     * @return $this
-     */
-    protected function setJoin($query = null)
-    {
-        $query = $query ?: $this->query;
-
-        // We need to join to the intermediate table on the related model's primary
-        // key column with the intermediate table's foreign key for the related
-        // model instance. Then we can set the "where" for the parent models.
-        $baseTable = $this->relatedMap->getTable();
-
-        $key = $baseTable.'.'.$this->relatedMap->getKeyName();
-
-        $query->join($this->table, $key, '=', $this->getOtherKey());
-
-        return $this;
-    }
-
-    /**
-     * Set the where clause for the relation query.
-     *
-     * @return $this
-     */
-    protected function setWhere()
-    {
-        $foreign = $this->getForeignKey();
-
-        $parentKey = $this->parentMap->getKeyName();
-
-        $this->query->where($foreign, '=', $this->parent->getEntityAttribute($parentKey));
-
-        return $this;
-    }
-
-    /**
-     * Set the constraints for an eager load of the relation.
-     *
-     * @param array $results
-     *
-     * @return void
-     */
-    public function addEagerConstraints(array $results)
-    {
-        $this->query->whereIn($this->getForeignKey(), $this->getKeysFromResults($results));
-    }
-
-    /**
-     * Match Eagerly loaded relation to result.
-     *
-     * @param array  $results
-     * @param string $relation
-     *
-     * @return array
-     */
-    public function match(array $results, $relation)
-    {
-        $entities = $this->getEager();
-
-        // TODO; optimize this operation
-        $dictionary = $this->buildDictionary($entities);
-
-        $keyName = $this->parentMap->getKeyName();
-
-        $cache = $this->parentMapper->getEntityCache();
-
-        $host = $this;
-
-        // Once we have an array dictionary of child objects we can easily match the
-        // children back to their parent using the dictionary and the keys on the
-        // the parent models. Then we will return the hydrated models back out.
-        return array_map(function ($result) use ($dictionary, $keyName, $cache, $relation, $host) {
-            if (isset($dictionary[$key = $result[$keyName]])) {
-                $collection = $host->relatedMap->newCollection($dictionary[$key]);
-
-                $result[$relation] = $collection;
-
-                // TODO Refactor this
-                $cache->cacheLoadedRelationResult($key, $relation, $collection, $this);
-            } else {
-                $result[$relation] = $host->relatedMap->newCollection();
-            }
-
-            return $result;
-        }, $results);
-    }
-
-    /**
-     * Build model dictionary keyed by the relation's foreign key.
-     *
-     * @param EntityCollection $results
-     *
-     * @return array
-     */
-    protected function buildDictionary(EntityCollection $results)
-    {
-        $foreign = $this->foreignKey;
-
-        // First we will build a dictionary of child models keyed by the foreign key
-        // of the relation so that we will easily and quickly match them to their
-        // parents without having a possibly slow inner loops for every models.
-        $dictionary = [];
-
-        foreach ($results as $entity) {
-            $wrapper = $this->factory->make($entity);
-            $dictionary[$wrapper->getEntityAttribute('pivot')->$foreign][] = $entity;
-        }
-
-        return $dictionary;
-    }
-
-    /**
-     * Get all of the IDs for the related models.
-     *
-     * @return array
-     */
-    public function getRelatedIds()
-    {
-        $fullKey = $this->relatedMap->getQualifiedKeyName();
-
-        return $this->getQuery()->select($fullKey)->lists($this->relatedMap->getKeyName());
-    }
-
-    /**
-     * Update Pivot.
-     *
-     * @param \Analogue\ORM\Entity $entity
-     *
-     * @return void
-     */
-    public function updatePivot($entity)
-    {
-        $keyName = $this->relatedMap->getKeyName();
-
-        $this->updateExistingPivot(
-            $entity->getEntityAttribute($keyName),
-            $entity->getEntityAttribute('pivot')->getEntityAttributes()
-        );
-    }
-
-    /**
-     * Update Multiple pivot.
-     *
-     * @param  $relatedEntities
-     *
-     * @return void
-     */
-    public function updatePivots($relatedEntities)
-    {
-        foreach ($relatedEntities as $entity) {
-            $this->updatePivot($entity);
-        }
-    }
-
-    /**
-     * Create Pivot Records.
-     *
-     * @param \Analogue\ORM\Entity[] $relatedEntities
-     *
-     * @return void
-     */
-    public function createPivots($relatedEntities)
-    {
-        $keys = [];
-        $attributes = [];
-
-        $keyName = $this->relatedMap->getKeyName();
-
-        foreach ($relatedEntities as $entity) {
-            $keys[] = $entity->getEntityAttribute($keyName);
-        }
-
-        $records = $this->createAttachRecords($keys, $attributes);
-
-        $this->query->getQuery()->from($this->table)->insert($records);
-    }
-
-    /**
-     * Update an existing pivot record on the table.
-     *
-     * @param mixed $id
-     * @param array $attributes
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return int
-     */
-    public function updateExistingPivot($id, array $attributes)
-    {
-        if (in_array($this->updatedAt(), $this->pivotColumns)) {
-            $attributes = $this->setTimestampsOnAttach($attributes, true);
-        }
-
-        return $this->newPivotStatementForId($id)->update($attributes);
-    }
-
-    /**
-     * Attach a model to the parent.
-     *
-     * @param mixed $id
-     * @param array $attributes
-     *
-     * @return void
-     */
-    public function attach($id, array $attributes = [])
-    {
-        $query = $this->newPivotStatement();
-
-        $query->insert($this->createAttachRecords((array) $id, $attributes));
-    }
-
-    /**
-     * @param array $entities
-     *
-     * @throws \InvalidArgumentException
-     */
-    public function sync(array $entities)
-    {
-        $this->detachExcept($entities);
-    }
-
-    /**
-     * Detach related entities that are not in $id.
-     *
-     * @param array $entities
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    protected function detachExcept(array $entities = [])
-    {
-        $query = $this->newPivotQuery();
-
-        if (count($entities) > 0) {
-            $keys = $this->getKeys($entities);
-
-            $query->whereNotIn($this->otherKey, $keys);
-        }
-        $parentKey = $this->parentMap->getKeyName();
-
-        $query->where($this->foreignKey, '=', $this->parent->getEntityAttribute($parentKey));
-
-        $query->delete();
-
-        $query = $this->newPivotQuery();
-    }
-
-    /**
-     * Create an array of records to insert into the pivot table.
-     *
-     * @param array $ids
-     * @param array $attributes
-     *
-     * @return array
-     */
-    protected function createAttachRecords($ids, array $attributes)
-    {
-        $records = [];
-
-        $timed = in_array($this->createdAt(), $this->pivotColumns);
-
-        // To create the attachment records, we will simply spin through the IDs given
-        // and create a new record to insert for each ID. Each ID may actually be a
-        // key in the array, with extra attributes to be placed in other columns.
-        foreach ($ids as $key => $value) {
-            $records[] = $this->attacher($key, $value, $attributes, $timed);
-        }
-
-        return $records;
-    }
-
-    /**
-     * Create a full attachment record payload.
-     *
-     * @param int   $key
-     * @param mixed $value
-     * @param array $attributes
-     * @param bool  $timed
-     *
-     * @return array
-     */
-    protected function attacher($key, $value, $attributes, $timed)
-    {
-        list($id, $extra) = $this->getAttachId($key, $value, $attributes);
-
-        // To create the attachment records, we will simply spin through the IDs given
-        // and create a new record to insert for each ID. Each ID may actually be a
-        // key in the array, with extra attributes to be placed in other columns.
-        $record = $this->createAttachRecord($id, $timed);
-
-        return array_merge($record, $extra);
-    }
-
-    /**
-     * Get the attach record ID and extra attributes.
-     *
-     * @param int   $key
-     * @param mixed $value
-     * @param array $attributes
-     *
-     * @return array
-     */
-    protected function getAttachId($key, $value, array $attributes)
-    {
-        if (is_array($value)) {
-            return [$key, array_merge($value, $attributes)];
-        }
-
-        return [$value, $attributes];
-    }
-
-    /**
-     * Create a new pivot attachment record.
-     *
-     * @param int  $id
-     * @param bool $timed
-     *
-     * @return array
-     */
-    protected function createAttachRecord($id, $timed)
-    {
-        $parentKey = $this->parentMap->getKeyName();
-
-        $record = [];
-
-        $record[$this->foreignKey] = $this->parent->getEntityAttribute($parentKey);
-
-        $record[$this->otherKey] = $id;
-
-        // If the record needs to have creation and update timestamps, we will make
-        // them by calling the parent model's "freshTimestamp" method which will
-        // provide us with a fresh timestamp in this model's preferred format.
-        if ($timed) {
-            $record = $this->setTimestampsOnAttach($record);
-        }
-
-        return $record;
-    }
-
-    /**
-     * Set the creation and update timestamps on an attach record.
-     *
-     * @param array $record
-     * @param bool  $exists
-     *
-     * @return array
-     */
-    protected function setTimestampsOnAttach(array $record, $exists = false)
-    {
-        $fresh = $this->freshTimestamp();
-
-        if (!$exists) {
-            $record[$this->createdAt()] = $fresh;
-        }
-
-        $record[$this->updatedAt()] = $fresh;
-
-        return $record;
-    }
-
-    /**
-     * @param EntityCollection $entities
-     *
-     * @return array
-     */
-    protected function getModelKeysFromCollection(EntityCollection $entities)
-    {
-        $keyName = $this->relatedMap->getKeyName();
-
-        return array_map(function ($m) use ($keyName) {
-            return $m->$keyName;
-        }, $entities);
-    }
-
-    /**
-     * Detach models from the relationship.
-     *
-     * @param int|array $ids
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return int
-     */
-    public function detach($ids = [])
-    {
-        if ($ids instanceof EntityCollection) {
-            $ids = (array) $ids->modelKeys();
-        }
-
-        $query = $this->newPivotQuery();
-
-        // If associated IDs were passed to the method we will only delete those
-        // associations, otherwise all of the association ties will be broken.
-        // We'll return the numbers of affected rows when we do the deletes.
-        $ids = (array) $ids;
-
-        if (count($ids) > 0) {
-            $query->whereIn($this->otherKey, (array) $ids);
-        }
-
-        // Once we have all of the conditions set on the statement, we are ready
-        // to run the delete on the pivot table. Then, if the touch parameter
-        // is true, we will go ahead and touch all related models to sync.
-        return $query->delete();
-    }
-
-    /**
-     * Create a new query builder for the pivot table.
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return \Illuminate\Database\Query\Builder
-     */
-    protected function newPivotQuery()
-    {
-        $query = $this->newPivotStatement();
-
-        $parentKey = $this->parentMap->getKeyName();
-
-        return $query->where($this->foreignKey, $this->parent->getEntityAttribute($parentKey));
-    }
-
-    /**
-     * Get a new plain query builder for the pivot table.
-     *
-     * @return \Illuminate\Database\Query\Builder
-     */
-    public function newPivotStatement()
-    {
-        return $this->query->getQuery()->newQuery()->from($this->table);
-    }
-
-    /**
-     * Get a new pivot statement for a given "other" ID.
-     *
-     * @param mixed $id
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return \Illuminate\Database\Query\Builder
-     */
-    public function newPivotStatementForId($id)
-    {
-        $pivot = $this->newPivotStatement();
-
-        $parentKeyName = $this->parentMap->getKeyName();
-
-        $key = $this->parent->getEntityAttribute($parentKeyName);
-
-        return $pivot->where($this->foreignKey, $key)->where($this->otherKey, $id);
-    }
-
-    /**
-     * Create a new pivot model instance.
-     *
-     * @param array $attributes
-     * @param bool  $exists
-     *
-     * @return \Analogue\ORM\Relationships\Pivot
-     */
-    public function newPivot(array $attributes = [], $exists = false)
-    {
-        $pivot = new Pivot($this->parent, $this->parentMap, $attributes, $this->table, $exists);
-
-        return $pivot->setPivotKeys($this->foreignKey, $this->otherKey);
-    }
-
-    /**
-     * Create a new existing pivot model instance.
-     *
-     * @param array $attributes
-     *
-     * @return \Analogue\ORM\Relationships\Pivot
-     */
-    public function newExistingPivot(array $attributes = [])
-    {
-        return $this->newPivot($attributes, true);
-    }
-
-    /**
-     * Set the columns on the pivot table to retrieve.
-     *
-     * @param array $columns
-     *
-     * @return $this
-     */
-    public function withPivot($columns)
-    {
-        $columns = is_array($columns) ? $columns : func_get_args();
-
-        $this->pivotColumns = array_merge($this->pivotColumns, $columns);
-
-        return $this;
-    }
-
-    /**
-     * Specify that the pivot table has creation and update timestamps.
-     *
-     * @param mixed $createdAt
-     * @param mixed $updatedAt
-     *
-     * @return \Analogue\ORM\Relationships\BelongsToMany
-     */
-    public function withTimestamps($createdAt = null, $updatedAt = null)
-    {
-        return $this->withPivot($createdAt ?: $this->createdAt(), $updatedAt ?: $this->updatedAt());
-    }
-
-    /**
-     * Get the key for comparing against the parent key in "has" query.
-     *
-     * @return string
-     */
-    public function getHasCompareKey()
-    {
-        return $this->getForeignKey();
-    }
-
-    /**
-     * Get the fully qualified foreign key for the relation.
-     *
-     * @return string
-     */
-    public function getForeignKey()
-    {
-        return $this->table.'.'.$this->foreignKey;
-    }
-
-    /**
-     * Get the fully qualified "other key" for the relation.
-     *
-     * @return string
-     */
-    public function getOtherKey()
-    {
-        return $this->table.'.'.$this->otherKey;
-    }
-
-    /**
-     * Get the fully qualified parent key name.
-     *
-     * @return string
-     */
-    protected function getQualifiedParentKeyName()
-    {
-        return $this->parentMap->getQualifiedKeyName();
-    }
-
-    /**
-     * Get the intermediate table for the relationship.
-     *
-     * @return string
-     */
-    public function getTable()
-    {
-        return $this->table;
-    }
-
-    /**
-     * Get the relationship name for the relationship.
-     *
-     * @return string
-     */
-    public function getRelationName()
-    {
-        return $this->relation;
-    }
+	/**
+	 * The intermediate table for the relation.
+	 *
+	 * @var string
+	 */
+	protected $table;
+
+	/**
+	 * The foreign key of the parent model.
+	 *
+	 * @var string
+	 */
+	protected $foreignKey;
+
+	/**
+	 * The associated key of the relation.
+	 *
+	 * @var string
+	 */
+	protected $otherKey;
+
+	/**
+	 * The "name" of the relationship.
+	 *
+	 * @var string
+	 */
+	protected $relation;
+
+	/**
+	 * The pivot table columns to retrieve.
+	 *
+	 * @var array
+	 */
+	protected $pivotColumns = [];
+
+	/**
+	 * This relationship has pivot attributes.
+	 *
+	 * @var bool
+	 */
+	protected static $hasPivot = true;
+
+	/**
+	 * Create a new has many relationship instance.
+	 *
+	 * @param Mapper   $mapper
+	 * @param Mappable $parent
+	 * @param string   $table
+	 * @param string   $foreignKey
+	 * @param string   $otherKey
+	 * @param string   $relation
+	 */
+	public function __construct(Mapper $mapper, $parent, $table, $foreignKey, $otherKey, $relation)
+	{
+		$this->table = $table;
+		$this->otherKey = $otherKey;
+		$this->foreignKey = $foreignKey;
+		$this->relation = $relation;
+
+		parent::__construct($mapper, $parent);
+	}
+
+	/**
+	 * @param $related
+	 */
+	public function detachMany($related)
+	{
+		$ids = $this->getIdsFromHashes($related);
+
+		$this->detach($ids);
+	}
+
+	/**
+	 * @param array $hashes
+	 *
+	 * @return array
+	 */
+	protected function getIdsFromHashes(array $hashes)
+	{
+		$ids = [];
+
+		foreach ($hashes as $hash) {
+			$split = explode('.', $hash);
+			$ids[] = $split[1];
+		}
+
+		return $ids;
+	}
+
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @param $relation
+	 *
+	 * @return EntityCollection
+	 */
+	public function getResults($relation)
+	{
+		$results = $this->get();
+
+		$this->cacheRelation($results, $relation);
+
+		return $results;
+	}
+
+	/**
+	 * Set a where clause for a pivot table column.
+	 *
+	 * @param string $column
+	 * @param string $operator
+	 * @param mixed  $value
+	 * @param string $boolean
+	 *
+	 * @return self
+	 */
+	public function wherePivot($column, $operator = null, $value = null, $boolean = 'and')
+	{
+		return $this->where($this->table.'.'.$column, $operator, $value, $boolean);
+	}
+
+	/**
+	 * Set an or where clause for a pivot table column.
+	 *
+	 * @param string $column
+	 * @param string $operator
+	 * @param mixed  $value
+	 *
+	 * @return self
+	 */
+	public function orWherePivot($column, $operator = null, $value = null)
+	{
+		return $this->wherePivot($column, $operator, $value, 'or');
+	}
+
+	/**
+	 * Return Pivot attributes when available on a relationship.
+	 *
+	 * @return array
+	 */
+	public function getPivotAttributes()
+	{
+		return $this->pivotColumns;
+	}
+
+	/**
+	 * Execute the query and get the first result.
+	 *
+	 * @param array $columns
+	 *
+	 * @return mixed
+	 */
+	public function first($columns = ['*'])
+	{
+		$results = $this->take(1)->get($columns);
+
+		return count($results) > 0 ? $results->first() : null;
+	}
+
+	/**
+	 * Execute the query and get the first result or throw an exception.
+	 *
+	 * @param array $columns
+	 *
+	 * @throws EntityNotFoundException
+	 *
+	 * @return Mappable|self
+	 */
+	public function firstOrFail($columns = ['*'])
+	{
+		if (!is_null($entity = $this->first($columns))) {
+			return $entity;
+		}
+
+		throw new EntityNotFoundException();
+	}
+
+	/**
+	 * Execute the query as a "select" statement.
+	 *
+	 * @param array $columns
+	 *
+	 * @return \Illuminate\Support\Collection
+	 */
+	public function get($columns = ['*']) : Collection
+	{
+		// First we'll add the proper select columns onto the query so it is run with
+		// the proper columns. Then, we will get the results and hydrate out pivot
+		// models with the result of those columns as a separate model relation.
+		$columns = $this->query->getQuery()->columns ? [] : $columns;
+
+		$select = $this->getSelectColumns($columns);
+
+		$entities = $this->query->addSelect($select)->get()->all();
+
+		$entities = $this->hydratePivotRelation($entities);
+
+		return $this->relatedMap->newCollection($entities);
+	}
+
+	/**
+	 * Hydrate the pivot table relationship on the models.
+	 *
+	 * @param array $entities
+	 *
+	 * @return void
+	 */
+	protected function hydratePivotRelation(array $entities)
+	{
+		// TODO (note) We should definitely get rid of the pivot in a next
+		// release, as this is not quite relevant in a datamapper context.
+		$host = $this;
+
+		return array_map(function ($entity) use ($host) {
+			$entityWrapper = $this->factory->make($entity);
+
+			$pivot = $this->newExistingPivot($this->cleanPivotAttributes($entityWrapper));
+			$entityWrapper->setEntityAttribute('pivot', $pivot);
+
+			return $entityWrapper->getObject();
+		}, $entities);
+	}
+
+	/**
+	 * Get the pivot attributes from a model.
+	 *
+	 * @param  $entity
+	 *
+	 * @return array
+	 */
+	protected function cleanPivotAttributes(InternallyMappable $entity)
+	{
+		$values = [];
+
+		$attributes = $entity->getEntityAttributes();
+
+		foreach ($attributes as $key => $value) {
+			// To get the pivots attributes we will just take any of the attributes which
+			// begin with "pivot_" and add those to this arrays, as well as unsetting
+			// them from the parent's models since they exist in a different table.
+			if (strpos($key, 'pivot_') === 0) {
+				$values[substr($key, 6)] = $value;
+
+				unset($attributes[$key]);
+			}
+		}
+
+		// Rehydrate Entity with cleaned array.
+		$entity->setEntityAttributes($attributes);
+
+		return $values;
+	}
+
+	/**
+	 * Set the base constraints on the relation query.
+	 *
+	 * @return void
+	 */
+	public function addConstraints()
+	{
+		$this->setJoin();
+
+		if (static::$constraints) {
+			$this->setWhere();
+		}
+	}
+
+	/**
+	 * Add the constraints for a relationship count query.
+	 *
+	 * @param Query $query
+	 * @param Query $parent
+	 *
+	 * @return Query
+	 */
+	public function getRelationCountQuery(Query $query, Query $parent)
+	{
+		if ($parent->getQuery()->from == $query->getQuery()->from) {
+			return $this->getRelationCountQueryForSelfJoin($query, $parent);
+		}
+
+		$this->setJoin($query);
+
+		return parent::getRelationCountQuery($query, $parent);
+	}
+
+	/**
+	 * Add the constraints for a relationship count query on the same table.
+	 *
+	 * @param Query $query
+	 * @param Query $parent
+	 *
+	 * @return Query
+	 */
+	public function getRelationCountQueryForSelfJoin(Query $query, Query $parent)
+	{
+		$query->select(new Expression('count(*)'));
+
+		$tablePrefix = $this->query->getQuery()->getConnection()->getTablePrefix();
+
+		$query->from($this->table.' as '.$tablePrefix.$hash = $this->getRelationCountHash());
+
+		$key = $this->wrap($this->getQualifiedParentKeyName());
+
+		return $query->where($hash.'.'.$this->foreignKey, '=', new Expression($key));
+	}
+
+	/**
+	 * Get a relationship join table hash.
+	 *
+	 * @return string
+	 */
+	public function getRelationCountHash()
+	{
+		return 'self_'.md5(microtime(true));
+	}
+
+	/**
+	 * Set the select clause for the relation query.
+	 *
+	 * @param array $columns
+	 *
+	 * @return \Analogue\ORM\Relationships\BelongsToMany
+	 */
+	protected function getSelectColumns(array $columns = ['*'])
+	{
+		if ($columns == ['*']) {
+			$columns = [$this->relatedMap->getTable().'.*'];
+		}
+
+		return array_merge($columns, $this->getAliasedPivotColumns());
+	}
+
+	/**
+	 * Get the pivot columns for the relation.
+	 *
+	 * @return array
+	 */
+	protected function getAliasedPivotColumns()
+	{
+		$defaults = [$this->foreignKey, $this->otherKey];
+
+		// We need to alias all of the pivot columns with the "pivot_" prefix so we
+		// can easily extract them out of the models and put them into the pivot
+		// relationships when they are retrieved and hydrated into the models.
+		$columns = [];
+
+		foreach (array_merge($defaults, $this->pivotColumns) as $column) {
+			$columns[] = $this->table.'.'.$column.' as pivot_'.$column;
+		}
+
+		return array_unique($columns);
+	}
+
+	/**
+	 * Set the join clause for the relation query.
+	 *
+	 * @param  \Analogue\ORM\Query|null
+	 *
+	 * @return $this
+	 */
+	protected function setJoin($query = null)
+	{
+		$query = $query ?: $this->query;
+
+		// We need to join to the intermediate table on the related model's primary
+		// key column with the intermediate table's foreign key for the related
+		// model instance. Then we can set the "where" for the parent models.
+		$baseTable = $this->relatedMap->getTable();
+
+		$key = $baseTable.'.'.$this->relatedMap->getKeyName();
+
+		$query->join($this->table, $key, '=', $this->getOtherKey());
+
+		return $this;
+	}
+
+	/**
+	 * Set the where clause for the relation query.
+	 *
+	 * @return $this
+	 */
+	protected function setWhere()
+	{
+		$foreign = $this->getForeignKey();
+
+		$parentKey = $this->parentMap->getKeyName();
+
+		$this->query->where($foreign, '=', $this->parent->getEntityAttribute($parentKey));
+
+		return $this;
+	}
+
+	/**
+	 * Set the constraints for an eager load of the relation.
+	 *
+	 * @param array $results
+	 *
+	 * @return void
+	 */
+	public function addEagerConstraints(array $results)
+	{
+		$this->query->whereIn($this->getForeignKey(), $this->getKeysFromResults($results));
+	}
+
+	/**
+	 * Match Eagerly loaded relation to result.
+	 *
+	 * @param array  $results
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	public function match(array $results, $relation)
+	{
+		$entities = $this->getEager();
+
+		// TODO; optimize this operation
+		$dictionary = $this->buildDictionary($entities);
+
+		$keyName = $this->parentMap->getKeyName();
+
+		$cache = $this->parentMapper->getEntityCache();
+
+		$host = $this;
+
+		// Once we have an array dictionary of child objects we can easily match the
+		// children back to their parent using the dictionary and the keys on the
+		// the parent models. Then we will return the hydrated models back out.
+		return array_map(function ($result) use ($dictionary, $keyName, $cache, $relation, $host) {
+			if (isset($dictionary[$key = $result[$keyName]])) {
+				$collection = $host->relatedMap->newCollection($dictionary[$key]);
+
+				$result[$relation] = $collection;
+
+				// TODO Refactor this
+				$cache->cacheLoadedRelationResult($key, $relation, $collection, $this);
+			} else {
+				$result[$relation] = $host->relatedMap->newCollection();
+			}
+
+			return $result;
+		}, $results);
+	}
+
+	/**
+	 * Build model dictionary keyed by the relation's foreign key.
+	 *
+	 * @param EntityCollection $results
+	 *
+	 * @return array
+	 */
+	protected function buildDictionary(EntityCollection $results)
+	{
+		$foreign = $this->foreignKey;
+
+		// First we will build a dictionary of child models keyed by the foreign key
+		// of the relation so that we will easily and quickly match them to their
+		// parents without having a possibly slow inner loops for every models.
+		$dictionary = [];
+
+		foreach ($results as $entity) {
+			$wrapper = $this->factory->make($entity);
+			$dictionary[$wrapper->getEntityAttribute('pivot')->$foreign][] = $entity;
+		}
+
+		return $dictionary;
+	}
+
+	/**
+	 * Get all of the IDs for the related models.
+	 *
+	 * @return array
+	 */
+	public function getRelatedIds()
+	{
+		$fullKey = $this->relatedMap->getQualifiedKeyName();
+
+		return $this->getQuery()->select($fullKey)->lists($this->relatedMap->getKeyName());
+	}
+
+	/**
+	 * Update Pivot.
+	 *
+	 * @param \Analogue\ORM\Entity $entity
+	 *
+	 * @return void
+	 */
+	public function updatePivot($entity)
+	{
+		$keyName = $this->relatedMap->getKeyName();
+
+		$this->updateExistingPivot(
+			$entity->getEntityAttribute($keyName),
+			$entity->getEntityAttribute('pivot')->getEntityAttributes()
+		);
+	}
+
+	/**
+	 * Update Multiple pivot.
+	 *
+	 * @param  $relatedEntities
+	 *
+	 * @return void
+	 */
+	public function updatePivots($relatedEntities)
+	{
+		foreach ($relatedEntities as $entity) {
+			$this->updatePivot($entity);
+		}
+	}
+
+	/**
+	 * Create Pivot Records.
+	 *
+	 * @param \Analogue\ORM\Entity[] $relatedEntities
+	 *
+	 * @return void
+	 */
+	public function createPivots($relatedEntities)
+	{
+		$keys = [];
+		$attributes = [];
+
+		$keyName = $this->relatedMap->getKeyName();
+
+		foreach ($relatedEntities as $entity) {
+			$keys[] = $entity->getEntityAttribute($keyName);
+		}
+
+		$records = $this->createAttachRecords($keys, $attributes);
+
+		$this->query->getQuery()->from($this->table)->insert($records);
+	}
+
+	/**
+	 * Update an existing pivot record on the table.
+	 *
+	 * @param mixed $id
+	 * @param array $attributes
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return int
+	 */
+	public function updateExistingPivot($id, array $attributes)
+	{
+		if (in_array($this->updatedAt(), $this->pivotColumns)) {
+			$attributes = $this->setTimestampsOnAttach($attributes, true);
+		}
+
+		return $this->newPivotStatementForId($id)->update($attributes);
+	}
+
+	/**
+	 * Attach a model to the parent.
+	 *
+	 * @param mixed $id
+	 * @param array $attributes
+	 *
+	 * @return void
+	 */
+	public function attach($id, array $attributes = [])
+	{
+		$query = $this->newPivotStatement();
+
+		$query->insert($this->createAttachRecords((array) $id, $attributes));
+	}
+
+	/**
+	 * @param array $entities
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public function sync(array $entities)
+	{
+		$this->detachExcept($entities);
+	}
+
+	/**
+	 * Detach related entities that are not in $id.
+	 *
+	 * @param array $entities
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return void
+	 */
+	protected function detachExcept(array $entities = [])
+	{
+		$query = $this->newPivotQuery();
+
+		if (count($entities) > 0) {
+			$keys = $this->getKeys($entities);
+
+			$query->whereNotIn($this->otherKey, $keys);
+		}
+		$parentKey = $this->parentMap->getKeyName();
+
+		$query->where($this->foreignKey, '=', $this->parent->getEntityAttribute($parentKey));
+
+		$query->delete();
+
+		$query = $this->newPivotQuery();
+	}
+
+	/**
+	 * Create an array of records to insert into the pivot table.
+	 *
+	 * @param array $ids
+	 * @param array $attributes
+	 *
+	 * @return array
+	 */
+	protected function createAttachRecords($ids, array $attributes)
+	{
+		$records = [];
+
+		$timed = in_array($this->createdAt(), $this->pivotColumns);
+
+		// To create the attachment records, we will simply spin through the IDs given
+		// and create a new record to insert for each ID. Each ID may actually be a
+		// key in the array, with extra attributes to be placed in other columns.
+		foreach ($ids as $key => $value) {
+			$records[] = $this->attacher($key, $value, $attributes, $timed);
+		}
+
+		return $records;
+	}
+
+	/**
+	 * Create a full attachment record payload.
+	 *
+	 * @param int   $key
+	 * @param mixed $value
+	 * @param array $attributes
+	 * @param bool  $timed
+	 *
+	 * @return array
+	 */
+	protected function attacher($key, $value, $attributes, $timed)
+	{
+		list($id, $extra) = $this->getAttachId($key, $value, $attributes);
+
+		// To create the attachment records, we will simply spin through the IDs given
+		// and create a new record to insert for each ID. Each ID may actually be a
+		// key in the array, with extra attributes to be placed in other columns.
+		$record = $this->createAttachRecord($id, $timed);
+
+		return array_merge($record, $extra);
+	}
+
+	/**
+	 * Get the attach record ID and extra attributes.
+	 *
+	 * @param int   $key
+	 * @param mixed $value
+	 * @param array $attributes
+	 *
+	 * @return array
+	 */
+	protected function getAttachId($key, $value, array $attributes)
+	{
+		if (is_array($value)) {
+			return [$key, array_merge($value, $attributes)];
+		}
+
+		return [$value, $attributes];
+	}
+
+	/**
+	 * Create a new pivot attachment record.
+	 *
+	 * @param int  $id
+	 * @param bool $timed
+	 *
+	 * @return array
+	 */
+	protected function createAttachRecord($id, $timed)
+	{
+		$parentKey = $this->parentMap->getKeyName();
+
+		$record = [];
+
+		$record[$this->foreignKey] = $this->parent->getEntityAttribute($parentKey);
+
+		$record[$this->otherKey] = $id;
+
+		// If the record needs to have creation and update timestamps, we will make
+		// them by calling the parent model's "freshTimestamp" method which will
+		// provide us with a fresh timestamp in this model's preferred format.
+		if ($timed) {
+			$record = $this->setTimestampsOnAttach($record);
+		}
+
+		return $record;
+	}
+
+	/**
+	 * Set the creation and update timestamps on an attach record.
+	 *
+	 * @param array $record
+	 * @param bool  $exists
+	 *
+	 * @return array
+	 */
+	protected function setTimestampsOnAttach(array $record, $exists = false)
+	{
+		$fresh = $this->freshTimestamp();
+
+		if (!$exists) {
+			$record[$this->createdAt()] = $fresh;
+		}
+
+		$record[$this->updatedAt()] = $fresh;
+
+		return $record;
+	}
+
+	/**
+	 * @param EntityCollection $entities
+	 *
+	 * @return array
+	 */
+	protected function getModelKeysFromCollection(EntityCollection $entities)
+	{
+		$keyName = $this->relatedMap->getKeyName();
+
+		return array_map(function ($m) use ($keyName) {
+			return $m->$keyName;
+		}, $entities);
+	}
+
+	/**
+	 * Detach models from the relationship.
+	 *
+	 * @param int|array $ids
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return int
+	 */
+	public function detach($ids = [])
+	{
+		if ($ids instanceof EntityCollection) {
+			$ids = (array) $ids->modelKeys();
+		}
+
+		$query = $this->newPivotQuery();
+
+		// If associated IDs were passed to the method we will only delete those
+		// associations, otherwise all of the association ties will be broken.
+		// We'll return the numbers of affected rows when we do the deletes.
+		$ids = (array) $ids;
+
+		if (count($ids) > 0) {
+			$query->whereIn($this->otherKey, (array) $ids);
+		}
+
+		// Once we have all of the conditions set on the statement, we are ready
+		// to run the delete on the pivot table. Then, if the touch parameter
+		// is true, we will go ahead and touch all related models to sync.
+		return $query->delete();
+	}
+
+	/**
+	 * Create a new query builder for the pivot table.
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	protected function newPivotQuery()
+	{
+		$query = $this->newPivotStatement();
+
+		$parentKey = $this->parentMap->getKeyName();
+
+		return $query->where($this->foreignKey, $this->parent->getEntityAttribute($parentKey));
+	}
+
+	/**
+	 * Get a new plain query builder for the pivot table.
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	public function newPivotStatement()
+	{
+		return $this->query->getQuery()->newQuery()->from($this->table);
+	}
+
+	/**
+	 * Get a new pivot statement for a given "other" ID.
+	 *
+	 * @param mixed $id
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	public function newPivotStatementForId($id)
+	{
+		$pivot = $this->newPivotStatement();
+
+		$parentKeyName = $this->parentMap->getKeyName();
+
+		$key = $this->parent->getEntityAttribute($parentKeyName);
+
+		return $pivot->where($this->foreignKey, $key)->where($this->otherKey, $id);
+	}
+
+	/**
+	 * Create a new pivot model instance.
+	 *
+	 * @param array $attributes
+	 * @param bool  $exists
+	 *
+	 * @return \Analogue\ORM\Relationships\Pivot
+	 */
+	public function newPivot(array $attributes = [], $exists = false)
+	{
+		$pivot = new Pivot($this->parent, $this->parentMap, $attributes, $this->table, $exists);
+
+		return $pivot->setPivotKeys($this->foreignKey, $this->otherKey);
+	}
+
+	/**
+	 * Create a new existing pivot model instance.
+	 *
+	 * @param array $attributes
+	 *
+	 * @return \Analogue\ORM\Relationships\Pivot
+	 */
+	public function newExistingPivot(array $attributes = [])
+	{
+		return $this->newPivot($attributes, true);
+	}
+
+	/**
+	 * Set the columns on the pivot table to retrieve.
+	 *
+	 * @param array $columns
+	 *
+	 * @return $this
+	 */
+	public function withPivot($columns)
+	{
+		$columns = is_array($columns) ? $columns : func_get_args();
+
+		$this->pivotColumns = array_merge($this->pivotColumns, $columns);
+
+		return $this;
+	}
+
+	/**
+	 * Specify that the pivot table has creation and update timestamps.
+	 *
+	 * @param mixed $createdAt
+	 * @param mixed $updatedAt
+	 *
+	 * @return \Analogue\ORM\Relationships\BelongsToMany
+	 */
+	public function withTimestamps($createdAt = null, $updatedAt = null)
+	{
+		return $this->withPivot($createdAt ?: $this->createdAt(), $updatedAt ?: $this->updatedAt());
+	}
+
+	/**
+	 * Get the key for comparing against the parent key in "has" query.
+	 *
+	 * @return string
+	 */
+	public function getHasCompareKey()
+	{
+		return $this->getForeignKey();
+	}
+
+	/**
+	 * Get the fully qualified foreign key for the relation.
+	 *
+	 * @return string
+	 */
+	public function getForeignKey()
+	{
+		return $this->table.'.'.$this->foreignKey;
+	}
+
+	/**
+	 * Get the fully qualified "other key" for the relation.
+	 *
+	 * @return string
+	 */
+	public function getOtherKey()
+	{
+		return $this->table.'.'.$this->otherKey;
+	}
+
+	/**
+	 * Get the fully qualified parent key name.
+	 *
+	 * @return string
+	 */
+	protected function getQualifiedParentKeyName()
+	{
+		return $this->parentMap->getQualifiedKeyName();
+	}
+
+	/**
+	 * Get the intermediate table for the relationship.
+	 *
+	 * @return string
+	 */
+	public function getTable()
+	{
+		return $this->table;
+	}
+
+	/**
+	 * Get the relationship name for the relationship.
+	 *
+	 * @return string
+	 */
+	public function getRelationName()
+	{
+		return $this->relation;
+	}
 }

src/Relationships/MorphToMany.php

Indentation +168 added lines, -168 removed lines

@@ -7,172 +7,172 @@
 
 class MorphToMany extends BelongsToMany
 {
-    /**
-     * The type of the polymorphic relation.
-     *
-     * @var string
-     */
-    protected $morphType;
-
-    /**
-     * The class name of the morph type constraint.
-     *
-     * @var string
-     */
-    protected $morphClass;
-
-    /**
-     * Indicates if we are connecting the inverse of the relation.
-     *
-     * This primarily affects the morphClass constraint.
-     *
-     * @var bool
-     */
-    protected $inverse;
-
-    protected static $hasPivot = true;
-
-    /**
-     * Create a new has many relationship instance.
-     *
-     * @param Mapper               $mapper
-     * @param \Analogue\ORM\Entity $parent
-     * @param string               $name
-     * @param string               $table
-     * @param string               $foreignKey
-     * @param string               $otherKey
-     * @param string|null          $relationName
-     * @param bool                 $inverse
-     */
-    public function __construct(Mapper $mapper, $parent, $name, $table, $foreignKey, $otherKey, $relationName = null, $inverse = false)
-    {
-        $this->inverse = $inverse;
-
-        $this->morphType = $name.'_type';
-
-        $this->morphClass = $inverse ? $mapper->getEntityMap()->getClass() : get_class($parent);
-
-        parent::__construct($mapper, $parent, $table, $foreignKey, $otherKey, $relationName);
-    }
-
-    /**
-     * Set the where clause for the relation query.
-     *
-     * @return self
-     */
-    protected function setWhere()
-    {
-        parent::setWhere();
-
-        $this->query->where($this->table.'.'.$this->morphType, $this->morphClass);
-
-        return $this;
-    }
-
-    /**
-     * Add the constraints for a relationship count query.
-     *
-     * @param Query $query
-     * @param Query $parent
-     *
-     * @return Query
-     */
-    public function getRelationCountQuery(Query $query, Query $parent)
-    {
-        $query = parent::getRelationCountQuery($query, $parent);
-
-        return $query->where($this->table.'.'.$this->morphType, $this->morphClass);
-    }
-
-    /**
-     * Set the constraints for an eager load of the relation.
-     *
-     * @param array $results
-     *
-     * @return void
-     */
-    public function addEagerConstraints(array $results)
-    {
-        parent::addEagerConstraints($results);
-
-        $this->query->where($this->table.'.'.$this->morphType, $this->morphClass);
-    }
-
-    /**
-     * Create a new pivot attachment record.
-     *
-     * @param int  $id
-     * @param bool $timed
-     *
-     * @return array
-     */
-    protected function createAttachRecord($id, $timed)
-    {
-        $record = parent::createAttachRecord($id, $timed);
-
-        return array_add($record, $this->morphType, $this->morphClass);
-    }
-
-    /**
-     * Create a new query builder for the pivot table.
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return \Illuminate\Database\Query\Builder
-     */
-    protected function newPivotQuery()
-    {
-        $query = parent::newPivotQuery();
-
-        return $query->where($this->morphType, $this->morphClass);
-    }
-
-    /**
-     * Create a new pivot model instance.
-     *
-     * @param array $attributes
-     * @param bool  $exists
-     *
-     * @return Pivot
-     */
-    public function newPivot(array $attributes = [], $exists = false)
-    {
-        $pivot = new MorphPivot($this->parent, $this->parentMap, $attributes, $this->table, $exists);
-
-        $pivot->setPivotKeys($this->foreignKey, $this->otherKey)
-            ->setMorphType($this->morphType)
-            ->setMorphClass($this->morphClass);
-
-        return $pivot;
-    }
-
-    /**
-     * Return Pivot attributes when available on a relationship.
-     *
-     * @return array
-     */
-    public function getPivotAttributes()
-    {
-        return $this->pivotColumns;
-    }
-
-    /**
-     * Get the foreign key "type" name.
-     *
-     * @return string
-     */
-    public function getMorphType()
-    {
-        return $this->morphType;
-    }
-
-    /**
-     * Get the class name of the parent model.
-     *
-     * @return string
-     */
-    public function getMorphClass()
-    {
-        return $this->morphClass;
-    }
+	/**
+	 * The type of the polymorphic relation.
+	 *
+	 * @var string
+	 */
+	protected $morphType;
+
+	/**
+	 * The class name of the morph type constraint.
+	 *
+	 * @var string
+	 */
+	protected $morphClass;
+
+	/**
+	 * Indicates if we are connecting the inverse of the relation.
+	 *
+	 * This primarily affects the morphClass constraint.
+	 *
+	 * @var bool
+	 */
+	protected $inverse;
+
+	protected static $hasPivot = true;
+
+	/**
+	 * Create a new has many relationship instance.
+	 *
+	 * @param Mapper               $mapper
+	 * @param \Analogue\ORM\Entity $parent
+	 * @param string               $name
+	 * @param string               $table
+	 * @param string               $foreignKey
+	 * @param string               $otherKey
+	 * @param string|null          $relationName
+	 * @param bool                 $inverse
+	 */
+	public function __construct(Mapper $mapper, $parent, $name, $table, $foreignKey, $otherKey, $relationName = null, $inverse = false)
+	{
+		$this->inverse = $inverse;
+
+		$this->morphType = $name.'_type';
+
+		$this->morphClass = $inverse ? $mapper->getEntityMap()->getClass() : get_class($parent);
+
+		parent::__construct($mapper, $parent, $table, $foreignKey, $otherKey, $relationName);
+	}
+
+	/**
+	 * Set the where clause for the relation query.
+	 *
+	 * @return self
+	 */
+	protected function setWhere()
+	{
+		parent::setWhere();
+
+		$this->query->where($this->table.'.'.$this->morphType, $this->morphClass);
+
+		return $this;
+	}
+
+	/**
+	 * Add the constraints for a relationship count query.
+	 *
+	 * @param Query $query
+	 * @param Query $parent
+	 *
+	 * @return Query
+	 */
+	public function getRelationCountQuery(Query $query, Query $parent)
+	{
+		$query = parent::getRelationCountQuery($query, $parent);
+
+		return $query->where($this->table.'.'.$this->morphType, $this->morphClass);
+	}
+
+	/**
+	 * Set the constraints for an eager load of the relation.
+	 *
+	 * @param array $results
+	 *
+	 * @return void
+	 */
+	public function addEagerConstraints(array $results)
+	{
+		parent::addEagerConstraints($results);
+
+		$this->query->where($this->table.'.'.$this->morphType, $this->morphClass);
+	}
+
+	/**
+	 * Create a new pivot attachment record.
+	 *
+	 * @param int  $id
+	 * @param bool $timed
+	 *
+	 * @return array
+	 */
+	protected function createAttachRecord($id, $timed)
+	{
+		$record = parent::createAttachRecord($id, $timed);
+
+		return array_add($record, $this->morphType, $this->morphClass);
+	}
+
+	/**
+	 * Create a new query builder for the pivot table.
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	protected function newPivotQuery()
+	{
+		$query = parent::newPivotQuery();
+
+		return $query->where($this->morphType, $this->morphClass);
+	}
+
+	/**
+	 * Create a new pivot model instance.
+	 *
+	 * @param array $attributes
+	 * @param bool  $exists
+	 *
+	 * @return Pivot
+	 */
+	public function newPivot(array $attributes = [], $exists = false)
+	{
+		$pivot = new MorphPivot($this->parent, $this->parentMap, $attributes, $this->table, $exists);
+
+		$pivot->setPivotKeys($this->foreignKey, $this->otherKey)
+			->setMorphType($this->morphType)
+			->setMorphClass($this->morphClass);
+
+		return $pivot;
+	}
+
+	/**
+	 * Return Pivot attributes when available on a relationship.
+	 *
+	 * @return array
+	 */
+	public function getPivotAttributes()
+	{
+		return $this->pivotColumns;
+	}
+
+	/**
+	 * Get the foreign key "type" name.
+	 *
+	 * @return string
+	 */
+	public function getMorphType()
+	{
+		return $this->morphType;
+	}
+
+	/**
+	 * Get the class name of the parent model.
+	 *
+	 * @return string
+	 */
+	public function getMorphClass()
+	{
+		return $this->morphClass;
+	}
 }