analogueorm / analogue

src/Relationships/HasOneOrMany.php

Spacing +1 added lines, -1 removed lines

@@ -193,7 +193,7 @@
         // 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.
-        return array_map(function ($result) use ($dictionary, $cache, $type, $relation, $host) {
+        return array_map(function($result) use ($dictionary, $cache, $type, $relation, $host) {
             $key = $result[$host->localKey];
 
             if (isset($dictionary[$key])) {

Indentation +304 added lines, -304 removed lines

@@ -7,308 +7,308 @@
 
 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 $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 $results
-     *
-     * @return void
-     */
-    public function addEagerConstraints(array $results)
-    {
-        $this->query->whereIn($this->foreignKey, $this->getKeysFromResults($results, $this->localKey));
-    }
-
-    /**
-     * Match the eagerly loaded relationship to the current result set.
-     *
-     * @param array  $results
-     * @param string $relation
-     *
-     * @return array
-     */
-    public function matchOne(array $results, $relation)
-    {
-        return $this->matchOneOrMany($results, $relation, 'one');
-    }
-
-    /**
-     * Match the eagerly loaded results to their many parents.
-     *
-     * @param array  $results
-     * @param string $relation
-     *
-     * @return array
-     */
-    public function matchMany(array $results, $relation)
-    {
-        return $this->matchOneOrMany($results, $relation, 'many');
-    }
-
-    /**
-     * Match the eagerly loaded results to their many parents.
-     *
-     * @param array  $results
-     * @param string $relation
-     * @param string $type
-     *
-     * @return array
-     */
-    protected function matchOneOrMany(array $results, $relation, $type)
-    {
-        $entities = $this->getEager();
-
-        $dictionary = $this->buildDictionary($entities);
-
-        $cache = $this->parentMapper->getEntityCache();
-
-        $host = $this;
-
-        // 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.
-        return array_map(function ($result) use ($dictionary, $cache, $type, $relation, $host) {
-            $key = $result[$host->localKey];
-
-            if (isset($dictionary[$key])) {
-                $value = $host->getRelationValue($dictionary, $key, $type);
-
-                $result[$relation] = $value;
-
-                // TODO : Refactor This
-                $cache->cacheLoadedRelationResult($key, $relation, $value, $this);
-            } else {
-                $result[$relation] = $type === 'many' ? $this->relatedMap->newCollection() : null;
-            }
-
-            return $result;
-        }, $results);
-    }
-
-    /**
-     * 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 $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 $results
+	 *
+	 * @return void
+	 */
+	public function addEagerConstraints(array $results)
+	{
+		$this->query->whereIn($this->foreignKey, $this->getKeysFromResults($results, $this->localKey));
+	}
+
+	/**
+	 * Match the eagerly loaded relationship to the current result set.
+	 *
+	 * @param array  $results
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	public function matchOne(array $results, $relation)
+	{
+		return $this->matchOneOrMany($results, $relation, 'one');
+	}
+
+	/**
+	 * Match the eagerly loaded results to their many parents.
+	 *
+	 * @param array  $results
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	public function matchMany(array $results, $relation)
+	{
+		return $this->matchOneOrMany($results, $relation, 'many');
+	}
+
+	/**
+	 * Match the eagerly loaded results to their many parents.
+	 *
+	 * @param array  $results
+	 * @param string $relation
+	 * @param string $type
+	 *
+	 * @return array
+	 */
+	protected function matchOneOrMany(array $results, $relation, $type)
+	{
+		$entities = $this->getEager();
+
+		$dictionary = $this->buildDictionary($entities);
+
+		$cache = $this->parentMapper->getEntityCache();
+
+		$host = $this;
+
+		// 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.
+		return array_map(function ($result) use ($dictionary, $cache, $type, $relation, $host) {
+			$key = $result[$host->localKey];
+
+			if (isset($dictionary[$key])) {
+				$value = $host->getRelationValue($dictionary, $key, $type);
+
+				$result[$relation] = $value;
+
+				// TODO : Refactor This
+				$cache->cacheLoadedRelationResult($key, $relation, $value, $this);
+			} else {
+				$result[$relation] = $type === 'many' ? $this->relatedMap->newCollection() : null;
+			}
+
+			return $result;
+		}, $results);
+	}
+
+	/**
+	 * 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()];
+	}
 }

src/Relationships/HasManyThrough.php

Spacing +1 added lines, -1 removed lines

@@ -156,7 +156,7 @@
         // 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.
-        return array_map(function ($result) use ($relation, $relatedKey, $dictionary, $cache, $host) {
+        return array_map(function($result) use ($relation, $relatedKey, $dictionary, $cache, $host) {
             $key = $result[$relatedKey];
 
             if (isset($dictionary[$key])) {

Indentation +290 added lines, -290 removed lines

@@ -9,294 +9,294 @@
 
 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 = $mapper->getManager()->mapper($farParent)->getEntityMap();
-        $parentInstance = $mapper->getManager()->mapper($parentMap->getClass())->newInstance();
-
-        parent::__construct($mapper, $parentInstance);
-    }
-
-    /**
-     * 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 $results
-     *
-     * @return void
-     */
-    public function addEagerConstraints(array $results)
-    {
-        $table = $this->parentMap->getTable();
-
-        $this->query->whereIn($table.'.'.$this->firstKey, $this->getKeysFromResults($results));
-    }
-
-    /**
-     * Match eagerly loaded relationship to a result set.
-     *
-     * @param array  $results
-     * @param string $relation
-     *
-     * @return array
-     */
-    public function match(array $results, $relation)
-    {
-        $entities = $this->getEager();
-
-        $dictionary = $this->buildDictionary($entities);
-
-        $relatedKey = $this->relatedMap->getKeyName();
-
-        $cache = $this->parentMapper->getEntityCache();
-
-        $host = $this;
-
-        // 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.
-        return array_map(function ($result) use ($relation, $relatedKey, $dictionary, $cache, $host) {
-            $key = $result[$relatedKey];
-
-            if (isset($dictionary[$key])) {
-                $value = $host->relatedMap->newCollection($dictionary[$key]);
-
-                $result[$relation] = $value;
-
-                $cache->cacheLoadedRelationResult($key, $relation, $value, $this);
-            }
-
-            return $result;
-        }, $results);
-    }
-
-    /**
-     * 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();
-    }
-
-    /**
-     * Run synchronization content if needed by the
-     * relation type.
-     *
-     * @param array $entities
-     *
-     * @return void
-     */
-    public function sync(array $entities)
-    {
-        // N/A
-    }
+	/**
+	 * 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 = $mapper->getManager()->mapper($farParent)->getEntityMap();
+		$parentInstance = $mapper->getManager()->mapper($parentMap->getClass())->newInstance();
+
+		parent::__construct($mapper, $parentInstance);
+	}
+
+	/**
+	 * 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 $results
+	 *
+	 * @return void
+	 */
+	public function addEagerConstraints(array $results)
+	{
+		$table = $this->parentMap->getTable();
+
+		$this->query->whereIn($table.'.'.$this->firstKey, $this->getKeysFromResults($results));
+	}
+
+	/**
+	 * Match eagerly loaded relationship to a result set.
+	 *
+	 * @param array  $results
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	public function match(array $results, $relation)
+	{
+		$entities = $this->getEager();
+
+		$dictionary = $this->buildDictionary($entities);
+
+		$relatedKey = $this->relatedMap->getKeyName();
+
+		$cache = $this->parentMapper->getEntityCache();
+
+		$host = $this;
+
+		// 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.
+		return array_map(function ($result) use ($relation, $relatedKey, $dictionary, $cache, $host) {
+			$key = $result[$relatedKey];
+
+			if (isset($dictionary[$key])) {
+				$value = $host->relatedMap->newCollection($dictionary[$key]);
+
+				$result[$relation] = $value;
+
+				$cache->cacheLoadedRelationResult($key, $relation, $value, $this);
+			}
+
+			return $result;
+		}, $results);
+	}
+
+	/**
+	 * 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();
+	}
+
+	/**
+	 * Run synchronization content if needed by the
+	 * relation type.
+	 *
+	 * @param array $entities
+	 *
+	 * @return void
+	 */
+	public function sync(array $entities)
+	{
+		// N/A
+	}
 }

src/Relationships/MorphMany.php

Indentation +25 added lines, -25 removed lines

@@ -4,32 +4,32 @@
 
 class MorphMany extends MorphOneOrMany
 {
-    /**
-     * Get the results of the relationship.
-     *
-     * @param  $relation
-     *
-     * @return mixed
-     */
-    public function getResults($relation)
-    {
-        $results = $this->query->get();
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @param  $relation
+	 *
+	 * @return mixed
+	 */
+	public function getResults($relation)
+	{
+		$results = $this->query->get();
 
-        $this->cacheRelation($results, $relation);
+		$this->cacheRelation($results, $relation);
 
-        return $results;
-    }
+		return $results;
+	}
 
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param array  $results
-     * @param string $relation
-     *
-     * @return array
-     */
-    public function match(array $results, $relation)
-    {
-        return $this->matchMany($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->matchMany($results, $relation);
+	}
 }

src/Relationships/MorphOneOrMany.php

Indentation +118 added lines, -118 removed lines

@@ -7,122 +7,122 @@
 
 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 $results
-     *
-     * @return void
-     */
-    public function addEagerConstraints(array $results)
-    {
-        parent::addEagerConstraints($results);
-
-        $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 $results
+	 *
+	 * @return void
+	 */
+	public function addEagerConstraints(array $results)
+	{
+		parent::addEagerConstraints($results);
+
+		$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/Drivers/IlluminateQueryBuilder.php

Indentation +1 added lines, -1 removed lines

@@ -12,5 +12,5 @@
  */
 class IlluminateQueryBuilder extends Builder
 {
-    //
+	//
 }

src/AnalogueFacade.php

Indentation +9 added lines, -9 removed lines

@@ -9,13 +9,13 @@
  */
 class AnalogueFacade extends Facade
 {
-    /**
-     * Get the registered name of the component.
-     *
-     * @return string
-     */
-    protected static function getFacadeAccessor()
-    {
-        return 'analogue';
-    }
+	/**
+	 * Get the registered name of the component.
+	 *
+	 * @return string
+	 */
+	protected static function getFacadeAccessor()
+	{
+		return 'analogue';
+	}
 }

src/Relationships/MorphTo.php

Spacing +1 added lines, -1 removed lines

@@ -172,7 +172,7 @@
     {
         $foreign = $this->foreignKey;
 
-        return BaseCollection::make($this->dictionary[$type])->map(function ($entities) use ($foreign) {
+        return BaseCollection::make($this->dictionary[$type])->map(function($entities) use ($foreign) {
             return head($entities)->{$foreign};
         })->unique();
     }

Indentation +215 added lines, -215 removed lines

@@ -8,219 +8,219 @@
 
 class MorphTo extends BelongsTo
 {
-    /**
-     * The type of the polymorphic relation.
-     *
-     * @var string
-     */
-    protected $morphType;
-
-    /**
-     * The entities whose relations are being eager loaded.
-     *
-     * @var EntityCollection
-     */
-    protected $entities;
-
-    /**
-     * All of the result sets keyed by ID.
-     *
-     * @var array
-     */
-    protected $dictionary = [];
-
-    /**
-     * Indicates if soft-deleted model instances should be fetched.
-     *
-     * @var bool
-     */
-    protected $withTrashed = false;
-
-    /**
-     * Create a new belongs to relationship instance.
-     *
-     * @param Mapper                 $mapper
-     * @param \Analogue\ORM\Mappable $parent
-     * @param string                 $foreignKey
-     * @param string                 $otherKey
-     * @param string                 $type
-     * @param string                 $relation
-     */
-    public function __construct(Mapper $mapper, $parent, $foreignKey, $otherKey, $type, $relation)
-    {
-        $this->morphType = $type;
-
-        parent::__construct($mapper, $parent, $foreignKey, $otherKey, $relation);
-    }
-
-    /**
-     * Set the constraints for an eager load of the relation.
-     *
-     * @param array $results
-     *
-     * @return void
-     */
-    public function addEagerConstraints(array $results)
-    {
-        $this->buildDictionary($results);
-    }
-
-    /**
-     * Build a dictionary with the entities.
-     *
-     * @param array $results
-     *
-     * @return void
-     */
-    protected function buildDictionary($results)
-    {
-        foreach ($results as $result) {
-            if ($result[$this->morphType]) {
-                $this->dictionary[$result[$this->morphType]][$result[$this->foreignKey]] = $result;
-            }
-        }
-    }
-
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param array  $results
-     * @param string $relation
-     *
-     * @return array
-     */
-    public function match(array $results, $relation)
-    {
-        return $results;
-    }
-
-    /**
-     * Get the results of the relationship.
-     *
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     *
-     * @return EntityCollection
-     */
-    public function getEager()
-    {
-        foreach (array_keys($this->dictionary) as $type) {
-            $this->matchToMorphParents($type, $this->getResultsByType($type));
-        }
-
-        return $this->entities;
-    }
-
-    /**
-     * Match the results for a given type to their parents.
-     *
-     * @param string           $type
-     * @param EntityCollection $results
-     *
-     * @return void
-     */
-    protected function matchToMorphParents($type, EntityCollection $results)
-    {
-        $mapper = $this->relatedMapper->getManager()->mapper($type);
-        $keyName = $mapper->getEntityMap()->getKeyName();
-
-        foreach ($results as $result) {
-            $key = $result[$keyName];
-
-            if (isset($this->dictionary[$type][$key])) {
-                foreach ($this->dictionary[$type][$key] as $result) {
-                    $result[$this->relation] = $result;
-                }
-            }
-        }
-    }
-
-    /**
-     * Get all of the relation results for a type.
-     *
-     * @param string $type
-     *
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     *
-     * @return \Illuminate\Support\Collection
-     */
-    protected function getResultsByType($type)
-    {
-        $mapper = $this->relatedMapper->getManager()->mapper($type);
-
-        $key = $mapper->getEntityMap()->getKeyName();
-
-        $query = $mapper->getQuery();
-
-        return $query->whereIn($key, $this->gatherKeysByType($type)->all())->get();
-    }
-
-    /**
-     * Gather all of the foreign keys for a given type.
-     *
-     * @param string $type
-     *
-     * @return BaseCollection
-     */
-    protected function gatherKeysByType($type)
-    {
-        $foreign = $this->foreignKey;
-
-        return BaseCollection::make($this->dictionary[$type])->map(function ($entities) use ($foreign) {
-            return head($entities)->{$foreign};
-        })->unique();
-    }
-
-    /**
-     * Associate the model instance to the given parent.
-     *
-     * @param mixed $entity
-     *
-     * @return void
-     */
-    public function associate($entity)
-    {
-        // 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, $entity->getEntityAttribute($this->otherKey));
-        //
-        // Instead, we'll just add the object to the Entity's attribute
-
-        $this->parent->setEntityAttribute($this->relation, $entity->getEntityObject());
-    }
-
-    /**
-     * 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),
-                $this->morphType => $wrapper->getMap()->getMorphClass(),
-            ];
-        } else {
-            return [$foreignKey => null];
-        }
-    }
-
-    /**
-     * Get the dictionary used by the relationship.
-     *
-     * @return array
-     */
-    public function getDictionary()
-    {
-        return $this->dictionary;
-    }
+	/**
+	 * The type of the polymorphic relation.
+	 *
+	 * @var string
+	 */
+	protected $morphType;
+
+	/**
+	 * The entities whose relations are being eager loaded.
+	 *
+	 * @var EntityCollection
+	 */
+	protected $entities;
+
+	/**
+	 * All of the result sets keyed by ID.
+	 *
+	 * @var array
+	 */
+	protected $dictionary = [];
+
+	/**
+	 * Indicates if soft-deleted model instances should be fetched.
+	 *
+	 * @var bool
+	 */
+	protected $withTrashed = false;
+
+	/**
+	 * Create a new belongs to relationship instance.
+	 *
+	 * @param Mapper                 $mapper
+	 * @param \Analogue\ORM\Mappable $parent
+	 * @param string                 $foreignKey
+	 * @param string                 $otherKey
+	 * @param string                 $type
+	 * @param string                 $relation
+	 */
+	public function __construct(Mapper $mapper, $parent, $foreignKey, $otherKey, $type, $relation)
+	{
+		$this->morphType = $type;
+
+		parent::__construct($mapper, $parent, $foreignKey, $otherKey, $relation);
+	}
+
+	/**
+	 * Set the constraints for an eager load of the relation.
+	 *
+	 * @param array $results
+	 *
+	 * @return void
+	 */
+	public function addEagerConstraints(array $results)
+	{
+		$this->buildDictionary($results);
+	}
+
+	/**
+	 * Build a dictionary with the entities.
+	 *
+	 * @param array $results
+	 *
+	 * @return void
+	 */
+	protected function buildDictionary($results)
+	{
+		foreach ($results as $result) {
+			if ($result[$this->morphType]) {
+				$this->dictionary[$result[$this->morphType]][$result[$this->foreignKey]] = $result;
+			}
+		}
+	}
+
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param array  $results
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	public function match(array $results, $relation)
+	{
+		return $results;
+	}
+
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 *
+	 * @return EntityCollection
+	 */
+	public function getEager()
+	{
+		foreach (array_keys($this->dictionary) as $type) {
+			$this->matchToMorphParents($type, $this->getResultsByType($type));
+		}
+
+		return $this->entities;
+	}
+
+	/**
+	 * Match the results for a given type to their parents.
+	 *
+	 * @param string           $type
+	 * @param EntityCollection $results
+	 *
+	 * @return void
+	 */
+	protected function matchToMorphParents($type, EntityCollection $results)
+	{
+		$mapper = $this->relatedMapper->getManager()->mapper($type);
+		$keyName = $mapper->getEntityMap()->getKeyName();
+
+		foreach ($results as $result) {
+			$key = $result[$keyName];
+
+			if (isset($this->dictionary[$type][$key])) {
+				foreach ($this->dictionary[$type][$key] as $result) {
+					$result[$this->relation] = $result;
+				}
+			}
+		}
+	}
+
+	/**
+	 * Get all of the relation results for a type.
+	 *
+	 * @param string $type
+	 *
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 *
+	 * @return \Illuminate\Support\Collection
+	 */
+	protected function getResultsByType($type)
+	{
+		$mapper = $this->relatedMapper->getManager()->mapper($type);
+
+		$key = $mapper->getEntityMap()->getKeyName();
+
+		$query = $mapper->getQuery();
+
+		return $query->whereIn($key, $this->gatherKeysByType($type)->all())->get();
+	}
+
+	/**
+	 * Gather all of the foreign keys for a given type.
+	 *
+	 * @param string $type
+	 *
+	 * @return BaseCollection
+	 */
+	protected function gatherKeysByType($type)
+	{
+		$foreign = $this->foreignKey;
+
+		return BaseCollection::make($this->dictionary[$type])->map(function ($entities) use ($foreign) {
+			return head($entities)->{$foreign};
+		})->unique();
+	}
+
+	/**
+	 * Associate the model instance to the given parent.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @return void
+	 */
+	public function associate($entity)
+	{
+		// 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, $entity->getEntityAttribute($this->otherKey));
+		//
+		// Instead, we'll just add the object to the Entity's attribute
+
+		$this->parent->setEntityAttribute($this->relation, $entity->getEntityObject());
+	}
+
+	/**
+	 * 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),
+				$this->morphType => $wrapper->getMap()->getMorphClass(),
+			];
+		} else {
+			return [$foreignKey => null];
+		}
+	}
+
+	/**
+	 * Get the dictionary used by the relationship.
+	 *
+	 * @return array
+	 */
+	public function getDictionary()
+	{
+		return $this->dictionary;
+	}
 }

src/System/Mapper.php

Spacing +2 added lines, -2 removed lines

@@ -114,7 +114,7 @@ 
         }
 
         // First, we'll cast every single result to array
-        $results = array_map(function ($item) {
+        $results = array_map(function($item) {
             return (array) $item;
         }, $results);
 
@@ -394,7 +394,7 @@ 
      */
     public function getGlobalScope($scope)
     {
-        return array_first($this->globalScopes, function ($key, $value) use ($scope) {
+        return array_first($this->globalScopes, function($key, $value) use ($scope) {
             return $scope instanceof $value;
         });
     }

Doc Comments +1 added lines, -1 removed lines

@@ -122,7 +122,7 @@
     /**
      * Map results to a Collection.
      *
-     * @param array|Collection $results
+     * @param Collection $results
      * @param array            $eagerLoads
      *
      * @return Collection

Indentation +689 added lines, -689 removed lines

@@ -25,696 +25,696 @@
  */
 class Mapper
 {
-    /**
-     * The Manager instance.
-     *
-     * @var \Analogue\ORM\System\Manager
-     */
-    protected $manager;
-
-    /**
-     * Instance of EntityMapper Object.
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * The instance of db adapter.
-     *
-     * @var \Analogue\ORM\Drivers\DBAdapter
-     */
-    protected $adapter;
-
-    /**
-     * Event dispatcher instance.
-     *
-     * @var \Illuminate\Contracts\Events\Dispatcher
-     */
-    protected $dispatcher;
-
-    /**
-     * Entity Cache.
-     *
-     * @var \Analogue\ORM\System\Cache\AttributeCache
-     */
-    protected $cache;
-
-    /**
-     * Entity instances Object cache.
-     *
-     * @var \Analogue\ORM\System\Cache\InstanceCache
-     */
-    protected $instances;
-
-    /**
-     * Global scopes.
-     *
-     * @var array
-     */
-    protected $globalScopes = [];
-
-    /**
-     * Custom Commands.
-     *
-     * @var array
-     */
-    protected $customCommands = [];
-
-    /**
-     * Available Analogue Events.
-     *
-     * @var array
-     */
-    protected $events = [
-        'initializing' => \Analogue\ORM\Events\Initializing::class,
-        'initialized'  => \Analogue\ORM\Events\Initialized::class,
-        'storing'      => \Analogue\ORM\Events\Storing::class,
-        'stored'       => \Analogue\ORM\Events\Stored::class,
-        'creating'     => \Analogue\ORM\Events\Creating::class,
-        'created'      => \Analogue\ORM\Events\Created::class,
-        'updating'     => \Analogue\ORM\Events\Updating::class,
-        'updated'      => \Analogue\ORM\Events\Updated::class,
-        'deleting'     => \Analogue\ORM\Events\Deleting::class,
-        'deleted'      => \Analogue\ORM\Events\Deleted::class,
-    ];
-
-    /**
-     * @param EntityMap  $entityMap
-     * @param DBAdapter  $adapter
-     * @param Dispatcher $dispatcher
-     * @param Manager    $manager
-     */
-    public function __construct(EntityMap $entityMap, DBAdapter $adapter, Dispatcher $dispatcher, Manager $manager)
-    {
-        $this->entityMap = $entityMap;
-
-        $this->adapter = $adapter;
-
-        $this->dispatcher = $dispatcher;
-
-        $this->manager = $manager;
-
-        $this->cache = new AttributeCache($entityMap);
-        $this->instances = new InstanceCache($entityMap->getClass());
-    }
-
-    /**
-     * Map results to a Collection.
-     *
-     * @param array|Collection $results
-     * @param array            $eagerLoads
-     *
-     * @return Collection
-     */
-    public function map($results, array $eagerLoads = []) : Collection
-    {
-        $builder = new ResultBuilder($this);
-
-        if ($results instanceof Collection) {
-            // Get underlying collection array
-            $results = $results->all();
-        }
-
-        if (!is_array($results)) {
-            throw new InvalidArgumentException("'results' should be an array or collection.");
-        }
-
-        // First, we'll cast every single result to array
-        $results = array_map(function ($item) {
-            return (array) $item;
-        }, $results);
-
-        // Then, we'll pass the results to the Driver's provided transformer, so
-        // any DB specific value can be casted before hydration
-        $results = $this->adapter->fromDatabase($results);
-
-        // Then, we'll cache every single results as raw attributes, before
-        // adding relationships, which will be cached when the relationship's
-        // query takes place.
-        //$this->getEntityCache()->add($results);
-
-        $entities = $builder->build($results, $eagerLoads);
-
-        return $this->entityMap->newCollection($entities);
-    }
-
-    /**
-     * Return all records for a mapped object.
-     *
-     * @return \Illuminate\Support\Collection
-     */
-    public function all()
-    {
-        return $this->query()->get();
-    }
-
-    /**
-     * Persist an entity or an entity collection into the database.
-     *
-     * @param Mappable|\Traversable|array $entity
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return Mappable|\Traversable|array
-     */
-    public function store($entity)
-    {
-        if ($this->manager->isTraversable($entity)) {
-            return $this->storeCollection($entity);
-        } else {
-            return $this->storeEntity($entity);
-        }
-    }
-
-    /**
-     * Store an entity collection inside a single DB Transaction.
-     *
-     * @param \Traversable|array $entities
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return \Traversable|array
-     */
-    protected function storeCollection($entities)
-    {
-        $this->adapter->beginTransaction();
-
-        foreach ($entities as $entity) {
-            $this->storeEntity($entity);
-        }
-
-        $this->adapter->commit();
-
-        return $entities;
-    }
-
-    /**
-     * Store a single entity into the database.
-     *
-     * @param Mappable $entity
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\Entity
-     */
-    protected function storeEntity($entity)
-    {
-        $this->checkEntityType($entity);
-
-        $store = new Store($this->aggregate($entity), $this->newQueryBuilder());
-
-        return $store->execute();
-    }
-
-    /**
-     * Check that the entity correspond to the current mapper.
-     *
-     * @param mixed $entity
-     *
-     * @throws InvalidArgumentException
-     *
-     * @return void
-     */
-    protected function checkEntityType($entity)
-    {
-        if (get_class($entity) != $this->entityMap->getClass() && !is_subclass_of($entity, $this->entityMap->getClass())) {
-            $expected = $this->entityMap->getClass();
-            $actual = get_class($entity);
-
-            throw new InvalidArgumentException("Expected : $expected, got $actual.");
-        }
-    }
-
-    /**
-     * Convert an entity into an aggregate root.
-     *
-     * @param mixed $entity
-     *
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\System\Aggregate
-     */
-    protected function aggregate($entity)
-    {
-        return new Aggregate($entity);
-    }
-
-    /**
-     * Get a the Underlying Query Builder.
-     *
-     * @return \Illuminate\Database\Query\Builder
-     */
-    public function newQueryBuilder()
-    {
-        return $this->adapter->getQuery();
-    }
-
-    /**
-     * Delete an entity or an entity collection from the database.
-     *
-     * @param  Mappable|\Traversable|array
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return \Traversable|array
-     */
-    public function delete($entity)
-    {
-        if ($this->manager->isTraversable($entity)) {
-            return $this->deleteCollection($entity);
-        } else {
-            $this->deleteEntity($entity);
-        }
-    }
-
-    /**
-     * Delete an Entity Collection inside a single db transaction.
-     *
-     * @param \Traversable|array $entities
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return \Traversable|array
-     */
-    protected function deleteCollection($entities)
-    {
-        $this->adapter->beginTransaction();
-
-        foreach ($entities as $entity) {
-            $this->deleteEntity($entity);
-        }
-
-        $this->adapter->commit();
-
-        return $entities;
-    }
-
-    /**
-     * Delete a single entity from the database.
-     *
-     * @param Mappable $entity
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return void
-     */
-    protected function deleteEntity($entity)
-    {
-        $this->checkEntityType($entity);
-
-        $delete = new Delete($this->aggregate($entity), $this->newQueryBuilder());
-
-        $delete->execute();
-    }
-
-    /**
-     * Return the entity map for this mapper.
-     *
-     * @return EntityMap
-     */
-    public function getEntityMap()
-    {
-        return $this->entityMap;
-    }
-
-    /**
-     * Get the entity cache for the current mapper.
-     *
-     * @return \Analogue\ORM\System\Cache\AttributeCache
-     */
-    public function getEntityCache() : AttributeCache
-    {
-        return $this->cache;
-    }
-
-    /**
-     * Get the instance cache for the current mapper.
-     *
-     * @return \Analogue\ORM\System\Cache\InstanceCache
-     */
-    public function getInstanceCache() : InstanceCache
-    {
-        return $this->instances;
-    }
-
-    /**
-     * Reset all caches within the mapper.
-     *
-     * @return void
-     */
-    public function clearCache()
-    {
-        $this->cache->clear();
-        $this->instances->clear();
-    }
-
-    /**
-     * Fire the given event for the entity.
-     *
-     * @param string               $event
-     * @param \Analogue\ORM\Entity $entity
-     * @param bool                 $halt
-     *
-     * @throws InvalidArgumentException
-     *
-     * @return mixed
-     */
-    public function fireEvent($event, $entity, $halt = true)
-    {
-        /*if ($entity instanceof Wrapper) {
+	/**
+	 * The Manager instance.
+	 *
+	 * @var \Analogue\ORM\System\Manager
+	 */
+	protected $manager;
+
+	/**
+	 * Instance of EntityMapper Object.
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * The instance of db adapter.
+	 *
+	 * @var \Analogue\ORM\Drivers\DBAdapter
+	 */
+	protected $adapter;
+
+	/**
+	 * Event dispatcher instance.
+	 *
+	 * @var \Illuminate\Contracts\Events\Dispatcher
+	 */
+	protected $dispatcher;
+
+	/**
+	 * Entity Cache.
+	 *
+	 * @var \Analogue\ORM\System\Cache\AttributeCache
+	 */
+	protected $cache;
+
+	/**
+	 * Entity instances Object cache.
+	 *
+	 * @var \Analogue\ORM\System\Cache\InstanceCache
+	 */
+	protected $instances;
+
+	/**
+	 * Global scopes.
+	 *
+	 * @var array
+	 */
+	protected $globalScopes = [];
+
+	/**
+	 * Custom Commands.
+	 *
+	 * @var array
+	 */
+	protected $customCommands = [];
+
+	/**
+	 * Available Analogue Events.
+	 *
+	 * @var array
+	 */
+	protected $events = [
+		'initializing' => \Analogue\ORM\Events\Initializing::class,
+		'initialized'  => \Analogue\ORM\Events\Initialized::class,
+		'storing'      => \Analogue\ORM\Events\Storing::class,
+		'stored'       => \Analogue\ORM\Events\Stored::class,
+		'creating'     => \Analogue\ORM\Events\Creating::class,
+		'created'      => \Analogue\ORM\Events\Created::class,
+		'updating'     => \Analogue\ORM\Events\Updating::class,
+		'updated'      => \Analogue\ORM\Events\Updated::class,
+		'deleting'     => \Analogue\ORM\Events\Deleting::class,
+		'deleted'      => \Analogue\ORM\Events\Deleted::class,
+	];
+
+	/**
+	 * @param EntityMap  $entityMap
+	 * @param DBAdapter  $adapter
+	 * @param Dispatcher $dispatcher
+	 * @param Manager    $manager
+	 */
+	public function __construct(EntityMap $entityMap, DBAdapter $adapter, Dispatcher $dispatcher, Manager $manager)
+	{
+		$this->entityMap = $entityMap;
+
+		$this->adapter = $adapter;
+
+		$this->dispatcher = $dispatcher;
+
+		$this->manager = $manager;
+
+		$this->cache = new AttributeCache($entityMap);
+		$this->instances = new InstanceCache($entityMap->getClass());
+	}
+
+	/**
+	 * Map results to a Collection.
+	 *
+	 * @param array|Collection $results
+	 * @param array            $eagerLoads
+	 *
+	 * @return Collection
+	 */
+	public function map($results, array $eagerLoads = []) : Collection
+	{
+		$builder = new ResultBuilder($this);
+
+		if ($results instanceof Collection) {
+			// Get underlying collection array
+			$results = $results->all();
+		}
+
+		if (!is_array($results)) {
+			throw new InvalidArgumentException("'results' should be an array or collection.");
+		}
+
+		// First, we'll cast every single result to array
+		$results = array_map(function ($item) {
+			return (array) $item;
+		}, $results);
+
+		// Then, we'll pass the results to the Driver's provided transformer, so
+		// any DB specific value can be casted before hydration
+		$results = $this->adapter->fromDatabase($results);
+
+		// Then, we'll cache every single results as raw attributes, before
+		// adding relationships, which will be cached when the relationship's
+		// query takes place.
+		//$this->getEntityCache()->add($results);
+
+		$entities = $builder->build($results, $eagerLoads);
+
+		return $this->entityMap->newCollection($entities);
+	}
+
+	/**
+	 * Return all records for a mapped object.
+	 *
+	 * @return \Illuminate\Support\Collection
+	 */
+	public function all()
+	{
+		return $this->query()->get();
+	}
+
+	/**
+	 * Persist an entity or an entity collection into the database.
+	 *
+	 * @param Mappable|\Traversable|array $entity
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return Mappable|\Traversable|array
+	 */
+	public function store($entity)
+	{
+		if ($this->manager->isTraversable($entity)) {
+			return $this->storeCollection($entity);
+		} else {
+			return $this->storeEntity($entity);
+		}
+	}
+
+	/**
+	 * Store an entity collection inside a single DB Transaction.
+	 *
+	 * @param \Traversable|array $entities
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return \Traversable|array
+	 */
+	protected function storeCollection($entities)
+	{
+		$this->adapter->beginTransaction();
+
+		foreach ($entities as $entity) {
+			$this->storeEntity($entity);
+		}
+
+		$this->adapter->commit();
+
+		return $entities;
+	}
+
+	/**
+	 * Store a single entity into the database.
+	 *
+	 * @param Mappable $entity
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\Entity
+	 */
+	protected function storeEntity($entity)
+	{
+		$this->checkEntityType($entity);
+
+		$store = new Store($this->aggregate($entity), $this->newQueryBuilder());
+
+		return $store->execute();
+	}
+
+	/**
+	 * Check that the entity correspond to the current mapper.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @throws InvalidArgumentException
+	 *
+	 * @return void
+	 */
+	protected function checkEntityType($entity)
+	{
+		if (get_class($entity) != $this->entityMap->getClass() && !is_subclass_of($entity, $this->entityMap->getClass())) {
+			$expected = $this->entityMap->getClass();
+			$actual = get_class($entity);
+
+			throw new InvalidArgumentException("Expected : $expected, got $actual.");
+		}
+	}
+
+	/**
+	 * Convert an entity into an aggregate root.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\System\Aggregate
+	 */
+	protected function aggregate($entity)
+	{
+		return new Aggregate($entity);
+	}
+
+	/**
+	 * Get a the Underlying Query Builder.
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	public function newQueryBuilder()
+	{
+		return $this->adapter->getQuery();
+	}
+
+	/**
+	 * Delete an entity or an entity collection from the database.
+	 *
+	 * @param  Mappable|\Traversable|array
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return \Traversable|array
+	 */
+	public function delete($entity)
+	{
+		if ($this->manager->isTraversable($entity)) {
+			return $this->deleteCollection($entity);
+		} else {
+			$this->deleteEntity($entity);
+		}
+	}
+
+	/**
+	 * Delete an Entity Collection inside a single db transaction.
+	 *
+	 * @param \Traversable|array $entities
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return \Traversable|array
+	 */
+	protected function deleteCollection($entities)
+	{
+		$this->adapter->beginTransaction();
+
+		foreach ($entities as $entity) {
+			$this->deleteEntity($entity);
+		}
+
+		$this->adapter->commit();
+
+		return $entities;
+	}
+
+	/**
+	 * Delete a single entity from the database.
+	 *
+	 * @param Mappable $entity
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return void
+	 */
+	protected function deleteEntity($entity)
+	{
+		$this->checkEntityType($entity);
+
+		$delete = new Delete($this->aggregate($entity), $this->newQueryBuilder());
+
+		$delete->execute();
+	}
+
+	/**
+	 * Return the entity map for this mapper.
+	 *
+	 * @return EntityMap
+	 */
+	public function getEntityMap()
+	{
+		return $this->entityMap;
+	}
+
+	/**
+	 * Get the entity cache for the current mapper.
+	 *
+	 * @return \Analogue\ORM\System\Cache\AttributeCache
+	 */
+	public function getEntityCache() : AttributeCache
+	{
+		return $this->cache;
+	}
+
+	/**
+	 * Get the instance cache for the current mapper.
+	 *
+	 * @return \Analogue\ORM\System\Cache\InstanceCache
+	 */
+	public function getInstanceCache() : InstanceCache
+	{
+		return $this->instances;
+	}
+
+	/**
+	 * Reset all caches within the mapper.
+	 *
+	 * @return void
+	 */
+	public function clearCache()
+	{
+		$this->cache->clear();
+		$this->instances->clear();
+	}
+
+	/**
+	 * Fire the given event for the entity.
+	 *
+	 * @param string               $event
+	 * @param \Analogue\ORM\Entity $entity
+	 * @param bool                 $halt
+	 *
+	 * @throws InvalidArgumentException
+	 *
+	 * @return mixed
+	 */
+	public function fireEvent($event, $entity, $halt = true)
+	{
+		/*if ($entity instanceof Wrapper) {
             throw new InvalidArgumentException('Fired Event with invalid Entity Object');
         }*/
 
-        $eventName = "analogue.{$event}.".$this->entityMap->getClass();
-
-        $method = $halt ? 'until' : 'fire';
-
-        if (!array_key_exists($event, $this->events)) {
-            throw new \LogicException("Analogue : Event $event doesn't exist");
-        }
-
-        $eventClass = $this->events[$event];
-        $event = new $eventClass($entity);
-
-        return $this->dispatcher->$method($eventName, $event);
-    }
-
-    /**
-     * Register an entity event with the dispatcher.
-     *
-     * @param string   $event
-     * @param \Closure $callback
-     *
-     * @return void
-     */
-    public function registerEvent($event, $callback)
-    {
-        $name = $this->entityMap->getClass();
-
-        $this->dispatcher->listen("analogue.{$event}.{$name}", $callback);
-    }
-
-    /**
-     * Add a global scope to this mapper query builder.
-     *
-     * @param ScopeInterface $scope
-     *
-     * @return void
-     */
-    public function addGlobalScope(ScopeInterface $scope)
-    {
-        $this->globalScopes[get_class($scope)] = $scope;
-    }
-
-    /**
-     * Determine if the mapper has a global scope.
-     *
-     * @param \Analogue\ORM\System\ScopeInterface $scope
-     *
-     * @return bool
-     */
-    public function hasGlobalScope($scope)
-    {
-        return !is_null($this->getGlobalScope($scope));
-    }
-
-    /**
-     * Get a global scope registered with the modal.
-     *
-     * @param \Analogue\ORM\System\ScopeInterface $scope
-     *
-     * @return \Analogue\ORM\System\ScopeInterface|null
-     */
-    public function getGlobalScope($scope)
-    {
-        return array_first($this->globalScopes, function ($key, $value) use ($scope) {
-            return $scope instanceof $value;
-        });
-    }
-
-    /**
-     * Get a new query instance without a given scope.
-     *
-     * @param \Analogue\ORM\System\ScopeInterface $scope
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function newQueryWithoutScope($scope)
-    {
-        $this->getGlobalScope($scope)->remove($query = $this->getQuery(), $this);
-
-        return $query;
-    }
-
-    /**
-     * Get the Analogue Query Builder for this instance.
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function getQuery()
-    {
-        $query = new Query($this, $this->adapter);
-
-        return $this->applyGlobalScopes($query);
-    }
-
-    /**
-     * Apply all of the global scopes to an Analogue Query builder.
-     *
-     * @param Query $query
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function applyGlobalScopes($query)
-    {
-        foreach ($this->getGlobalScopes() as $scope) {
-            $scope->apply($query, $this);
-        }
-
-        return $query;
-    }
-
-    /**
-     * Get the global scopes for this class instance.
-     *
-     * @return \Analogue\ORM\System\ScopeInterface
-     */
-    public function getGlobalScopes()
-    {
-        return $this->globalScopes;
-    }
-
-    /**
-     * Add a dynamic method that extends the mapper/repository.
-     *
-     * @param string $command
-     */
-    public function addCustomCommand($command)
-    {
-        $name = lcfirst(class_basename($command));
-
-        $this->customCommands[$name] = $command;
-    }
-
-    /**
-     * Create a new instance of the mapped entity class.
-     *
-     * @return mixed
-     */
-    public function newInstance()
-    {
-        $class = $this->entityMap->getClass();
-
-        if ($this->entityMap->useDependencyInjection()) {
-            return $this->newInstanceUsingDependencyInjection($class);
-        }
-
-        return $this->newInstanceUsingInstantiator($class);
-    }
-
-    /**
-     * Return a new object instance using dependency injection.
-     *
-     * @param string $class
-     *
-     * @throws ErrorException
-     *
-     * @return mixed
-     */
-    protected function newInstanceUsingDependencyInjection($class)
-    {
-        if (!class_exists(Container::class)) {
-            throw new ErrorException("Illuminate\Container\Container is required to use Dependency Injection");
-        }
-
-        return Container::getInstance()->make($class);
-    }
-
-    /**
-     * Return a new object instance using doctrine's instantiator.
-     *
-     * @param string $class
-     *
-     * @return mixed
-     */
-    protected function newInstanceUsingInstantiator($class)
-    {
-        $instantiator = new \Doctrine\Instantiator\Instantiator();
-
-        return $instantiator->instantiate($class);
-    }
-
-    /**
-     * Get an unscoped Analogue Query Builder for this instance.
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function globalQuery()
-    {
-        return $this->newQueryWithoutScopes();
-    }
-
-    /**
-     * Get a new query builder that doesn't have any global scopes.
-     *
-     * @return Query
-     */
-    public function newQueryWithoutScopes()
-    {
-        return $this->removeGlobalScopes($this->getQuery());
-    }
-
-    /**
-     * Remove all of the global scopes from an Analogue Query builder.
-     *
-     * @param Query $query
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function removeGlobalScopes($query)
-    {
-        foreach ($this->getGlobalScopes() as $scope) {
-            $scope->remove($query, $this);
-        }
-
-        return $query;
-    }
-
-    /**
-     * Return the manager instance.
-     *
-     * @return \Analogue\ORM\System\Manager
-     */
-    public function getManager()
-    {
-        return $this->manager;
-    }
-
-    /**
-     * Dynamically handle calls to custom commands, or Redirects to query().
-     *
-     * @param string $method
-     * @param array  $parameters
-     *
-     * @throws \Exception
-     *
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        // Check if method is a custom command on the mapper
-        if ($this->hasCustomCommand($method)) {
-            if (count($parameters) == 0) {
-                throw new \Exception("$method must at least have 1 argument");
-            }
-
-            return $this->executeCustomCommand($method, $parameters[0]);
-        }
-
-        // Redirect call on a new query instance
-        return call_user_func_array([$this->query(), $method], $parameters);
-    }
-
-    /**
-     * Check if this mapper supports this command.
-     *
-     * @param string $command
-     *
-     * @return bool
-     */
-    public function hasCustomCommand($command)
-    {
-        return in_array($command, $this->getCustomCommands());
-    }
-
-    /**
-     * Get all the custom commands registered on this mapper.
-     *
-     * @return array
-     */
-    public function getCustomCommands()
-    {
-        return array_keys($this->customCommands);
-    }
-
-    /**
-     * Execute a custom command on an Entity.
-     *
-     * @param string                 $command
-     * @param mixed|Collection|array $entity
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return mixed
-     */
-    public function executeCustomCommand($command, $entity)
-    {
-        $commandClass = $this->customCommands[$command];
-
-        if ($this->manager->isTraversable($entity)) {
-            foreach ($entity as $instance) {
-                $this->executeSingleCustomCommand($commandClass, $instance);
-            }
-        } else {
-            return $this->executeSingleCustomCommand($commandClass, $entity);
-        }
-    }
-
-    /**
-     * Execute a single command instance.
-     *
-     * @param string $commandClass
-     * @param mixed  $entity
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return mixed
-     */
-    protected function executeSingleCustomCommand($commandClass, $entity)
-    {
-        $this->checkEntityType($entity);
-
-        $instance = new $commandClass($this->aggregate($entity), $this->newQueryBuilder());
-
-        return $instance->execute();
-    }
-
-    /**
-     * Get the Analogue Query Builder for this instance.
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function query()
-    {
-        return $this->getQuery();
-    }
+		$eventName = "analogue.{$event}.".$this->entityMap->getClass();
+
+		$method = $halt ? 'until' : 'fire';
+
+		if (!array_key_exists($event, $this->events)) {
+			throw new \LogicException("Analogue : Event $event doesn't exist");
+		}
+
+		$eventClass = $this->events[$event];
+		$event = new $eventClass($entity);
+
+		return $this->dispatcher->$method($eventName, $event);
+	}
+
+	/**
+	 * Register an entity event with the dispatcher.
+	 *
+	 * @param string   $event
+	 * @param \Closure $callback
+	 *
+	 * @return void
+	 */
+	public function registerEvent($event, $callback)
+	{
+		$name = $this->entityMap->getClass();
+
+		$this->dispatcher->listen("analogue.{$event}.{$name}", $callback);
+	}
+
+	/**
+	 * Add a global scope to this mapper query builder.
+	 *
+	 * @param ScopeInterface $scope
+	 *
+	 * @return void
+	 */
+	public function addGlobalScope(ScopeInterface $scope)
+	{
+		$this->globalScopes[get_class($scope)] = $scope;
+	}
+
+	/**
+	 * Determine if the mapper has a global scope.
+	 *
+	 * @param \Analogue\ORM\System\ScopeInterface $scope
+	 *
+	 * @return bool
+	 */
+	public function hasGlobalScope($scope)
+	{
+		return !is_null($this->getGlobalScope($scope));
+	}
+
+	/**
+	 * Get a global scope registered with the modal.
+	 *
+	 * @param \Analogue\ORM\System\ScopeInterface $scope
+	 *
+	 * @return \Analogue\ORM\System\ScopeInterface|null
+	 */
+	public function getGlobalScope($scope)
+	{
+		return array_first($this->globalScopes, function ($key, $value) use ($scope) {
+			return $scope instanceof $value;
+		});
+	}
+
+	/**
+	 * Get a new query instance without a given scope.
+	 *
+	 * @param \Analogue\ORM\System\ScopeInterface $scope
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function newQueryWithoutScope($scope)
+	{
+		$this->getGlobalScope($scope)->remove($query = $this->getQuery(), $this);
+
+		return $query;
+	}
+
+	/**
+	 * Get the Analogue Query Builder for this instance.
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function getQuery()
+	{
+		$query = new Query($this, $this->adapter);
+
+		return $this->applyGlobalScopes($query);
+	}
+
+	/**
+	 * Apply all of the global scopes to an Analogue Query builder.
+	 *
+	 * @param Query $query
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function applyGlobalScopes($query)
+	{
+		foreach ($this->getGlobalScopes() as $scope) {
+			$scope->apply($query, $this);
+		}
+
+		return $query;
+	}
+
+	/**
+	 * Get the global scopes for this class instance.
+	 *
+	 * @return \Analogue\ORM\System\ScopeInterface
+	 */
+	public function getGlobalScopes()
+	{
+		return $this->globalScopes;
+	}
+
+	/**
+	 * Add a dynamic method that extends the mapper/repository.
+	 *
+	 * @param string $command
+	 */
+	public function addCustomCommand($command)
+	{
+		$name = lcfirst(class_basename($command));
+
+		$this->customCommands[$name] = $command;
+	}
+
+	/**
+	 * Create a new instance of the mapped entity class.
+	 *
+	 * @return mixed
+	 */
+	public function newInstance()
+	{
+		$class = $this->entityMap->getClass();
+
+		if ($this->entityMap->useDependencyInjection()) {
+			return $this->newInstanceUsingDependencyInjection($class);
+		}
+
+		return $this->newInstanceUsingInstantiator($class);
+	}
+
+	/**
+	 * Return a new object instance using dependency injection.
+	 *
+	 * @param string $class
+	 *
+	 * @throws ErrorException
+	 *
+	 * @return mixed
+	 */
+	protected function newInstanceUsingDependencyInjection($class)
+	{
+		if (!class_exists(Container::class)) {
+			throw new ErrorException("Illuminate\Container\Container is required to use Dependency Injection");
+		}
+
+		return Container::getInstance()->make($class);
+	}
+
+	/**
+	 * Return a new object instance using doctrine's instantiator.
+	 *
+	 * @param string $class
+	 *
+	 * @return mixed
+	 */
+	protected function newInstanceUsingInstantiator($class)
+	{
+		$instantiator = new \Doctrine\Instantiator\Instantiator();
+
+		return $instantiator->instantiate($class);
+	}
+
+	/**
+	 * Get an unscoped Analogue Query Builder for this instance.
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function globalQuery()
+	{
+		return $this->newQueryWithoutScopes();
+	}
+
+	/**
+	 * Get a new query builder that doesn't have any global scopes.
+	 *
+	 * @return Query
+	 */
+	public function newQueryWithoutScopes()
+	{
+		return $this->removeGlobalScopes($this->getQuery());
+	}
+
+	/**
+	 * Remove all of the global scopes from an Analogue Query builder.
+	 *
+	 * @param Query $query
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function removeGlobalScopes($query)
+	{
+		foreach ($this->getGlobalScopes() as $scope) {
+			$scope->remove($query, $this);
+		}
+
+		return $query;
+	}
+
+	/**
+	 * Return the manager instance.
+	 *
+	 * @return \Analogue\ORM\System\Manager
+	 */
+	public function getManager()
+	{
+		return $this->manager;
+	}
+
+	/**
+	 * Dynamically handle calls to custom commands, or Redirects to query().
+	 *
+	 * @param string $method
+	 * @param array  $parameters
+	 *
+	 * @throws \Exception
+	 *
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		// Check if method is a custom command on the mapper
+		if ($this->hasCustomCommand($method)) {
+			if (count($parameters) == 0) {
+				throw new \Exception("$method must at least have 1 argument");
+			}
+
+			return $this->executeCustomCommand($method, $parameters[0]);
+		}
+
+		// Redirect call on a new query instance
+		return call_user_func_array([$this->query(), $method], $parameters);
+	}
+
+	/**
+	 * Check if this mapper supports this command.
+	 *
+	 * @param string $command
+	 *
+	 * @return bool
+	 */
+	public function hasCustomCommand($command)
+	{
+		return in_array($command, $this->getCustomCommands());
+	}
+
+	/**
+	 * Get all the custom commands registered on this mapper.
+	 *
+	 * @return array
+	 */
+	public function getCustomCommands()
+	{
+		return array_keys($this->customCommands);
+	}
+
+	/**
+	 * Execute a custom command on an Entity.
+	 *
+	 * @param string                 $command
+	 * @param mixed|Collection|array $entity
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return mixed
+	 */
+	public function executeCustomCommand($command, $entity)
+	{
+		$commandClass = $this->customCommands[$command];
+
+		if ($this->manager->isTraversable($entity)) {
+			foreach ($entity as $instance) {
+				$this->executeSingleCustomCommand($commandClass, $instance);
+			}
+		} else {
+			return $this->executeSingleCustomCommand($commandClass, $entity);
+		}
+	}
+
+	/**
+	 * Execute a single command instance.
+	 *
+	 * @param string $commandClass
+	 * @param mixed  $entity
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return mixed
+	 */
+	protected function executeSingleCustomCommand($commandClass, $entity)
+	{
+		$this->checkEntityType($entity);
+
+		$instance = new $commandClass($this->aggregate($entity), $this->newQueryBuilder());
+
+		return $instance->execute();
+	}
+
+	/**
+	 * Get the Analogue Query Builder for this instance.
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function query()
+	{
+		return $this->getQuery();
+	}
 }

src/Plugins/SoftDeletes/SoftDeletesPlugin.php

Spacing +2 added lines, -2 removed lines

@@ -25,7 +25,7 @@ 
         $host = $this;
 
         // Hook any mapper init and check the mapping include soft deletes.
-        $this->manager->registerGlobalEvent('initialized', function ($event, $payload = null) use ($host) {
+        $this->manager->registerGlobalEvent('initialized', function($event, $payload = null) use ($host) {
 
             // Cross Compatible Event handling with 5.3
             // TODO : find a replacement event handler
@@ -63,7 +63,7 @@ 
         $host = $this;
 
         // Register 'deleting' events
-        $mapper->registerEvent('deleting', function ($entity) use ($entityMap, $host) {
+        $mapper->registerEvent('deleting', function($entity) use ($entityMap, $host) {
 
             // Convert Entity into an EntityWrapper
             $factory = new Factory();

Indentation +83 added lines, -83 removed lines

@@ -13,87 +13,87 @@
  */
 class SoftDeletesPlugin extends AnaloguePlugin
 {
-    /**
-     * {@inheritdoc}
-     */
-    public function register()
-    {
-        $host = $this;
-
-        // Hook any mapper init and check the mapping include soft deletes.
-        $this->manager->registerGlobalEvent('initialized', function ($event, $payload = null) use ($host) {
-
-            // Cross Compatible Event handling with 5.3
-            // TODO : find a replacement event handler
-            if (is_null($payload)) {
-                $mapper = $event;
-            } else {
-                $mapper = $payload[0]->mapper;
-            }
-
-            $entityMap = $mapper->getEntityMap();
-
-            if ($entityMap->usesSoftDeletes()) {
-                $host->registerSoftDelete($mapper);
-            }
-        });
-    }
-
-    /**
-     * By hooking to the mapper initialization event, we can extend it
-     * with the softDelete capacity.
-     *
-     * @param \Analogue\ORM\System\Mapper $mapper
-     *
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     *
-     * @return bool|void
-     */
-    protected function registerSoftDelete(Mapper $mapper)
-    {
-        $entityMap = $mapper->getEntityMap();
-
-        // Add Scopes
-        $mapper->addGlobalScope(new SoftDeletingScope());
-
-        $host = $this;
-
-        // Register 'deleting' events
-        $mapper->registerEvent('deleting', function ($entity) use ($entityMap, $host) {
-
-            // Convert Entity into an EntityWrapper
-            $factory = new Factory();
-
-            $wrappedEntity = $factory->make($entity);
-
-            $deletedAtField = $entityMap->getQualifiedDeletedAtColumn();
-
-            if (!is_null($wrappedEntity->getEntityAttribute($deletedAtField))) {
-                return true;
-            }
-
-            $time = new Carbon();
-
-            $wrappedEntity->setEntityAttribute($deletedAtField, $time);
-
-            $plainObject = $wrappedEntity->getObject();
-            $host->manager->mapper(get_class($plainObject))->store($plainObject);
-
-            return false;
-        });
-
-        // Register RestoreCommand
-        $mapper->addCustomCommand(Restore::class);
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getCustomEvents(): array
-    {
-        return [
-            'restoring',
-            'restored',
-        ];
-    }
+	/**
+	 * {@inheritdoc}
+	 */
+	public function register()
+	{
+		$host = $this;
+
+		// Hook any mapper init and check the mapping include soft deletes.
+		$this->manager->registerGlobalEvent('initialized', function ($event, $payload = null) use ($host) {
+
+			// Cross Compatible Event handling with 5.3
+			// TODO : find a replacement event handler
+			if (is_null($payload)) {
+				$mapper = $event;
+			} else {
+				$mapper = $payload[0]->mapper;
+			}
+
+			$entityMap = $mapper->getEntityMap();
+
+			if ($entityMap->usesSoftDeletes()) {
+				$host->registerSoftDelete($mapper);
+			}
+		});
+	}
+
+	/**
+	 * By hooking to the mapper initialization event, we can extend it
+	 * with the softDelete capacity.
+	 *
+	 * @param \Analogue\ORM\System\Mapper $mapper
+	 *
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 *
+	 * @return bool|void
+	 */
+	protected function registerSoftDelete(Mapper $mapper)
+	{
+		$entityMap = $mapper->getEntityMap();
+
+		// Add Scopes
+		$mapper->addGlobalScope(new SoftDeletingScope());
+
+		$host = $this;
+
+		// Register 'deleting' events
+		$mapper->registerEvent('deleting', function ($entity) use ($entityMap, $host) {
+
+			// Convert Entity into an EntityWrapper
+			$factory = new Factory();
+
+			$wrappedEntity = $factory->make($entity);
+
+			$deletedAtField = $entityMap->getQualifiedDeletedAtColumn();
+
+			if (!is_null($wrappedEntity->getEntityAttribute($deletedAtField))) {
+				return true;
+			}
+
+			$time = new Carbon();
+
+			$wrappedEntity->setEntityAttribute($deletedAtField, $time);
+
+			$plainObject = $wrappedEntity->getObject();
+			$host->manager->mapper(get_class($plainObject))->store($plainObject);
+
+			return false;
+		});
+
+		// Register RestoreCommand
+		$mapper->addCustomCommand(Restore::class);
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function getCustomEvents(): array
+	{
+		return [
+			'restoring',
+			'restored',
+		];
+	}
 }