analogueorm / analogue

src/Relationships/HasMany.php

Indentation +46 added lines, -46 removed lines

@@ -6,50 +6,50 @@
 
 class HasMany extends HasOneOrMany
 {
-    /**
-     * Get the results of the relationship.
-     *
-     * @param  $relation
-     *
-     * @return mixed
-     */
-    public function getResults($relation)
-    {
-        $results = $this->query->get();
-
-        $this->cacheRelation($results, $relation);
-
-        return $results;
-    }
-
-    /**
-     * Initialize the relation on a set of entities.
-     *
-     * @param  array  $entities
-     * @param  string $relation
-     * @return array
-     */
-    public function initRelation(array $entities, $relation)
-    {
-        foreach ($entities as $entity) {
-            $entityWrapper = $this->factory->make($entity);
-
-            $entityWrapper->setEntityAttribute($relation, $this->relatedMap->newCollection());
-        }
-
-        return $entities;
-    }
-
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param  array             $entities
-     * @param  EntityCollection  $results
-     * @param  string            $relation
-     * @return array
-     */
-    public function match(array $entities, EntityCollection $results, $relation)
-    {
-        return $this->matchMany($entities, $results, $relation);
-    }
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @param  $relation
+	 *
+	 * @return mixed
+	 */
+	public function getResults($relation)
+	{
+		$results = $this->query->get();
+
+		$this->cacheRelation($results, $relation);
+
+		return $results;
+	}
+
+	/**
+	 * Initialize the relation on a set of entities.
+	 *
+	 * @param  array  $entities
+	 * @param  string $relation
+	 * @return array
+	 */
+	public function initRelation(array $entities, $relation)
+	{
+		foreach ($entities as $entity) {
+			$entityWrapper = $this->factory->make($entity);
+
+			$entityWrapper->setEntityAttribute($relation, $this->relatedMap->newCollection());
+		}
+
+		return $entities;
+	}
+
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param  array             $entities
+	 * @param  EntityCollection  $results
+	 * @param  string            $relation
+	 * @return array
+	 */
+	public function match(array $entities, EntityCollection $results, $relation)
+	{
+		return $this->matchMany($entities, $results, $relation);
+	}
 }

src/Relationships/MorphOne.php

Indentation +45 added lines, -45 removed lines

@@ -6,49 +6,49 @@
 
 class MorphOne extends MorphOneOrMany
 {
-    /**
-     * Get the results of the relationship.
-     *
-     * @param  $relation
-     * @return mixed
-     */
-    public function getResults($relation)
-    {
-        $result = $this->query->first();
-
-        $this->cacheRelation($result, $relation);
-
-        return $result;
-    }
-
-    /**
-     * Initialize the relation on a set of models.
-     *
-     * @param  array  $entities
-     * @param  string $relation
-     * @return array
-     */
-    public function initRelation(array $entities, $relation)
-    {
-        foreach ($entities as $entity) {
-            $entity = $this->factory->make($entity);
-
-            $entity->setEntityAttribute($relation, null);
-        }
-
-        return $entities;
-    }
-
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param  array            $entities
-     * @param  EntityCollection $results
-     * @param  string           $relation
-     * @return array
-     */
-    public function match(array $entities, EntityCollection $results, $relation)
-    {
-        return $this->matchOne($entities, $results, $relation);
-    }
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @param  $relation
+	 * @return mixed
+	 */
+	public function getResults($relation)
+	{
+		$result = $this->query->first();
+
+		$this->cacheRelation($result, $relation);
+
+		return $result;
+	}
+
+	/**
+	 * Initialize the relation on a set of models.
+	 *
+	 * @param  array  $entities
+	 * @param  string $relation
+	 * @return array
+	 */
+	public function initRelation(array $entities, $relation)
+	{
+		foreach ($entities as $entity) {
+			$entity = $this->factory->make($entity);
+
+			$entity->setEntityAttribute($relation, null);
+		}
+
+		return $entities;
+	}
+
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param  array            $entities
+	 * @param  EntityCollection $results
+	 * @param  string           $relation
+	 * @return array
+	 */
+	public function match(array $entities, EntityCollection $results, $relation)
+	{
+		return $this->matchOne($entities, $results, $relation);
+	}
 }

src/Relationships/MorphMany.php

Indentation +45 added lines, -45 removed lines

@@ -6,49 +6,49 @@
 
 class MorphMany extends MorphOneOrMany
 {
-    /**
-     * Get the results of the relationship.
-     *
-     * @param  $relation
-     * @return mixed
-     */
-    public function getResults($relation)
-    {
-        $results = $this->query->get();
-
-        $this->cacheRelation($results, $relation);
-
-        return $results;
-    }
-
-    /**
-     * Initialize the relation on a set of models.
-     *
-     * @param  array  $entities
-     * @param  string $relation
-     * @return array
-     */
-    public function initRelation(array $entities, $relation)
-    {
-        foreach ($entities as $entity) {
-            $entity = $this->factory->make($entity);
-
-            $entity->setEntityAttribute($relation, $this->relatedMap->newCollection());
-        }
-
-        return $entities;
-    }
-
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param  array            $entities
-     * @param  EntityCollection $results
-     * @param  string           $relation
-     * @return array
-     */
-    public function match(array $entities, EntityCollection $results, $relation)
-    {
-        return $this->matchMany($entities, $results, $relation);
-    }
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @param  $relation
+	 * @return mixed
+	 */
+	public function getResults($relation)
+	{
+		$results = $this->query->get();
+
+		$this->cacheRelation($results, $relation);
+
+		return $results;
+	}
+
+	/**
+	 * Initialize the relation on a set of models.
+	 *
+	 * @param  array  $entities
+	 * @param  string $relation
+	 * @return array
+	 */
+	public function initRelation(array $entities, $relation)
+	{
+		foreach ($entities as $entity) {
+			$entity = $this->factory->make($entity);
+
+			$entity->setEntityAttribute($relation, $this->relatedMap->newCollection());
+		}
+
+		return $entities;
+	}
+
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param  array            $entities
+	 * @param  EntityCollection $results
+	 * @param  string           $relation
+	 * @return array
+	 */
+	public function match(array $entities, EntityCollection $results, $relation)
+	{
+		return $this->matchMany($entities, $results, $relation);
+	}
 }

src/Relationships/MorphOneOrMany.php

Indentation +115 added lines, -115 removed lines

@@ -7,119 +7,119 @@
 
 abstract class MorphOneOrMany extends HasOneOrMany
 {
-    /**
-     * The foreign key type for the relationship.
-     *
-     * @var string
-     */
-    protected $morphType;
-
-    /**
-     * The class name of the parent model.
-     *
-     * @var string
-     */
-    protected $morphClass;
-
-    /**
-     * Create a new has many relationship instance.
-     *
-     * @param  Mapper                 $mapper
-     * @param  \Analogue\ORM\Mappable $parent
-     * @param  string                 $type
-     * @param  string                 $id
-     * @param  string                 $localKey
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     */
-    public function __construct(Mapper $mapper, $parent, $type, $id, $localKey)
-    {
-        $this->morphType = $type;
-        $this->morphClass = $mapper->getManager()->getMapper($parent)->getEntityMap()->getMorphClass();
-
-        parent::__construct($mapper, $parent, $id, $localKey);
-    }
-
-    /**
-     * Set the base constraints on the relation query.
-     *
-     * @return void
-     */
-    public function addConstraints()
-    {
-        if (static::$constraints) {
-            parent::addConstraints();
-
-            $this->query->where($this->morphType, $this->morphClass);
-        }
-    }
-
-    /**
-     * Get the 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->morphType, $this->morphClass);
-    }
-
-    /**
-     * Set the constraints for an eager load of the relation.
-     *
-     * @param  array $entities
-     * @return void
-     */
-    public function addEagerConstraints(array $entities)
-    {
-        parent::addEagerConstraints($entities);
-
-        $this->query->where($this->morphType, $this->morphClass);
-    }
-
-    /**
-     * Get the foreign key "type" name.
-     *
-     * @return string
-     */
-    public function getMorphType()
-    {
-        return $this->morphType;
-    }
-
-    /**
-     * Get the plain morph type name without the table.
-     *
-     * @return string
-     */
-    public function getPlainMorphType()
-    {
-        return last(explode('.', $this->morphType));
-    }
-
-    /**
-     * Get the class name of the parent model.
-     *
-     * @return string
-     */
-    public function getMorphClass()
-    {
-        return $this->morphClass;
-    }
-
-    /**
-     * Get the foreign key as value pair for this relation
-     *
-     * @return array
-     */
-    public function getForeignKeyValuePair()
-    {
-        return [
-            $this->getPlainForeignKey() => $this->getParentKey(),
-            $this->getPlainMorphType() => $this->morphClass,
-        ];
-    }
+	/**
+	 * The foreign key type for the relationship.
+	 *
+	 * @var string
+	 */
+	protected $morphType;
+
+	/**
+	 * The class name of the parent model.
+	 *
+	 * @var string
+	 */
+	protected $morphClass;
+
+	/**
+	 * Create a new has many relationship instance.
+	 *
+	 * @param  Mapper                 $mapper
+	 * @param  \Analogue\ORM\Mappable $parent
+	 * @param  string                 $type
+	 * @param  string                 $id
+	 * @param  string                 $localKey
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 */
+	public function __construct(Mapper $mapper, $parent, $type, $id, $localKey)
+	{
+		$this->morphType = $type;
+		$this->morphClass = $mapper->getManager()->getMapper($parent)->getEntityMap()->getMorphClass();
+
+		parent::__construct($mapper, $parent, $id, $localKey);
+	}
+
+	/**
+	 * Set the base constraints on the relation query.
+	 *
+	 * @return void
+	 */
+	public function addConstraints()
+	{
+		if (static::$constraints) {
+			parent::addConstraints();
+
+			$this->query->where($this->morphType, $this->morphClass);
+		}
+	}
+
+	/**
+	 * Get the 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->morphType, $this->morphClass);
+	}
+
+	/**
+	 * Set the constraints for an eager load of the relation.
+	 *
+	 * @param  array $entities
+	 * @return void
+	 */
+	public function addEagerConstraints(array $entities)
+	{
+		parent::addEagerConstraints($entities);
+
+		$this->query->where($this->morphType, $this->morphClass);
+	}
+
+	/**
+	 * Get the foreign key "type" name.
+	 *
+	 * @return string
+	 */
+	public function getMorphType()
+	{
+		return $this->morphType;
+	}
+
+	/**
+	 * Get the plain morph type name without the table.
+	 *
+	 * @return string
+	 */
+	public function getPlainMorphType()
+	{
+		return last(explode('.', $this->morphType));
+	}
+
+	/**
+	 * Get the class name of the parent model.
+	 *
+	 * @return string
+	 */
+	public function getMorphClass()
+	{
+		return $this->morphClass;
+	}
+
+	/**
+	 * Get the foreign key as value pair for this relation
+	 *
+	 * @return array
+	 */
+	public function getForeignKeyValuePair()
+	{
+		return [
+			$this->getPlainForeignKey() => $this->getParentKey(),
+			$this->getPlainMorphType() => $this->morphClass,
+		];
+	}
 }

src/Relationships/BelongsTo.php

Spacing +5 added lines, -5 removed lines

@@ -103,7 +103,7 @@ 
             // of the related models matching on the foreign key that's on a parent.
             $table = $this->relatedMap->getTable();
 
-            $this->query->where($table . '.' . $this->otherKey, '=', $this->parent->getEntityAttribute($this->foreignKey));
+            $this->query->where($table.'.'.$this->otherKey, '=', $this->parent->getEntityAttribute($this->foreignKey));
         }
     }
 
@@ -118,7 +118,7 @@ 
     {
         $query->select(new Expression('count(*)'));
 
-        $otherKey = $this->wrap($query->getTable() . '.' . $this->otherKey);
+        $otherKey = $this->wrap($query->getTable().'.'.$this->otherKey);
 
         return $query->where($this->getQualifiedForeignKey(), '=', new Expression($otherKey));
     }
@@ -134,7 +134,7 @@ 
         // We'll grab the primary key name of the related models since it could be set to
         // a non-standard name and not "id". We will then construct the constraint for
         // our eagerly loading query so it returns the proper models from execution.
-        $key = $this->relatedMap->getTable() . '.' . $this->otherKey;
+        $key = $this->relatedMap->getTable().'.'.$this->otherKey;
 
         $this->query->whereIn($key, $this->getEagerModelKeys($entities));
     }
@@ -297,7 +297,7 @@ 
      */
     public function getQualifiedForeignKey()
     {
-        return $this->parentMap->getTable() . '.' . $this->foreignKey;
+        return $this->parentMap->getTable().'.'.$this->foreignKey;
     }
 
     /**
@@ -317,6 +317,6 @@ 
      */
     public function getQualifiedOtherKeyName()
     {
-        return $this->relatedMap->getTable() . '.' . $this->otherKey;
+        return $this->relatedMap->getTable().'.'.$this->otherKey;
     }
 }

Indentation +314 added lines, -314 removed lines

@@ -10,319 +10,319 @@
 
 class BelongsTo extends Relationship
 {
-    /**
-     * The foreign key of the parent model.
-     *
-     * @var string
-     */
-    protected $foreignKey;
-
-    /**
-     * The associated key on the parent model.
-     *
-     * @var string
-     */
-    protected $otherKey;
-
-    /**
-     * The name of the relationship.
-     *
-     * @var string
-     */
-    protected $relation;
-
-    /**
-     * Indicate if the parent entity hold the key for the relation.
-     *
-     * @var boolean
-     */
-    protected static $ownForeignKey = true;
-
-    /**
-     * Create a new belongs to relationship instance.
-     *
-     * @param Mapper   $mapper
-     * @param Mappable $parent
-     * @param string   $foreignKey
-     * @param string   $otherKey
-     * @param string   $relation
-     */
-    public function __construct(Mapper $mapper, $parent, $foreignKey, $otherKey, $relation)
-    {
-        $this->otherKey = $otherKey;
-        $this->relation = $relation;
-        $this->foreignKey = $foreignKey;
-
-        parent::__construct($mapper, $parent);
-    }
-
-    /**
-     * @param  $related
-     * @return mixed
-     */
-    public function attachTo($related)
-    {
-        $this->associate($related);
-    }
-
-    /**
-     * @param $related
-     * @return Mappable
-     */
-    public function detachFrom($related)
-    {
-        return $this->dissociate($related); //todo
-    }
-
-    /**
-     * Get the results of the relationship.
-     *
-     * @param  $relation
-     *
-     * @return \Analogue\ORM\Entity
-     */
-    public function getResults($relation)
-    {
-        $result = $this->query->first();
-
-        $this->cacheRelation($result, $relation);
-
-        return $result;
-    }
-
-    /**
-     * Set the base constraints on the relation query.
-     *
-     * @return void
-     */
-    public function addConstraints()
-    {
-        if (static::$constraints) {
-            // For belongs to relationships, which are essentially the inverse of has one
-            // or has many relationships, we need to actually query on the primary key
-            // of the related models matching on the foreign key that's on a parent.
-            $table = $this->relatedMap->getTable();
-
-            $this->query->where($table . '.' . $this->otherKey, '=', $this->parent->getEntityAttribute($this->foreignKey));
-        }
-    }
-
-    /**
-     * Add the constraints for a relationship count query.
-     *
-     * @param  Query $query
-     * @param  Query $parent
-     * @return Query
-     */
-    public function getRelationCountQuery(Query $query, Query $parent)
-    {
-        $query->select(new Expression('count(*)'));
-
-        $otherKey = $this->wrap($query->getTable() . '.' . $this->otherKey);
-
-        return $query->where($this->getQualifiedForeignKey(), '=', new Expression($otherKey));
-    }
-
-    /**
-     * Set the constraints for an eager load of the relation.
-     *
-     * @param  array $entities
-     * @return void
-     */
-    public function addEagerConstraints(array $entities)
-    {
-        // We'll grab the primary key name of the related models since it could be set to
-        // a non-standard name and not "id". We will then construct the constraint for
-        // our eagerly loading query so it returns the proper models from execution.
-        $key = $this->relatedMap->getTable() . '.' . $this->otherKey;
-
-        $this->query->whereIn($key, $this->getEagerModelKeys($entities));
-    }
-
-    /**
-     * Gather the keys from an array of related models.
-     *
-     * @param  array $entities
-     * @return array
-     */
-    protected function getEagerModelKeys(array $entities)
-    {
-        $keys = [];
-
-        // First we need to gather all of the keys from the parent models so we know what
-        // to query for via the eager loading query. We will add them to an array then
-        // execute a "where in" statement to gather up all of those related records.
-        foreach ($entities as $entity) {
-            $entity = $this->factory->make($entity);
-
-            if (!is_null($value = $entity->getEntityAttribute($this->foreignKey))) {
-                $keys[] = $value;
-            }
-        }
-
-        // If there are no keys that were not null we will just return an array with 0 in
-        // it so the query doesn't fail, but will not return any results, which should
-        // be what this developer is expecting in a case where this happens to them.
-        if (count($keys) == 0) {
-            return [0];
-        }
-
-        return array_values(array_unique($keys));
-    }
-
-    /**
-     * Initialize the relation on a set of models.
-     *
-     * @param  array  $entities
-     * @param  string $relation
-     * @return array
-     */
-    public function initRelation(array $entities, $relation)
-    {
-        foreach ($entities as $entity) {
-            $entity = $this->factory->make($entity);
-            $entity->setEntityAttribute($relation, null);
-        }
-
-        return $entities;
-    }
-
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param  array            $entities
-     * @param  EntityCollection $results
-     * @param  string           $relation
-     * @return array
-     */
-    public function match(array $entities, EntityCollection $results, $relation)
-    {
-        $foreign = $this->foreignKey;
-
-        $other = $this->otherKey;
-
-        // First we will get to build a dictionary of the child models by their primary
-        // key of the relationship, then we can easily match the children back onto
-        // the parents using that dictionary and the primary key of the children.
-        $dictionary = [];
-
-        foreach ($results as $result) {
-            $result = $this->factory->make($result);
-            $dictionary[$result->getEntityAttribute($other)] = $result->getObject();
-        }
-
-        // Once we have the dictionary constructed, we can loop through all the parents
-        // and match back onto their children using these keys of the dictionary and
-        // the primary key of the children to map them onto the correct instances.
-        foreach ($entities as $entity) {
-            $entity = $this->factory->make($entity);
-
-            if (isset($dictionary[$entity->getEntityAttribute($foreign)])) {
-                $entity->setEntityAttribute($relation, $dictionary[$entity->getEntityAttribute($foreign)]);
-            }
-        }
-
-        return $entities;
-    }
-
-    public function sync(array $entities)
-    {
-        if (count($entities) > 1) {
-            throw new MappingException("Single Relationship shouldn't be synced with more than one entity");
-        }
+	/**
+	 * The foreign key of the parent model.
+	 *
+	 * @var string
+	 */
+	protected $foreignKey;
+
+	/**
+	 * The associated key on the parent model.
+	 *
+	 * @var string
+	 */
+	protected $otherKey;
+
+	/**
+	 * The name of the relationship.
+	 *
+	 * @var string
+	 */
+	protected $relation;
+
+	/**
+	 * Indicate if the parent entity hold the key for the relation.
+	 *
+	 * @var boolean
+	 */
+	protected static $ownForeignKey = true;
+
+	/**
+	 * Create a new belongs to relationship instance.
+	 *
+	 * @param Mapper   $mapper
+	 * @param Mappable $parent
+	 * @param string   $foreignKey
+	 * @param string   $otherKey
+	 * @param string   $relation
+	 */
+	public function __construct(Mapper $mapper, $parent, $foreignKey, $otherKey, $relation)
+	{
+		$this->otherKey = $otherKey;
+		$this->relation = $relation;
+		$this->foreignKey = $foreignKey;
+
+		parent::__construct($mapper, $parent);
+	}
+
+	/**
+	 * @param  $related
+	 * @return mixed
+	 */
+	public function attachTo($related)
+	{
+		$this->associate($related);
+	}
+
+	/**
+	 * @param $related
+	 * @return Mappable
+	 */
+	public function detachFrom($related)
+	{
+		return $this->dissociate($related); //todo
+	}
+
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @param  $relation
+	 *
+	 * @return \Analogue\ORM\Entity
+	 */
+	public function getResults($relation)
+	{
+		$result = $this->query->first();
+
+		$this->cacheRelation($result, $relation);
+
+		return $result;
+	}
+
+	/**
+	 * Set the base constraints on the relation query.
+	 *
+	 * @return void
+	 */
+	public function addConstraints()
+	{
+		if (static::$constraints) {
+			// For belongs to relationships, which are essentially the inverse of has one
+			// or has many relationships, we need to actually query on the primary key
+			// of the related models matching on the foreign key that's on a parent.
+			$table = $this->relatedMap->getTable();
+
+			$this->query->where($table . '.' . $this->otherKey, '=', $this->parent->getEntityAttribute($this->foreignKey));
+		}
+	}
+
+	/**
+	 * Add the constraints for a relationship count query.
+	 *
+	 * @param  Query $query
+	 * @param  Query $parent
+	 * @return Query
+	 */
+	public function getRelationCountQuery(Query $query, Query $parent)
+	{
+		$query->select(new Expression('count(*)'));
+
+		$otherKey = $this->wrap($query->getTable() . '.' . $this->otherKey);
+
+		return $query->where($this->getQualifiedForeignKey(), '=', new Expression($otherKey));
+	}
+
+	/**
+	 * Set the constraints for an eager load of the relation.
+	 *
+	 * @param  array $entities
+	 * @return void
+	 */
+	public function addEagerConstraints(array $entities)
+	{
+		// We'll grab the primary key name of the related models since it could be set to
+		// a non-standard name and not "id". We will then construct the constraint for
+		// our eagerly loading query so it returns the proper models from execution.
+		$key = $this->relatedMap->getTable() . '.' . $this->otherKey;
+
+		$this->query->whereIn($key, $this->getEagerModelKeys($entities));
+	}
+
+	/**
+	 * Gather the keys from an array of related models.
+	 *
+	 * @param  array $entities
+	 * @return array
+	 */
+	protected function getEagerModelKeys(array $entities)
+	{
+		$keys = [];
+
+		// First we need to gather all of the keys from the parent models so we know what
+		// to query for via the eager loading query. We will add them to an array then
+		// execute a "where in" statement to gather up all of those related records.
+		foreach ($entities as $entity) {
+			$entity = $this->factory->make($entity);
+
+			if (!is_null($value = $entity->getEntityAttribute($this->foreignKey))) {
+				$keys[] = $value;
+			}
+		}
+
+		// If there are no keys that were not null we will just return an array with 0 in
+		// it so the query doesn't fail, but will not return any results, which should
+		// be what this developer is expecting in a case where this happens to them.
+		if (count($keys) == 0) {
+			return [0];
+		}
+
+		return array_values(array_unique($keys));
+	}
+
+	/**
+	 * Initialize the relation on a set of models.
+	 *
+	 * @param  array  $entities
+	 * @param  string $relation
+	 * @return array
+	 */
+	public function initRelation(array $entities, $relation)
+	{
+		foreach ($entities as $entity) {
+			$entity = $this->factory->make($entity);
+			$entity->setEntityAttribute($relation, null);
+		}
+
+		return $entities;
+	}
+
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param  array            $entities
+	 * @param  EntityCollection $results
+	 * @param  string           $relation
+	 * @return array
+	 */
+	public function match(array $entities, EntityCollection $results, $relation)
+	{
+		$foreign = $this->foreignKey;
+
+		$other = $this->otherKey;
+
+		// First we will get to build a dictionary of the child models by their primary
+		// key of the relationship, then we can easily match the children back onto
+		// the parents using that dictionary and the primary key of the children.
+		$dictionary = [];
+
+		foreach ($results as $result) {
+			$result = $this->factory->make($result);
+			$dictionary[$result->getEntityAttribute($other)] = $result->getObject();
+		}
+
+		// Once we have the dictionary constructed, we can loop through all the parents
+		// and match back onto their children using these keys of the dictionary and
+		// the primary key of the children to map them onto the correct instances.
+		foreach ($entities as $entity) {
+			$entity = $this->factory->make($entity);
+
+			if (isset($dictionary[$entity->getEntityAttribute($foreign)])) {
+				$entity->setEntityAttribute($relation, $dictionary[$entity->getEntityAttribute($foreign)]);
+			}
+		}
+
+		return $entities;
+	}
+
+	public function sync(array $entities)
+	{
+		if (count($entities) > 1) {
+			throw new MappingException("Single Relationship shouldn't be synced with more than one entity");
+		}
         
-        if (count($entities) == 1) {
-            return $this->associate($entities[0]);
-        }
-
-        return false;
-    }
-
-    /**
-     * Associate the model instance to the given parent.
-     *
-     * @param  mixed $entity
-     * @return void
-     */
-    public function associate($entity)
-    {
-        $this->parent->setEntityAttribute($this->foreignKey, $entity->getEntityAttribute($this->otherKey));
-    }
-
-    /**
-     * Dissociate previously associated model from the given parent.
-     *
-     * @return Mappable
-     */
-    public function dissociate()
-    {
-        // The Mapper will retrieve this association within the object model, we won't be using
-        // the foreign key attribute inside the parent Entity.
-        //
-        //$this->parent->setEntityAttribute($this->foreignKey, null);
-
-        $this->parent->setEntityAttribute($this->relation, null);
-    }
-
-    /**
-     * Get the foreign key of the relationship.
-     *
-     * @return string
-     */
-    public function getForeignKey()
-    {
-        return $this->foreignKey;
-    }
-
-    /**
-     * Get the foreign key value pair for a related object
-     *
-     * @param  mixed $related
-     *
-     * @return array
-     */
-    public function getForeignKeyValuePair($related)
-    {
-        $foreignKey = $this->getForeignKey();
-
-        if ($related) {
-            $wrapper = $this->factory->make($related);
-
-            $relatedKey = $this->relatedMap->getKeyName();
-
-            return [$foreignKey => $wrapper->getEntityAttribute($relatedKey)];
-        } else {
-            return [$foreignKey => null];
-        }
-    }
-
-    /**
-     * Get the fully qualified foreign key of the relationship.
-     *
-     * @return string
-     */
-    public function getQualifiedForeignKey()
-    {
-        return $this->parentMap->getTable() . '.' . $this->foreignKey;
-    }
-
-    /**
-     * Get the associated key of the relationship.
-     *
-     * @return string
-     */
-    public function getOtherKey()
-    {
-        return $this->otherKey;
-    }
-
-    /**
-     * Get the fully qualified associated key of the relationship.
-     *
-     * @return string
-     */
-    public function getQualifiedOtherKeyName()
-    {
-        return $this->relatedMap->getTable() . '.' . $this->otherKey;
-    }
+		if (count($entities) == 1) {
+			return $this->associate($entities[0]);
+		}
+
+		return false;
+	}
+
+	/**
+	 * Associate the model instance to the given parent.
+	 *
+	 * @param  mixed $entity
+	 * @return void
+	 */
+	public function associate($entity)
+	{
+		$this->parent->setEntityAttribute($this->foreignKey, $entity->getEntityAttribute($this->otherKey));
+	}
+
+	/**
+	 * Dissociate previously associated model from the given parent.
+	 *
+	 * @return Mappable
+	 */
+	public function dissociate()
+	{
+		// The Mapper will retrieve this association within the object model, we won't be using
+		// the foreign key attribute inside the parent Entity.
+		//
+		//$this->parent->setEntityAttribute($this->foreignKey, null);
+
+		$this->parent->setEntityAttribute($this->relation, null);
+	}
+
+	/**
+	 * Get the foreign key of the relationship.
+	 *
+	 * @return string
+	 */
+	public function getForeignKey()
+	{
+		return $this->foreignKey;
+	}
+
+	/**
+	 * Get the foreign key value pair for a related object
+	 *
+	 * @param  mixed $related
+	 *
+	 * @return array
+	 */
+	public function getForeignKeyValuePair($related)
+	{
+		$foreignKey = $this->getForeignKey();
+
+		if ($related) {
+			$wrapper = $this->factory->make($related);
+
+			$relatedKey = $this->relatedMap->getKeyName();
+
+			return [$foreignKey => $wrapper->getEntityAttribute($relatedKey)];
+		} else {
+			return [$foreignKey => null];
+		}
+	}
+
+	/**
+	 * Get the fully qualified foreign key of the relationship.
+	 *
+	 * @return string
+	 */
+	public function getQualifiedForeignKey()
+	{
+		return $this->parentMap->getTable() . '.' . $this->foreignKey;
+	}
+
+	/**
+	 * Get the associated key of the relationship.
+	 *
+	 * @return string
+	 */
+	public function getOtherKey()
+	{
+		return $this->otherKey;
+	}
+
+	/**
+	 * Get the fully qualified associated key of the relationship.
+	 *
+	 * @return string
+	 */
+	public function getQualifiedOtherKeyName()
+	{
+		return $this->relatedMap->getTable() . '.' . $this->otherKey;
+	}
 }

src/Relationships/MorphToMany.php

Indentation +162 added lines, -162 removed lines

@@ -7,167 +7,167 @@
 
 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;
+	/**
+	 * 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 $entities
-     * @return void
-     */
-    public function addEagerConstraints(array $entities)
-    {
-        parent::addEagerConstraints($entities);
-
-        $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;
-    }
+		$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 $entities
+	 * @return void
+	 */
+	public function addEagerConstraints(array $entities)
+	{
+		parent::addEagerConstraints($entities);
+
+		$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;
+	}
 }

Spacing +4 added lines, -4 removed lines

@@ -48,7 +48,7 @@ 
     {
         $this->inverse = $inverse;
         
-        $this->morphType = $name . '_type';
+        $this->morphType = $name.'_type';
 
         $this->morphClass = $inverse ? $mapper->getEntityMap()->getClass() : get_class($parent);
 
@@ -64,7 +64,7 @@ 
     {
         parent::setWhere();
 
-        $this->query->where($this->table . '.' . $this->morphType, $this->morphClass);
+        $this->query->where($this->table.'.'.$this->morphType, $this->morphClass);
 
         return $this;
     }
@@ -80,7 +80,7 @@ 
     {
         $query = parent::getRelationCountQuery($query, $parent);
 
-        return $query->where($this->table . '.' . $this->morphType, $this->morphClass);
+        return $query->where($this->table.'.'.$this->morphType, $this->morphClass);
     }
 
     /**
@@ -93,7 +93,7 @@ 
     {
         parent::addEagerConstraints($entities);
 
-        $this->query->where($this->table . '.' . $this->morphType, $this->morphClass);
+        $this->query->where($this->table.'.'.$this->morphType, $this->morphClass);
     }
 
     /**

src/Relationships/HasOneOrMany.php

Indentation +317 added lines, -317 removed lines

@@ -7,321 +7,321 @@
 
 abstract class HasOneOrMany extends Relationship
 {
-    /**
-     * The foreign key of the parent model.
-     *
-     * @var string
-     */
-    protected $foreignKey;
-
-    /**
-     * The local key of the parent model.
-     *
-     * @var string
-     */
-    protected $localKey;
-
-    /**
-     * Create a new has many relationship instance.
-     *
-     * @param Mapper                 $mapper
-     * @param \Analogue\ORM\Mappable $parentEntity
-     * @param string                 $foreignKey
-     * @param string                 $localKey
-     */
-    public function __construct(Mapper $mapper, $parentEntity, $foreignKey, $localKey)
-    {
-        $this->localKey = $localKey;
-        $this->foreignKey = $foreignKey;
-
-        parent::__construct($mapper, $parentEntity);
-    }
-
-    /**
-     * @param \Analogue\ORM\Entity|EntityCollection $entity
-     * @return void
-     */
-    public function attachTo($entity)
-    {
-        if ($entity instanceof EntityCollection) {
-            $this->attachMany($entity);
-        }
-        $this->attachOne($entity);
-    }
-
-    /**
-     * @param $entityHash
-     * @return void
-     */
-    public function detachFrom($entityHash)
-    {
-        if (is_array($entityHash)) {
-            $this->detachMany($entityHash);
-            return;
-        }
-        $this->detachMany([$entityHash]);
-    }
-
-    /**
-     * @param \Analogue\ORM\Entity $entity
-     */
-    public function attachOne($entity)
-    {
-        $wrapper = $this->factory->make($entity);
-
-        // Ok, we need to guess the inverse of the relation from there.
-        // Let's assume the inverse of the relation method is the name of
-        // the entity.
-
-        $wrapper->setEntityAttribute($this->getPlainForeignKey(), $this->getParentKey());
-    }
-
-    /**
-     * @param EntityCollection $entities
-     */
-    public function attachMany(EntityCollection $entities)
-    {
-        foreach ($entities as $entity) {
-            $this->attachOne($entity);
-        }
-    }
-
-    /**
-     * @param $entityHash
-     */
-    protected function detachOne($entityHash)
-    {
-        $this->detachMany([$entityHash]);
-    }
-
-    /**
-     * Attach ids that are passed as arguments, and detach any other
-     * @param  mixed $entities
-     * @throws \InvalidArgumentException
-     * @return void
-     */
-    public function sync(array $entities)
-    {
-        $this->detachExcept($entities);
-    }
-
-    /**
-     * @param  $entities
-     * @throws \InvalidArgumentException
-     */
-    protected function detachExcept($entities)
-    {
-        $query = $this->query->getQuery()->from($this->relatedMap->getTable());
-
-        if (count($entities) > 0) {
-            $keys = $this->getKeys($entities);
-            $query->whereNotIn($this->relatedMap->getKeyName(), $keys);
-        }
-
-        $parentKey = $this->parentMap->getKeyName();
-
-        $query->where($this->getPlainForeignKey(), '=', $this->parent->getEntityAttribute($parentKey))
-            ->update([$this->getPlainForeignKey() => null]);
-    }
-
-    /**
-     * @param array $entityHashes
-     */
-    public function detachMany(array $entityHashes)
-    {
-        $keys = [];
-
-        foreach ($entityHashes as $hash) {
-            $split = explode('.', $hash);
-            $keys[] = $split[1];
-        }
-
-        $query = $this->query->getQuery()->from($this->relatedMap->getTable());
-
-        $query->whereIn($this->relatedMap->getKeyName(), $keys)
-            ->update([$this->getPlainForeignKey() => null]);
-    }
-
-    /**
-     * Set the base constraints on the relation query.
-     *
-     * @return void
-     */
-    public function addConstraints()
-    {
-        if (static::$constraints) {
-            $this->query->where($this->foreignKey, '=', $this->getParentKey());
-        }
-    }
-
-    /**
-     * Set the constraints for an eager load of the relation.
-     *
-     * @param  array $entities
-     * @return void
-     */
-    public function addEagerConstraints(array $entities)
-    {
-        $this->query->whereIn($this->foreignKey, $this->getKeys($entities, $this->localKey));
-    }
-
-    /**
-     * Match the eagerly loaded results to their single parents.
-     *
-     * @param  array            $entities
-     * @param  EntityCollection $results
-     * @param  string           $relation
-     * @return array
-     */
-    public function matchOne(array $entities, EntityCollection $results, $relation)
-    {
-        return $this->matchOneOrMany($entities, $results, $relation, 'one');
-    }
-
-    /**
-     * Match the eagerly loaded results to their many parents.
-     *
-     * @param  array            $entities
-     * @param  EntityCollection $results
-     * @param  string           $relation
-     * @return array
-     */
-    public function matchMany(array $entities, EntityCollection $results, $relation)
-    {
-        return $this->matchOneOrMany($entities, $results, $relation, 'many');
-    }
-
-    /**
-     * Match the eagerly loaded results to their many parents.
-     *
-     * @param  array            $entities
-     * @param  EntityCollection $results
-     * @param  string           $relation
-     * @param  string           $type
-     * @return array
-     */
-    protected function matchOneOrMany(array $entities, EntityCollection $results, $relation, $type)
-    {
-        $dictionary = $this->buildDictionary($results);
-
-        $cache = $this->parentMapper->getEntityCache();
-
-        // Once we have the dictionary we can simply spin through the parent models to
-        // link them up with their children using the keyed dictionary to make the
-        // matching very convenient and easy work. Then we'll just return them.
-        foreach ($entities as $entity) {
-            $entity = $this->factory->make($entity);
-
-            $key = $entity->getEntityAttribute($this->localKey);
-
-            if (isset($dictionary[$key])) {
-                $value = $this->getRelationValue($dictionary, $key, $type);
-
-                $entity->setEntityAttribute($relation, $value);
-
-                $cache->cacheLoadedRelationResult($entity, $relation, $value, $this);
-            }
-        }
-
-        return $entities;
-    }
-
-    /**
-     * Get the value of a relationship by one or many type.
-     *
-     * @param  array  $dictionary
-     * @param  string $key
-     * @param  string $type
-     * @return mixed
-     */
-    protected function getRelationValue(array $dictionary, $key, $type)
-    {
-        $value = $dictionary[$key];
-
-        return $type == 'one' ? reset($value) : $this->relatedMap->newCollection($value);
-    }
-
-    /**
-     * Build model dictionary keyed by the relation's foreign key.
-     *
-     * @param  EntityCollection $results
-     * @return array
-     */
-    protected function buildDictionary(EntityCollection $results)
-    {
-        $dictionary = [];
-
-        $foreign = $this->getPlainForeignKey();
-
-        // First we will create a dictionary of models keyed by the foreign key of the
-        // relationship as this will allow us to quickly access all of the related
-        // models without having to do nested looping which will be quite slow.
-        foreach ($results as $result) {
-            $dictionary[$result->{$foreign}][] = $result;
-        }
-
-        return $dictionary;
-    }
-
-    /**
-     * Get the key for comparing against the parent key in "has" query.
-     *
-     * @return string
-     */
-    public function getHasCompareKey()
-    {
-        return $this->getForeignKey();
-    }
-
-    /**
-     * Get the foreign key for the relationship.
-     *
-     * @return string
-     */
-    public function getForeignKey()
-    {
-        return $this->foreignKey;
-    }
-
-    /**
-     * Get the plain foreign key.
-     *
-     * @return string
-     */
-    public function getPlainForeignKey()
-    {
-        $segments = explode('.', $this->getForeignKey());
-
-        return $segments[count($segments) - 1];
-    }
-
-    /**
-     * Get the key value of the parent's local key.
-     *
-     * @return mixed
-     */
-    public function getParentKey()
-    {
-        return $this->parent->getEntityAttribute($this->localKey);
-    }
-
-    /**
-     * Get the fully qualified parent key name.
-     *
-     * @return string
-     */
-    public function getQualifiedParentKeyName()
-    {
-        return $this->parentMap->getTable() . '.' . $this->localKey;
-    }
-
-    /**
-     * Get the foreign key as value pair for this relation
-     *
-     * @return array
-     */
-    public function getForeignKeyValuePair()
-    {
-        return [$this->getPlainForeignKey() => $this->getParentKey()];
-    }
+	/**
+	 * The foreign key of the parent model.
+	 *
+	 * @var string
+	 */
+	protected $foreignKey;
+
+	/**
+	 * The local key of the parent model.
+	 *
+	 * @var string
+	 */
+	protected $localKey;
+
+	/**
+	 * Create a new has many relationship instance.
+	 *
+	 * @param Mapper                 $mapper
+	 * @param \Analogue\ORM\Mappable $parentEntity
+	 * @param string                 $foreignKey
+	 * @param string                 $localKey
+	 */
+	public function __construct(Mapper $mapper, $parentEntity, $foreignKey, $localKey)
+	{
+		$this->localKey = $localKey;
+		$this->foreignKey = $foreignKey;
+
+		parent::__construct($mapper, $parentEntity);
+	}
+
+	/**
+	 * @param \Analogue\ORM\Entity|EntityCollection $entity
+	 * @return void
+	 */
+	public function attachTo($entity)
+	{
+		if ($entity instanceof EntityCollection) {
+			$this->attachMany($entity);
+		}
+		$this->attachOne($entity);
+	}
+
+	/**
+	 * @param $entityHash
+	 * @return void
+	 */
+	public function detachFrom($entityHash)
+	{
+		if (is_array($entityHash)) {
+			$this->detachMany($entityHash);
+			return;
+		}
+		$this->detachMany([$entityHash]);
+	}
+
+	/**
+	 * @param \Analogue\ORM\Entity $entity
+	 */
+	public function attachOne($entity)
+	{
+		$wrapper = $this->factory->make($entity);
+
+		// Ok, we need to guess the inverse of the relation from there.
+		// Let's assume the inverse of the relation method is the name of
+		// the entity.
+
+		$wrapper->setEntityAttribute($this->getPlainForeignKey(), $this->getParentKey());
+	}
+
+	/**
+	 * @param EntityCollection $entities
+	 */
+	public function attachMany(EntityCollection $entities)
+	{
+		foreach ($entities as $entity) {
+			$this->attachOne($entity);
+		}
+	}
+
+	/**
+	 * @param $entityHash
+	 */
+	protected function detachOne($entityHash)
+	{
+		$this->detachMany([$entityHash]);
+	}
+
+	/**
+	 * Attach ids that are passed as arguments, and detach any other
+	 * @param  mixed $entities
+	 * @throws \InvalidArgumentException
+	 * @return void
+	 */
+	public function sync(array $entities)
+	{
+		$this->detachExcept($entities);
+	}
+
+	/**
+	 * @param  $entities
+	 * @throws \InvalidArgumentException
+	 */
+	protected function detachExcept($entities)
+	{
+		$query = $this->query->getQuery()->from($this->relatedMap->getTable());
+
+		if (count($entities) > 0) {
+			$keys = $this->getKeys($entities);
+			$query->whereNotIn($this->relatedMap->getKeyName(), $keys);
+		}
+
+		$parentKey = $this->parentMap->getKeyName();
+
+		$query->where($this->getPlainForeignKey(), '=', $this->parent->getEntityAttribute($parentKey))
+			->update([$this->getPlainForeignKey() => null]);
+	}
+
+	/**
+	 * @param array $entityHashes
+	 */
+	public function detachMany(array $entityHashes)
+	{
+		$keys = [];
+
+		foreach ($entityHashes as $hash) {
+			$split = explode('.', $hash);
+			$keys[] = $split[1];
+		}
+
+		$query = $this->query->getQuery()->from($this->relatedMap->getTable());
+
+		$query->whereIn($this->relatedMap->getKeyName(), $keys)
+			->update([$this->getPlainForeignKey() => null]);
+	}
+
+	/**
+	 * Set the base constraints on the relation query.
+	 *
+	 * @return void
+	 */
+	public function addConstraints()
+	{
+		if (static::$constraints) {
+			$this->query->where($this->foreignKey, '=', $this->getParentKey());
+		}
+	}
+
+	/**
+	 * Set the constraints for an eager load of the relation.
+	 *
+	 * @param  array $entities
+	 * @return void
+	 */
+	public function addEagerConstraints(array $entities)
+	{
+		$this->query->whereIn($this->foreignKey, $this->getKeys($entities, $this->localKey));
+	}
+
+	/**
+	 * Match the eagerly loaded results to their single parents.
+	 *
+	 * @param  array            $entities
+	 * @param  EntityCollection $results
+	 * @param  string           $relation
+	 * @return array
+	 */
+	public function matchOne(array $entities, EntityCollection $results, $relation)
+	{
+		return $this->matchOneOrMany($entities, $results, $relation, 'one');
+	}
+
+	/**
+	 * Match the eagerly loaded results to their many parents.
+	 *
+	 * @param  array            $entities
+	 * @param  EntityCollection $results
+	 * @param  string           $relation
+	 * @return array
+	 */
+	public function matchMany(array $entities, EntityCollection $results, $relation)
+	{
+		return $this->matchOneOrMany($entities, $results, $relation, 'many');
+	}
+
+	/**
+	 * Match the eagerly loaded results to their many parents.
+	 *
+	 * @param  array            $entities
+	 * @param  EntityCollection $results
+	 * @param  string           $relation
+	 * @param  string           $type
+	 * @return array
+	 */
+	protected function matchOneOrMany(array $entities, EntityCollection $results, $relation, $type)
+	{
+		$dictionary = $this->buildDictionary($results);
+
+		$cache = $this->parentMapper->getEntityCache();
+
+		// Once we have the dictionary we can simply spin through the parent models to
+		// link them up with their children using the keyed dictionary to make the
+		// matching very convenient and easy work. Then we'll just return them.
+		foreach ($entities as $entity) {
+			$entity = $this->factory->make($entity);
+
+			$key = $entity->getEntityAttribute($this->localKey);
+
+			if (isset($dictionary[$key])) {
+				$value = $this->getRelationValue($dictionary, $key, $type);
+
+				$entity->setEntityAttribute($relation, $value);
+
+				$cache->cacheLoadedRelationResult($entity, $relation, $value, $this);
+			}
+		}
+
+		return $entities;
+	}
+
+	/**
+	 * Get the value of a relationship by one or many type.
+	 *
+	 * @param  array  $dictionary
+	 * @param  string $key
+	 * @param  string $type
+	 * @return mixed
+	 */
+	protected function getRelationValue(array $dictionary, $key, $type)
+	{
+		$value = $dictionary[$key];
+
+		return $type == 'one' ? reset($value) : $this->relatedMap->newCollection($value);
+	}
+
+	/**
+	 * Build model dictionary keyed by the relation's foreign key.
+	 *
+	 * @param  EntityCollection $results
+	 * @return array
+	 */
+	protected function buildDictionary(EntityCollection $results)
+	{
+		$dictionary = [];
+
+		$foreign = $this->getPlainForeignKey();
+
+		// First we will create a dictionary of models keyed by the foreign key of the
+		// relationship as this will allow us to quickly access all of the related
+		// models without having to do nested looping which will be quite slow.
+		foreach ($results as $result) {
+			$dictionary[$result->{$foreign}][] = $result;
+		}
+
+		return $dictionary;
+	}
+
+	/**
+	 * Get the key for comparing against the parent key in "has" query.
+	 *
+	 * @return string
+	 */
+	public function getHasCompareKey()
+	{
+		return $this->getForeignKey();
+	}
+
+	/**
+	 * Get the foreign key for the relationship.
+	 *
+	 * @return string
+	 */
+	public function getForeignKey()
+	{
+		return $this->foreignKey;
+	}
+
+	/**
+	 * Get the plain foreign key.
+	 *
+	 * @return string
+	 */
+	public function getPlainForeignKey()
+	{
+		$segments = explode('.', $this->getForeignKey());
+
+		return $segments[count($segments) - 1];
+	}
+
+	/**
+	 * Get the key value of the parent's local key.
+	 *
+	 * @return mixed
+	 */
+	public function getParentKey()
+	{
+		return $this->parent->getEntityAttribute($this->localKey);
+	}
+
+	/**
+	 * Get the fully qualified parent key name.
+	 *
+	 * @return string
+	 */
+	public function getQualifiedParentKeyName()
+	{
+		return $this->parentMap->getTable() . '.' . $this->localKey;
+	}
+
+	/**
+	 * Get the foreign key as value pair for this relation
+	 *
+	 * @return array
+	 */
+	public function getForeignKeyValuePair()
+	{
+		return [$this->getPlainForeignKey() => $this->getParentKey()];
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -312,7 +312,7 @@
      */
     public function getQualifiedParentKeyName()
     {
-        return $this->parentMap->getTable() . '.' . $this->localKey;
+        return $this->parentMap->getTable().'.'.$this->localKey;
     }
 
     /**

src/Relationships/Pivot.php

Indentation +157 added lines, -157 removed lines

@@ -6,161 +6,161 @@
 
 class Pivot extends Entity
 {
-    /**
-     * @var bool
-     */
-    protected $exists;
-
-    /**
-     * Pivot's table
-     *
-     * @var string
-     */
-    protected $table;
-
-    /**
-     * The parent entity of the relationship.
-     *
-     * @var object
-     */
-    protected $parent;
-
-    /**
-     * The parent entity of the relationship.
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $parentMap;
-
-    /**
-     * We may define a pivot mapping to deal with
-     * soft deletes, timestamps, etc.
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $pivotMap;
-
-    /**
-     * The name of the foreign key column.
-     *
-     * @var string
-     */
-    protected $foreignKey;
-
-    /**
-     * The name of the "other key" column.
-     *
-     * @var string
-     */
-    protected $otherKey;
-
-    /**
-     * The attributes that aren't mass assignable.
-     *
-     * @var array
-     */
-    protected $guarded = [];
-
-    /**
-     * Pivot uses timestamps ?
-     *
-     * @var boolean
-     */
-    protected $timestamps;
-
-    /**
-     * Create a new pivot model instance.
-     *
-     * @param \Analogue\ORM\System\InternallyMappable $parent
-     * @param \Analogue\ORM\EntityMap                 $parentMap
-     * @param array                                   $attributes
-     * @param string                                  $table
-     * @param bool                                    $exists
-     */
-    public function __construct($parent, $parentMap, $attributes, $table, $exists = false)
-    {
-        // The pivot model is a "dynamic" model since we will set the tables dynamically
-        // for the instance. This allows it work for any intermediate tables for the
-        // many to many relationship that are defined by this developer's classes.
-        $this->setEntityAttributes($attributes, true);
-
-        $this->table = $table;
-
-        // We store off the parent instance so we will access the timestamp column names
-        // for the model, since the pivot model timestamps aren't easily configurable
-        // from the developer's point of view. We can use the parents to get these.
-        $this->parent = $parent;
-
-        $this->parentMap = $parentMap;
-
-        $this->exists = $exists;
-
-        $this->timestamps = $this->hasTimestampAttributes();
-    }
-
-    /**
-     * Get the foreign key column name.
-     *
-     * @return string
-     */
-    public function getForeignKey()
-    {
-        return $this->foreignKey;
-    }
-
-    /**
-     * Get the "other key" column name.
-     *
-     * @return string
-     */
-    public function getOtherKey()
-    {
-        return $this->otherKey;
-    }
-
-    /**
-     * Set the key names for the pivot model instance.
-     *
-     * @param  string $foreignKey
-     * @param  string $otherKey
-     * @return $this
-     */
-    public function setPivotKeys($foreignKey, $otherKey)
-    {
-        $this->foreignKey = $foreignKey;
-
-        $this->otherKey = $otherKey;
-
-        return $this;
-    }
-
-    /**
-     * Determine if the pivot model has timestamp attributes.
-     *
-     * @return bool
-     */
-    public function hasTimestampAttributes()
-    {
-        return array_key_exists($this->getCreatedAtColumn(), $this->attributes);
-    }
-
-    /**
-     * Get the name of the "created at" column.
-     *
-     * @return string
-     */
-    public function getCreatedAtColumn()
-    {
-        return $this->parentMap->getCreatedAtColumn();
-    }
-
-    /**
-     * Get the name of the "updated at" column.
-     *
-     * @return string
-     */
-    public function getUpdatedAtColumn()
-    {
-        return $this->parentMap->getUpdatedAtColumn();
-    }
+	/**
+	 * @var bool
+	 */
+	protected $exists;
+
+	/**
+	 * Pivot's table
+	 *
+	 * @var string
+	 */
+	protected $table;
+
+	/**
+	 * The parent entity of the relationship.
+	 *
+	 * @var object
+	 */
+	protected $parent;
+
+	/**
+	 * The parent entity of the relationship.
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $parentMap;
+
+	/**
+	 * We may define a pivot mapping to deal with
+	 * soft deletes, timestamps, etc.
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $pivotMap;
+
+	/**
+	 * The name of the foreign key column.
+	 *
+	 * @var string
+	 */
+	protected $foreignKey;
+
+	/**
+	 * The name of the "other key" column.
+	 *
+	 * @var string
+	 */
+	protected $otherKey;
+
+	/**
+	 * The attributes that aren't mass assignable.
+	 *
+	 * @var array
+	 */
+	protected $guarded = [];
+
+	/**
+	 * Pivot uses timestamps ?
+	 *
+	 * @var boolean
+	 */
+	protected $timestamps;
+
+	/**
+	 * Create a new pivot model instance.
+	 *
+	 * @param \Analogue\ORM\System\InternallyMappable $parent
+	 * @param \Analogue\ORM\EntityMap                 $parentMap
+	 * @param array                                   $attributes
+	 * @param string                                  $table
+	 * @param bool                                    $exists
+	 */
+	public function __construct($parent, $parentMap, $attributes, $table, $exists = false)
+	{
+		// The pivot model is a "dynamic" model since we will set the tables dynamically
+		// for the instance. This allows it work for any intermediate tables for the
+		// many to many relationship that are defined by this developer's classes.
+		$this->setEntityAttributes($attributes, true);
+
+		$this->table = $table;
+
+		// We store off the parent instance so we will access the timestamp column names
+		// for the model, since the pivot model timestamps aren't easily configurable
+		// from the developer's point of view. We can use the parents to get these.
+		$this->parent = $parent;
+
+		$this->parentMap = $parentMap;
+
+		$this->exists = $exists;
+
+		$this->timestamps = $this->hasTimestampAttributes();
+	}
+
+	/**
+	 * Get the foreign key column name.
+	 *
+	 * @return string
+	 */
+	public function getForeignKey()
+	{
+		return $this->foreignKey;
+	}
+
+	/**
+	 * Get the "other key" column name.
+	 *
+	 * @return string
+	 */
+	public function getOtherKey()
+	{
+		return $this->otherKey;
+	}
+
+	/**
+	 * Set the key names for the pivot model instance.
+	 *
+	 * @param  string $foreignKey
+	 * @param  string $otherKey
+	 * @return $this
+	 */
+	public function setPivotKeys($foreignKey, $otherKey)
+	{
+		$this->foreignKey = $foreignKey;
+
+		$this->otherKey = $otherKey;
+
+		return $this;
+	}
+
+	/**
+	 * Determine if the pivot model has timestamp attributes.
+	 *
+	 * @return bool
+	 */
+	public function hasTimestampAttributes()
+	{
+		return array_key_exists($this->getCreatedAtColumn(), $this->attributes);
+	}
+
+	/**
+	 * Get the name of the "created at" column.
+	 *
+	 * @return string
+	 */
+	public function getCreatedAtColumn()
+	{
+		return $this->parentMap->getCreatedAtColumn();
+	}
+
+	/**
+	 * Get the name of the "updated at" column.
+	 *
+	 * @return string
+	 */
+	public function getUpdatedAtColumn()
+	{
+		return $this->parentMap->getUpdatedAtColumn();
+	}
 }

src/Relationships/HasManyThrough.php

Indentation +299 added lines, -299 removed lines

@@ -9,303 +9,303 @@
 
 class HasManyThrough extends Relationship
 {
-    /**
-     * The distance parent Entity instance.
-     *
-     * @var \Analogue\ORM\Entity
-     */
-    protected $farParent;
-
-    /**
-     * The far parent map instance
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $farParentMap;
-
-    /**
-     * The near key on the relationship.
-     *
-     * @var string
-     */
-    protected $firstKey;
-
-    /**
-     * The far key on the relationship.
-     *
-     * @var string
-     */
-    protected $secondKey;
-
-    /**
-     * Create a new has many relationship instance.
-     *
-     * @param Mapper                  $mapper
-     * @param \Analogue\ORM\Mappable  $farParent
-     * @param \Analogue\ORM\EntityMap $parentMap
-     * @param string                  $firstKey
-     * @param string                  $secondKey
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     */
-    public function __construct(Mapper $mapper, $farParent, $parentMap, $firstKey, $secondKey)
-    {
-        $this->firstKey = $firstKey;
-        $this->secondKey = $secondKey;
-        $this->farParent = $farParent;
-
-        $this->farParentMap = $this->relatedMapper->getManager()->mapper($farParent)->getEntityMap();
-
-        $parentInstance = $this->relatedMapper->getManager()->mapper($parentMap->getClass())->newInstance();
-
-        parent::__construct($mapper, $parentInstance);
-    }
-
-    /**
-     * @param $related
-     * @return mixed
-     */
-    public function attachTo($related)
-    {
-        // N/A
-    }
-
-    /**
-     * @param $related
-     * @return mixed
-     */
-    public function detachFrom($related)
-    {
-        // N/A
-    }
-
-    /**
-     * Set the base constraints on the relation query.
-     *
-     * @return void
-     */
-    public function addConstraints()
-    {
-        $parentTable = $this->parentMap->getTable();
-
-        $this->setJoin();
-
-        if (static::$constraints) {
-            $farParentKeyName = $this->farParentMap->getKeyName();
-
-            $this->query->where(
-                $parentTable . '.' . $this->firstKey,
-                '=',
-                $this->farParent->getEntityAttribute($farParentKeyName)
-            );
-        }
-    }
-
-    /**
-     * Add the constraints for a relationship count query.
-     *
-     * @param  Query $query
-     * @param  Query $parent
-     * @return Query
-     */
-    public function getRelationCountQuery(Query $query, Query $parent)
-    {
-        $parentTable = $this->parentMap->getTable();
-
-        $this->setJoin($query);
-
-        $query->select(new Expression('count(*)'));
-
-        $key = $this->wrap($parentTable . '.' . $this->firstKey);
-
-        return $query->where($this->getHasCompareKey(), '=', new Expression($key));
-    }
-
-    /**
-     * Set the join clause on the query.
-     *
-     * @param  null|Query $query
-     * @return void
-     */
-    protected function setJoin(Query $query = null)
-    {
-        $query = $query ?: $this->query;
-
-        $foreignKey = $this->relatedMap->getTable() . '.' . $this->secondKey;
-
-        $query->join($this->parentMap->getTable(), $this->getQualifiedParentKeyName(), '=', $foreignKey);
-    }
-
-    /**
-     * Set the constraints for an eager load of the relation.
-     *
-     * @param  array $entities
-     * @return void
-     */
-    public function addEagerConstraints(array $entities)
-    {
-        $table = $this->parentMap->getTable();
-
-        $this->query->whereIn($table . '.' . $this->firstKey, $this->getKeys($entities));
-    }
-
-    /**
-     * Initialize the relation on a set of entities.
-     *
-     * @param  \Analogue\ORM\Entity[] $entities
-     * @param  string                 $relation
-     * @return \Analogue\ORM\Entity[]
-     */
-    public function initRelation(array $entities, $relation)
-    {
-        foreach ($entities as $entity) {
-            $entity->setEntityAttribute($relation, $this->relatedMap->newCollection());
-        }
-
-        return $entities;
-    }
-
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param  \Analogue\ORM\Entity[] $entities
-     * @param  EntityCollection       $results
-     * @param  string                 $relation
-     * @return \Analogue\ORM\Entity[]
-     */
-    public function match(array $entities, EntityCollection $results, $relation)
-    {
-        $dictionary = $this->buildDictionary($results);
-
-        $relatedKey = $this->relatedMap->getKeyName();
-
-        $cache = $this->parentMapper->getEntityCache();
-
-        // Once we have the dictionary we can simply spin through the parent entities to
-        // link them up with their children using the keyed dictionary to make the
-        // matching very convenient and easy work. Then we'll just return them.
-        foreach ($entities as $entity) {
-            $key = $entity->getEntityAttribute($relatedKey);
-
-            if (isset($dictionary[$key])) {
-                $value = $this->relatedMap->newCollection($dictionary[$key]);
-
-                $entity->setEntityAttribute($relation, $value);
-
-                $cache->cacheLoadedRelationResult($entity, $relation, $value, $this);
-            }
-        }
-
-        return $entities;
-    }
-
-    /**
-     * Build model dictionary keyed by the relation's foreign key.
-     *
-     * @param  EntityCollection $results
-     * @return array
-     */
-    protected function buildDictionary(EntityCollection $results)
-    {
-        $dictionary = [];
-
-        $foreign = $this->firstKey;
-
-        // First we will create a dictionary of entities keyed by the foreign key of the
-        // relationship as this will allow us to quickly access all of the related
-        // entities without having to do nested looping which will be quite slow.
-        foreach ($results as $result) {
-            $dictionary[$result->{$foreign}][] = $result;
-        }
-
-        return $dictionary;
-    }
-
-    /**
-     * Get the results of the relationship.
-     *
-     * @param  $relation
-     * @return EntityCollection
-     */
-    public function getResults($relation)
-    {
-        $results = $this->query->get();
-
-        $this->cacheRelation($results, $relation);
-
-        return $results;
-    }
-
-    /**
-     * Execute the query as a "select" statement.
-     *
-     * @param  array $columns
-     * @return EntityCollection
-     */
-    public function get($columns = ['*'])
-    {
-        // 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
-        // entities with the result of those columns as a separate model relation.
-        $select = $this->getSelectColumns($columns);
-
-        $entities = $this->query->addSelect($select)->getEntities();
-
-        // If we actually found entities we will also eager load any relationships that
-        // have been specified as needing to be eager loaded. This will solve the
-        // n + 1 query problem for the developer and also increase performance.
-        if (count($entities) > 0) {
-            $entities = $this->query->eagerLoadRelations($entities);
-        }
-
-        return $this->relatedMap->newCollection($entities);
-    }
-
-    /**
-     * Set the select clause for the relation query.
-     *
-     * @param  array $columns
-     * @return BelongsToMany
-     */
-    protected function getSelectColumns(array $columns = ['*'])
-    {
-        if ($columns == ['*']) {
-            $columns = [$this->relatedMap->getTable() . '.*'];
-        }
-
-        return array_merge($columns, [$this->parentMap->getTable() . '.' . $this->firstKey]);
-    }
-
-    /**
-     * Get a paginator for the "select" statement.
-     *
-     * @param  int   $perPage
-     * @param  array $columns
-     * @return \Illuminate\Pagination\LengthAwarePaginator
-     */
-    public function paginate($perPage = null, $columns = ['*'])
-    {
-        $this->query->addSelect($this->getSelectColumns($columns));
-
-        return $this->query->paginate($perPage, $columns);
-    }
-
-    /**
-     * Get the key name of the parent model.
-     *
-     * @return string
-     */
-    protected function getQualifiedParentKeyName()
-    {
-        return $this->parentMap->getQualifiedKeyName();
-    }
-
-    /**
-     * Get the key for comparing against the parent key in "has" query.
-     *
-     * @return string
-     */
-    public function getHasCompareKey()
-    {
-        return $this->farParentMap->getQualifiedKeyName();
-    }
+	/**
+	 * The distance parent Entity instance.
+	 *
+	 * @var \Analogue\ORM\Entity
+	 */
+	protected $farParent;
+
+	/**
+	 * The far parent map instance
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $farParentMap;
+
+	/**
+	 * The near key on the relationship.
+	 *
+	 * @var string
+	 */
+	protected $firstKey;
+
+	/**
+	 * The far key on the relationship.
+	 *
+	 * @var string
+	 */
+	protected $secondKey;
+
+	/**
+	 * Create a new has many relationship instance.
+	 *
+	 * @param Mapper                  $mapper
+	 * @param \Analogue\ORM\Mappable  $farParent
+	 * @param \Analogue\ORM\EntityMap $parentMap
+	 * @param string                  $firstKey
+	 * @param string                  $secondKey
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 */
+	public function __construct(Mapper $mapper, $farParent, $parentMap, $firstKey, $secondKey)
+	{
+		$this->firstKey = $firstKey;
+		$this->secondKey = $secondKey;
+		$this->farParent = $farParent;
+
+		$this->farParentMap = $this->relatedMapper->getManager()->mapper($farParent)->getEntityMap();
+
+		$parentInstance = $this->relatedMapper->getManager()->mapper($parentMap->getClass())->newInstance();
+
+		parent::__construct($mapper, $parentInstance);
+	}
+
+	/**
+	 * @param $related
+	 * @return mixed
+	 */
+	public function attachTo($related)
+	{
+		// N/A
+	}
+
+	/**
+	 * @param $related
+	 * @return mixed
+	 */
+	public function detachFrom($related)
+	{
+		// N/A
+	}
+
+	/**
+	 * Set the base constraints on the relation query.
+	 *
+	 * @return void
+	 */
+	public function addConstraints()
+	{
+		$parentTable = $this->parentMap->getTable();
+
+		$this->setJoin();
+
+		if (static::$constraints) {
+			$farParentKeyName = $this->farParentMap->getKeyName();
+
+			$this->query->where(
+				$parentTable . '.' . $this->firstKey,
+				'=',
+				$this->farParent->getEntityAttribute($farParentKeyName)
+			);
+		}
+	}
+
+	/**
+	 * Add the constraints for a relationship count query.
+	 *
+	 * @param  Query $query
+	 * @param  Query $parent
+	 * @return Query
+	 */
+	public function getRelationCountQuery(Query $query, Query $parent)
+	{
+		$parentTable = $this->parentMap->getTable();
+
+		$this->setJoin($query);
+
+		$query->select(new Expression('count(*)'));
+
+		$key = $this->wrap($parentTable . '.' . $this->firstKey);
+
+		return $query->where($this->getHasCompareKey(), '=', new Expression($key));
+	}
+
+	/**
+	 * Set the join clause on the query.
+	 *
+	 * @param  null|Query $query
+	 * @return void
+	 */
+	protected function setJoin(Query $query = null)
+	{
+		$query = $query ?: $this->query;
+
+		$foreignKey = $this->relatedMap->getTable() . '.' . $this->secondKey;
+
+		$query->join($this->parentMap->getTable(), $this->getQualifiedParentKeyName(), '=', $foreignKey);
+	}
+
+	/**
+	 * Set the constraints for an eager load of the relation.
+	 *
+	 * @param  array $entities
+	 * @return void
+	 */
+	public function addEagerConstraints(array $entities)
+	{
+		$table = $this->parentMap->getTable();
+
+		$this->query->whereIn($table . '.' . $this->firstKey, $this->getKeys($entities));
+	}
+
+	/**
+	 * Initialize the relation on a set of entities.
+	 *
+	 * @param  \Analogue\ORM\Entity[] $entities
+	 * @param  string                 $relation
+	 * @return \Analogue\ORM\Entity[]
+	 */
+	public function initRelation(array $entities, $relation)
+	{
+		foreach ($entities as $entity) {
+			$entity->setEntityAttribute($relation, $this->relatedMap->newCollection());
+		}
+
+		return $entities;
+	}
+
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param  \Analogue\ORM\Entity[] $entities
+	 * @param  EntityCollection       $results
+	 * @param  string                 $relation
+	 * @return \Analogue\ORM\Entity[]
+	 */
+	public function match(array $entities, EntityCollection $results, $relation)
+	{
+		$dictionary = $this->buildDictionary($results);
+
+		$relatedKey = $this->relatedMap->getKeyName();
+
+		$cache = $this->parentMapper->getEntityCache();
+
+		// Once we have the dictionary we can simply spin through the parent entities to
+		// link them up with their children using the keyed dictionary to make the
+		// matching very convenient and easy work. Then we'll just return them.
+		foreach ($entities as $entity) {
+			$key = $entity->getEntityAttribute($relatedKey);
+
+			if (isset($dictionary[$key])) {
+				$value = $this->relatedMap->newCollection($dictionary[$key]);
+
+				$entity->setEntityAttribute($relation, $value);
+
+				$cache->cacheLoadedRelationResult($entity, $relation, $value, $this);
+			}
+		}
+
+		return $entities;
+	}
+
+	/**
+	 * Build model dictionary keyed by the relation's foreign key.
+	 *
+	 * @param  EntityCollection $results
+	 * @return array
+	 */
+	protected function buildDictionary(EntityCollection $results)
+	{
+		$dictionary = [];
+
+		$foreign = $this->firstKey;
+
+		// First we will create a dictionary of entities keyed by the foreign key of the
+		// relationship as this will allow us to quickly access all of the related
+		// entities without having to do nested looping which will be quite slow.
+		foreach ($results as $result) {
+			$dictionary[$result->{$foreign}][] = $result;
+		}
+
+		return $dictionary;
+	}
+
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @param  $relation
+	 * @return EntityCollection
+	 */
+	public function getResults($relation)
+	{
+		$results = $this->query->get();
+
+		$this->cacheRelation($results, $relation);
+
+		return $results;
+	}
+
+	/**
+	 * Execute the query as a "select" statement.
+	 *
+	 * @param  array $columns
+	 * @return EntityCollection
+	 */
+	public function get($columns = ['*'])
+	{
+		// 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
+		// entities with the result of those columns as a separate model relation.
+		$select = $this->getSelectColumns($columns);
+
+		$entities = $this->query->addSelect($select)->getEntities();
+
+		// If we actually found entities we will also eager load any relationships that
+		// have been specified as needing to be eager loaded. This will solve the
+		// n + 1 query problem for the developer and also increase performance.
+		if (count($entities) > 0) {
+			$entities = $this->query->eagerLoadRelations($entities);
+		}
+
+		return $this->relatedMap->newCollection($entities);
+	}
+
+	/**
+	 * Set the select clause for the relation query.
+	 *
+	 * @param  array $columns
+	 * @return BelongsToMany
+	 */
+	protected function getSelectColumns(array $columns = ['*'])
+	{
+		if ($columns == ['*']) {
+			$columns = [$this->relatedMap->getTable() . '.*'];
+		}
+
+		return array_merge($columns, [$this->parentMap->getTable() . '.' . $this->firstKey]);
+	}
+
+	/**
+	 * Get a paginator for the "select" statement.
+	 *
+	 * @param  int   $perPage
+	 * @param  array $columns
+	 * @return \Illuminate\Pagination\LengthAwarePaginator
+	 */
+	public function paginate($perPage = null, $columns = ['*'])
+	{
+		$this->query->addSelect($this->getSelectColumns($columns));
+
+		return $this->query->paginate($perPage, $columns);
+	}
+
+	/**
+	 * Get the key name of the parent model.
+	 *
+	 * @return string
+	 */
+	protected function getQualifiedParentKeyName()
+	{
+		return $this->parentMap->getQualifiedKeyName();
+	}
+
+	/**
+	 * Get the key for comparing against the parent key in "has" query.
+	 *
+	 * @return string
+	 */
+	public function getHasCompareKey()
+	{
+		return $this->farParentMap->getQualifiedKeyName();
+	}
 }

Spacing +6 added lines, -6 removed lines

@@ -93,7 +93,7 @@ 
             $farParentKeyName = $this->farParentMap->getKeyName();
 
             $this->query->where(
-                $parentTable . '.' . $this->firstKey,
+                $parentTable.'.'.$this->firstKey,
                 '=',
                 $this->farParent->getEntityAttribute($farParentKeyName)
             );
@@ -115,7 +115,7 @@ 
 
         $query->select(new Expression('count(*)'));
 
-        $key = $this->wrap($parentTable . '.' . $this->firstKey);
+        $key = $this->wrap($parentTable.'.'.$this->firstKey);
 
         return $query->where($this->getHasCompareKey(), '=', new Expression($key));
     }
@@ -130,7 +130,7 @@ 
     {
         $query = $query ?: $this->query;
 
-        $foreignKey = $this->relatedMap->getTable() . '.' . $this->secondKey;
+        $foreignKey = $this->relatedMap->getTable().'.'.$this->secondKey;
 
         $query->join($this->parentMap->getTable(), $this->getQualifiedParentKeyName(), '=', $foreignKey);
     }
@@ -145,7 +145,7 @@ 
     {
         $table = $this->parentMap->getTable();
 
-        $this->query->whereIn($table . '.' . $this->firstKey, $this->getKeys($entities));
+        $this->query->whereIn($table.'.'.$this->firstKey, $this->getKeys($entities));
     }
 
     /**
@@ -269,10 +269,10 @@ 
     protected function getSelectColumns(array $columns = ['*'])
     {
         if ($columns == ['*']) {
-            $columns = [$this->relatedMap->getTable() . '.*'];
+            $columns = [$this->relatedMap->getTable().'.*'];
         }
 
-        return array_merge($columns, [$this->parentMap->getTable() . '.' . $this->firstKey]);
+        return array_merge($columns, [$this->parentMap->getTable().'.'.$this->firstKey]);
     }
 
     /**