analogueorm / analogue

src/Relationships/MorphPivot.php

Doc Comments +1 added lines, -1 removed lines

@@ -26,7 +26,7 @@
     /**
      * Set the keys for a save update query.
      *
-     * @param  \Analogue\ORM\Query  $query
+     * @param  Query  $query
      * @return \Analogue\ORM\Query
      */
     protected function setKeysForSaveQuery(Query $query)

Indentation +49 added lines, -49 removed lines

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

src/Relationships/MorphTo.php

Doc Comments +1 added lines, -2 removed lines

@@ -46,7 +46,6 @@ 
     /**
      * Create a new belongs to relationship instance.
      *
-     * @param  \Analogue\ORM\System\Query  $query
      * @param  Mappable  $parent
      * @param  string  $foreignKey
      * @param  string  $otherKey
@@ -157,7 +156,7 @@ 
      * Gather all of the foreign keys for a given type.
      *
      * @param  string  $type
-     * @return array
+     * @return BaseCollection
      */
     protected function gatherKeysByType($type)
     {

Indentation +207 added lines, -207 removed lines

@@ -8,224 +8,224 @@
 class MorphTo extends BelongsTo
 {
 
-    /**
-     * The type of the polymorphic relation.
-     *
-     * @var string
-     */
-    protected $morphType;
-
-    /**
-     * The entities whose relations are being eager loaded.
-     *
-     * @var \Analogue\ORM\EntityCollection
-     */
-    protected $entities;
-
-    /**
-     * All of the models keyed by ID.
-     *
-     * @var array
-     */
-    protected $dictionary = array();
-
-    /*
+	/**
+	 * The type of the polymorphic relation.
+	 *
+	 * @var string
+	 */
+	protected $morphType;
+
+	/**
+	 * The entities whose relations are being eager loaded.
+	 *
+	 * @var \Analogue\ORM\EntityCollection
+	 */
+	protected $entities;
+
+	/**
+	 * All of the models keyed by ID.
+	 *
+	 * @var array
+	 */
+	protected $dictionary = array();
+
+	/*
      * Indicates if soft-deleted model instances should be fetched.
      *
      * @var bool
      */
-    protected $withTrashed = false;
-
-    /**
-     * 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  \Analogue\ORM\System\Query  $query
-     * @param  Mappable  $parent
-     * @param  string  $foreignKey
-     * @param  string  $otherKey
-     * @param  string  $type
-     * @param  string  $relation
-     * @return void
-     */
-    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  $entities
-     * @return void
-     */
-    public function addEagerConstraints(array $entities)
-    {
-        $this->buildDictionary($this->entities = EntityCollection::make($entities));
-    }
-
-    /**
-     * Build a dictionary with the entities
-     *
-     * @param  \Analogue\ORM\EntityCollection  $entities
-     * @return void
-     */
-    protected function buildDictionary(EntityCollection $entities)
-    {
-        foreach ($entities as $entity) {
-            if ($entity->getEntityAttribute($this->morphType)) {
-                $this->dictionary[$entity->getEntityAttribute($this->morphType)][$entity->getEntityAttribute($this->foreignKey)][] = $entity;
-            }
-        }
-    }
-
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param  array   $entities
-     * @param  \Analogue\ORM\EntityCollection  $results
-     * @param  string  $relation
-     * @return array
-     */
-    public function match(array $entities, EntityCollection $results, $relation)
-    {
-        return $entities;
-    }
-
-    /*
+	protected $withTrashed = false;
+
+	/**
+	 * 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  \Analogue\ORM\System\Query  $query
+	 * @param  Mappable  $parent
+	 * @param  string  $foreignKey
+	 * @param  string  $otherKey
+	 * @param  string  $type
+	 * @param  string  $relation
+	 * @return void
+	 */
+	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  $entities
+	 * @return void
+	 */
+	public function addEagerConstraints(array $entities)
+	{
+		$this->buildDictionary($this->entities = EntityCollection::make($entities));
+	}
+
+	/**
+	 * Build a dictionary with the entities
+	 *
+	 * @param  \Analogue\ORM\EntityCollection  $entities
+	 * @return void
+	 */
+	protected function buildDictionary(EntityCollection $entities)
+	{
+		foreach ($entities as $entity) {
+			if ($entity->getEntityAttribute($this->morphType)) {
+				$this->dictionary[$entity->getEntityAttribute($this->morphType)][$entity->getEntityAttribute($this->foreignKey)][] = $entity;
+			}
+		}
+	}
+
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param  array   $entities
+	 * @param  \Analogue\ORM\EntityCollection  $results
+	 * @param  string  $relation
+	 * @return array
+	 */
+	public function match(array $entities, EntityCollection $results, $relation)
+	{
+		return $entities;
+	}
+
+	/*
      * Get the results of the relationship.
      *
      * @return mixed
      */
-    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  \Analogue\ORM\EntityCollection  $results
-     * @return void
-     */
-    protected function matchToMorphParents($type, EntityCollection $results)
-    {
-        foreach ($results as $result) {
-            if (isset($this->dictionary[$type][$result->getEntityKey()])) {
-                foreach ($this->dictionary[$type][$result->getEntityKey()] as $entity) {
-                    $entity->setEntityAttribute($this->relation, $result);
-                }
-            }
-        }
-    }
-
-    /**
-     * Get all of the relation results for a type.
-     *
-     * @param  string  $type
-     * @return \Analogue\ORM\EntityCollection
-     */
-    protected function getResultsByType($type)
-    {
-        $mapper = $this->relatedMapper->getManager()->mapper($type);
-
-        $map = $mapper->getEntityMap();
-
-        $key = $map->getKeyName();
-
-        $query = $mapper->getQuery();
-
-        //$query = $this->useWithTrashed($query);
-
-        return $query->whereIn($key, $this->gatherKeysByType($type)->all())->get();
-    }
-
-    /**
-     * Gather all of the foreign keys for a given type.
-     *
-     * @param  string  $type
-     * @return array
-     */
-    protected function gatherKeysByType($type)
-    {
-        $foreign = $this->foreignKey;
-
-        return BaseCollection::make($this->dictionary[$type])->map(function ($entities) use ($foreign) {
-            return head($entities)->{$foreign};
-
-        })->unique();
-    }
-
-    /**
-     * Get the foreign key of the relationship.
-     *
-     * @return string
-     */
-    /*public function getForeignKey()
+	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  \Analogue\ORM\EntityCollection  $results
+	 * @return void
+	 */
+	protected function matchToMorphParents($type, EntityCollection $results)
+	{
+		foreach ($results as $result) {
+			if (isset($this->dictionary[$type][$result->getEntityKey()])) {
+				foreach ($this->dictionary[$type][$result->getEntityKey()] as $entity) {
+					$entity->setEntityAttribute($this->relation, $result);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Get all of the relation results for a type.
+	 *
+	 * @param  string  $type
+	 * @return \Analogue\ORM\EntityCollection
+	 */
+	protected function getResultsByType($type)
+	{
+		$mapper = $this->relatedMapper->getManager()->mapper($type);
+
+		$map = $mapper->getEntityMap();
+
+		$key = $map->getKeyName();
+
+		$query = $mapper->getQuery();
+
+		//$query = $this->useWithTrashed($query);
+
+		return $query->whereIn($key, $this->gatherKeysByType($type)->all())->get();
+	}
+
+	/**
+	 * Gather all of the foreign keys for a given type.
+	 *
+	 * @param  string  $type
+	 * @return array
+	 */
+	protected function gatherKeysByType($type)
+	{
+		$foreign = $this->foreignKey;
+
+		return BaseCollection::make($this->dictionary[$type])->map(function ($entities) use ($foreign) {
+			return head($entities)->{$foreign};
+
+		})->unique();
+	}
+
+	/**
+	 * Get the foreign key of the relationship.
+	 *
+	 * @return string
+	 */
+	/*public function getForeignKey()
     {
         return $this->foreignKey;
     }*/
 
-    /**
-     * 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
+	/**
+	 * 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);
-    }
-
-    /**
-     * Get the foreign key value pair for a related object
-     *
-     * @var 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 dictionary used by the relationship.
-     *
-     * @return array
-     */
-    public function getDictionary()
-    {
-        return $this->dictionary;
-    }
+		$this->parent->setEntityAttribute($this->relation, $entity);
+	}
+
+	/**
+	 * Get the foreign key value pair for a related object
+	 *
+	 * @var 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 dictionary used by the relationship.
+	 *
+	 * @return array
+	 */
+	public function getDictionary()
+	{
+		return $this->dictionary;
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -163,7 +163,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();

Unused Use Statements -1 removed lines

@@ -5,7 +5,6 @@
 use Analogue\ORM\Mappable;
 use Analogue\ORM\System\Query;
 use Analogue\ORM\System\Mapper;
-use Analogue\ORM\System\Manager;
 use Analogue\ORM\EntityCollection;
 use Analogue\ORM\System\InternallyMappable;
 use Analogue\ORM\System\Wrappers\Factory;

src/Relationships/MorphToMany.php

Doc Comments +3 added lines, -4 removed lines

@@ -34,7 +34,6 @@ 
     /**
      * Create a new has many relationship instance.
      *
-     * @param  \Analogue\ORM\Query  $query
      * @param  \Analogue\ORM\Entityl  $parent
      * @param  string  $name
      * @param  string  $table
@@ -72,9 +71,9 @@ 
     /**
      * Add the constraints for a relationship count query.
      *
-     * @param  \Analogue\ORM\Query  $query
-     * @param  \Analogue\ORM\Query  $parent
-     * @return \Analogue\ORM\Query
+     * @param  Query  $query
+     * @param  Query  $parent
+     * @return Query
      */
     public function getRelationCountQuery(Query $query, Query $parent)
     {

Indentation +162 added lines, -162 removed lines

@@ -6,167 +6,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  \Analogue\ORM\Query  $query
-     * @param  \Analogue\ORM\Entityl  $parent
-     * @param  string  $name
-     * @param  string  $table
-     * @param  string  $foreignKey
-     * @param  string  $otherKey
-     * @param  string  $relationName
-     * @param  bool   $inverse
-     * @return void
-     */
-    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  \Analogue\ORM\Query  $query
+	 * @param  \Analogue\ORM\Entityl  $parent
+	 * @param  string  $name
+	 * @param  string  $table
+	 * @param  string  $foreignKey
+	 * @param  string  $otherKey
+	 * @param  string  $relationName
+	 * @param  bool   $inverse
+	 * @return void
+	 */
+	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 $this
-     */
-    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  \Analogue\ORM\Query  $query
-     * @param  \Analogue\ORM\Query  $parent
-     * @return \Analogue\ORM\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.
-     *
-     * @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 \Analogue\ORM\Relationships\Pivot
-     */
-    public function newPivot(array $attributes = array(), $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 $this
+	 */
+	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  \Analogue\ORM\Query  $query
+	 * @param  \Analogue\ORM\Query  $parent
+	 * @return \Analogue\ORM\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.
+	 *
+	 * @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 \Analogue\ORM\Relationships\Pivot
+	 */
+	public function newPivot(array $attributes = array(), $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;
+	}
 }

src/Relationships/Pivot.php

Doc Comments +2 added lines, -1 removed lines

@@ -67,10 +67,11 @@
     /**
      * Create a new pivot model instance.
      *
-     * @param  $parent
+     * @param  \Analogue\ORM\System\InternallyMappable $parent
      * @param  array   $attributes
      * @param  string  $table
      * @param  bool    $exists
+     * @param \Analogue\ORM\EntityMap $parentMap
      * @return void
      */
     public function __construct($parent, $parentMap, $attributes, $table, $exists = false)

Indentation +154 added lines, -154 removed lines

@@ -5,158 +5,158 @@
 class Pivot extends Entity
 {
 
-    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 = array();
-
-    /**
-     * Pivot uses timestamps ?
-     *
-     * @var boolean
-     */
-    protected $timestamps;
-
-    /**
-     * Create a new pivot model instance.
-     *
-     * @param  $parent
-     * @param  array   $attributes
-     * @param  string  $table
-     * @param  bool    $exists
-     * @return void
-     */
-    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();
-    }
+	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 = array();
+
+	/**
+	 * Pivot uses timestamps ?
+	 *
+	 * @var boolean
+	 */
+	protected $timestamps;
+
+	/**
+	 * Create a new pivot model instance.
+	 *
+	 * @param  $parent
+	 * @param  array   $attributes
+	 * @param  string  $table
+	 * @param  bool    $exists
+	 * @return void
+	 */
+	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/Relationship.php

Doc Comments +1 added lines, -1 removed lines

@@ -287,7 +287,7 @@
     /**
      * Get the parent model of the relation.
      *
-     * @return Mappable
+     * @return InternallyMappable
      */
     public function getParent()
     {

Unused Use Statements -1 removed lines

@@ -5,7 +5,6 @@
 use Analogue\ORM\Mappable;
 use Analogue\ORM\System\Query;
 use Analogue\ORM\System\Mapper;
-use Analogue\ORM\System\Manager;
 use Analogue\ORM\EntityCollection;
 use Analogue\ORM\System\InternallyMappable;
 use Analogue\ORM\System\Wrappers\Factory;

Indentation +432 added lines, -432 removed lines

@@ -14,438 +14,438 @@
 abstract class Relationship
 {
 
-    /**
-     * The mapper instance for the related entity
-     *
-     * @var \Analogue\ORM\System\Mapper
-     */
-    protected $relatedMapper;
-
-    /**
-     * The Analogue Query Builder instance.
-     *
-     * @var \Analogue\ORM\Query
-     */
-    protected $query;
-
-    /**
-     * The parent entity proxy instance.
-     *
-     * @var \Analogue\ORM\System\InternallyMappable
-     */
-    protected $parent;
-
-    /**
-     * The parent entity map
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $parentMap;
-
-    /**
-     * The Parent Mapper instance
-     *
-     * @var \Analogue\ORM\System\Mapper
-     */
-    protected $parentMapper;
-
-    /**
-     * The related entity instance.
-     *
-     * @var object
-     */
-    protected $related;
-
-    /**
-     * The related entity Map
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $relatedMap;
-
-    /**
-     * Indicate if the parent entity hold the key for the relation.
-     *
-     * @var boolean
-     */
-    protected static $ownForeignKey = false;
-
-    /**
-     * Indicate if the relationships use a pivot table.*
-     *
-     * @var boolean
-     */
-    protected static $hasPivot = false;
-
-    /**
-     * Indicates if the relation is adding constraints.
-     *
-     * @var bool
-     */
-    protected static $constraints = true;
-
-    /**
-     * Wrapper factory
-     *
-     * @var \Analogue\ORM\System\Wrappers\Factory
-     */
-    protected $factory;
-
-    /**
-     * Create a new relation instance.
-     *
-     * @param  \Analogue\ORM\System\Mapper  $mapper
-     * @param  Mappable  $parent
-     * @return void
-     */
-    public function __construct(Mapper $mapper, $parent)
-    {
-        $this->relatedMapper = $mapper;
-
-        $this->query = $mapper->getQuery();
-
-        $this->factory = new Factory;
-
-        $this->parent = $this->factory->make($parent);
-
-        $this->parentMapper = $mapper->getManager()->getMapper($parent);
-
-        $this->parentMap = $this->parentMapper->getEntityMap();
-
-        $this->related = $this->query->getEntityInstance();
-
-        $this->relatedMap = $mapper->getEntityMap();
-
-        $this->addConstraints();
-    }
-
-    /**
-     *
-     * @param  [type] $related [description]
-     * @return [type]         [description]
-     */
-    abstract public function attachTo($related);
-
-    /**
-     *
-     * @param  [type] $related [description]
-     * @return [type]         [description]
-     */
-    abstract public function detachFrom($related);
-
-    /**
-     * Indicate if the parent entity hold the foreign key for relation.
-     *
-     * @return boolean
-     */
-    public function ownForeignKey()
-    {
-        return static::$ownForeignKey;
-    }
-
-    /**
-     * Indicate if the relationship uses a pivot table
-     *
-     * @return boolean
-     */
-    public function hasPivot()
-    {
-        return static::$hasPivot;
-    }
-
-    /**
-     * Set the base constraints on the relation query.
-     *
-     * @return void
-     */
-    abstract public function addConstraints();
-
-    /**
-     * Set the constraints for an eager load of the relation.
-     *
-     * @param  array  $models
-     * @return void
-     */
-    abstract public function addEagerConstraints(array $models);
-
-    /**
-     * Initialize the relation on a set of models.
-     *
-     * @param  array   $models
-     * @param  string  $relation
-     * @return array
-     */
-    abstract public function initRelation(array $models, $relation);
-
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param  array   $entities
-     * @param  \Analogue\ORM\EntityCollection  $results
-     * @param  string  $relation
-     * @return array
-     */
-    abstract public function match(array $entities, EntityCollection $results, $relation);
-
-    /**
-     * Get the results of the relationship.
-     *
-     * @param string 	$relation 	relation name in parent's entity map
-     * @return mixed
-     */
-    abstract public function getResults($relation);
-
-    /**
-     * Get the relationship for eager loading.
-     *
-     * @return \Analogue\ORM\EntityCollection
-     */
-    public function getEager()
-    {
-        return $this->get();
-    }
-
-    /**
-     * Add the constraints for a relationship count query.
-     *
-     * @param  \Analogue\ORM\System\Query  $query
-     * @param  \Analogue\ORM\System\Query  $parent
-     * @return \Analogue\ORM\System\Query
-     */
-    public function getRelationCountQuery(Query $query, Query $parent)
-    {
-        $query->select(new Expression('count(*)'));
-
-        $key = $this->wrap($this->getQualifiedParentKeyName());
-
-        return $query->where($this->getHasCompareKey(), '=', new Expression($key));
-    }
-
-    /**
-     * Run a callback with constraints disabled on the relation.
-     *
-     * @param  \Closure  $callback
-     * @return mixed
-     */
-    public static function noConstraints(Closure $callback)
-    {
-        static::$constraints = false;
-
-        // When resetting the relation where clause, we want to shift the first element
-        // off of the bindings, leaving only the constraints that the developers put
-        // as "extra" on the relationships, and not original relation constraints.
-        $results = call_user_func($callback);
-
-        static::$constraints = true;
-
-        return $results;
-    }
-
-    /**
-     * Get all of the primary keys for an array of entities.
-     *
-     * @param  array   $entities
-     * @param  string  $key
-     * @return array
-     */
-    protected function getKeys(array $entities, $key = null)
-    {
-        if (is_null($key)) {
-            $key = $this->relatedMap->getKeyName();
-        }
-
-        $host = $this;
-
-        return array_unique(array_values(array_map(function ($value) use ($key, $host) {
-            if (! $value instanceof InternallyMappable) {
-                $value = $host->factory->make($value);
-            }
-
-            return $value->getEntityAttribute($key);
-
-        }, $entities)));
-    }
-
-    /**
-     * Get the underlying query for the relation.
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function getQuery()
-    {
-        return $this->query;
-    }
-
-    /**
-     * Get the base query builder
-     *
-     * @return \Illuminate\Database\Query\Builder
-     */
-    public function getBaseQuery()
-    {
-        return $this->query->getQuery();
-    }
-
-    /**
-     * Get the parent model of the relation.
-     *
-     * @return Mappable
-     */
-    public function getParent()
-    {
-        return $this->parent;
-    }
-
-    /**
-     * Get the fully qualified parent key name.
-     *
-     * @return string
-     */
-    protected function getQualifiedParentKeyName()
-    {
-        return $this->parent->getQualifiedKeyName();
-    }
-
-    /**
-     * Get the related entity of the relation.
-     *
-     * @return \Analogue\ORM\Entity
-     */
-    public function getRelated()
-    {
-        return $this->related;
-    }
-
-    /**
-     * Get the related mapper for the relation
-     *
-     * @return \Analogue\ORM\System\Mapper
-     */
-    public function getRelatedMapper()
-    {
-        return $this->relatedMapper;
-    }
-
-
-    /**
-     * Get the name of the "created at" column.
-     *
-     * @return string
-     */
-    public function createdAt()
-    {
-        return $this->parentMap->getCreatedAtColumn();
-    }
-
-    /**
-     * Get the name of the "updated at" column.
-     *
-     * @return string
-     */
-    public function updatedAt()
-    {
-        return $this->parentMap->getUpdatedAtColumn();
-    }
-
-    /**
-     * Get the name of the related model's "updated at" column.
-     *
-     * @return string
-     */
-    public function relatedUpdatedAt()
-    {
-        return $this->related->getUpdatedAtColumn();
-    }
-
-    /**
-     * Wrap the given value with the parent query's grammar.
-     *
-     * @param  string  $value
-     * @return string
-     */
-    public function wrap($value)
-    {
-        return $this->parentMapper->getQuery()->getQuery()->getGrammar()->wrap($value);
-    }
-
-    /**
-     * Get a fresh timestamp
-     *
-     * @return \Carbon\Carbon
-     */
-    protected function freshTimestamp()
-    {
-        return new Carbon;
-    }
-
-    /**
-     * Cache the link between parent and related
-     * into the mapper's Entity Cache.
-     *
-     * @param  EntityCollection|Mappable $results 	result of the relation query
-     * @param  string  $relation 					Name of the relation method on the parent entity
-     *
-     * @return void
-     */
-    protected function cacheRelation($results, $relation)
-    {
-        $cache = $this->parentMapper->getEntityCache();
-
-        $cache->cacheLoadedRelationResult($this->parent, $relation, $results, $this);
-    }
-
-    /**
-     * Return Pivot attributes when available on a relationship
-     *
-     * @return array
-     */
-    public function getPivotAttributes()
-    {
-        return [];
-    }
-
-    /**
-     * Get a combo type.primaryKey
-     *
-     * @param  Mappable $entity
-     * @return string
-     */
-    protected function getEntityHash(Mappable $entity)
-    {
-        $class = get_class($entity);
+	/**
+	 * The mapper instance for the related entity
+	 *
+	 * @var \Analogue\ORM\System\Mapper
+	 */
+	protected $relatedMapper;
+
+	/**
+	 * The Analogue Query Builder instance.
+	 *
+	 * @var \Analogue\ORM\Query
+	 */
+	protected $query;
+
+	/**
+	 * The parent entity proxy instance.
+	 *
+	 * @var \Analogue\ORM\System\InternallyMappable
+	 */
+	protected $parent;
+
+	/**
+	 * The parent entity map
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $parentMap;
+
+	/**
+	 * The Parent Mapper instance
+	 *
+	 * @var \Analogue\ORM\System\Mapper
+	 */
+	protected $parentMapper;
+
+	/**
+	 * The related entity instance.
+	 *
+	 * @var object
+	 */
+	protected $related;
+
+	/**
+	 * The related entity Map
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $relatedMap;
+
+	/**
+	 * Indicate if the parent entity hold the key for the relation.
+	 *
+	 * @var boolean
+	 */
+	protected static $ownForeignKey = false;
+
+	/**
+	 * Indicate if the relationships use a pivot table.*
+	 *
+	 * @var boolean
+	 */
+	protected static $hasPivot = false;
+
+	/**
+	 * Indicates if the relation is adding constraints.
+	 *
+	 * @var bool
+	 */
+	protected static $constraints = true;
+
+	/**
+	 * Wrapper factory
+	 *
+	 * @var \Analogue\ORM\System\Wrappers\Factory
+	 */
+	protected $factory;
+
+	/**
+	 * Create a new relation instance.
+	 *
+	 * @param  \Analogue\ORM\System\Mapper  $mapper
+	 * @param  Mappable  $parent
+	 * @return void
+	 */
+	public function __construct(Mapper $mapper, $parent)
+	{
+		$this->relatedMapper = $mapper;
+
+		$this->query = $mapper->getQuery();
+
+		$this->factory = new Factory;
+
+		$this->parent = $this->factory->make($parent);
+
+		$this->parentMapper = $mapper->getManager()->getMapper($parent);
+
+		$this->parentMap = $this->parentMapper->getEntityMap();
+
+		$this->related = $this->query->getEntityInstance();
+
+		$this->relatedMap = $mapper->getEntityMap();
+
+		$this->addConstraints();
+	}
+
+	/**
+	 *
+	 * @param  [type] $related [description]
+	 * @return [type]         [description]
+	 */
+	abstract public function attachTo($related);
+
+	/**
+	 *
+	 * @param  [type] $related [description]
+	 * @return [type]         [description]
+	 */
+	abstract public function detachFrom($related);
+
+	/**
+	 * Indicate if the parent entity hold the foreign key for relation.
+	 *
+	 * @return boolean
+	 */
+	public function ownForeignKey()
+	{
+		return static::$ownForeignKey;
+	}
+
+	/**
+	 * Indicate if the relationship uses a pivot table
+	 *
+	 * @return boolean
+	 */
+	public function hasPivot()
+	{
+		return static::$hasPivot;
+	}
+
+	/**
+	 * Set the base constraints on the relation query.
+	 *
+	 * @return void
+	 */
+	abstract public function addConstraints();
+
+	/**
+	 * Set the constraints for an eager load of the relation.
+	 *
+	 * @param  array  $models
+	 * @return void
+	 */
+	abstract public function addEagerConstraints(array $models);
+
+	/**
+	 * Initialize the relation on a set of models.
+	 *
+	 * @param  array   $models
+	 * @param  string  $relation
+	 * @return array
+	 */
+	abstract public function initRelation(array $models, $relation);
+
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param  array   $entities
+	 * @param  \Analogue\ORM\EntityCollection  $results
+	 * @param  string  $relation
+	 * @return array
+	 */
+	abstract public function match(array $entities, EntityCollection $results, $relation);
+
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @param string 	$relation 	relation name in parent's entity map
+	 * @return mixed
+	 */
+	abstract public function getResults($relation);
+
+	/**
+	 * Get the relationship for eager loading.
+	 *
+	 * @return \Analogue\ORM\EntityCollection
+	 */
+	public function getEager()
+	{
+		return $this->get();
+	}
+
+	/**
+	 * Add the constraints for a relationship count query.
+	 *
+	 * @param  \Analogue\ORM\System\Query  $query
+	 * @param  \Analogue\ORM\System\Query  $parent
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function getRelationCountQuery(Query $query, Query $parent)
+	{
+		$query->select(new Expression('count(*)'));
+
+		$key = $this->wrap($this->getQualifiedParentKeyName());
+
+		return $query->where($this->getHasCompareKey(), '=', new Expression($key));
+	}
+
+	/**
+	 * Run a callback with constraints disabled on the relation.
+	 *
+	 * @param  \Closure  $callback
+	 * @return mixed
+	 */
+	public static function noConstraints(Closure $callback)
+	{
+		static::$constraints = false;
+
+		// When resetting the relation where clause, we want to shift the first element
+		// off of the bindings, leaving only the constraints that the developers put
+		// as "extra" on the relationships, and not original relation constraints.
+		$results = call_user_func($callback);
+
+		static::$constraints = true;
+
+		return $results;
+	}
+
+	/**
+	 * Get all of the primary keys for an array of entities.
+	 *
+	 * @param  array   $entities
+	 * @param  string  $key
+	 * @return array
+	 */
+	protected function getKeys(array $entities, $key = null)
+	{
+		if (is_null($key)) {
+			$key = $this->relatedMap->getKeyName();
+		}
+
+		$host = $this;
+
+		return array_unique(array_values(array_map(function ($value) use ($key, $host) {
+			if (! $value instanceof InternallyMappable) {
+				$value = $host->factory->make($value);
+			}
+
+			return $value->getEntityAttribute($key);
+
+		}, $entities)));
+	}
+
+	/**
+	 * Get the underlying query for the relation.
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function getQuery()
+	{
+		return $this->query;
+	}
+
+	/**
+	 * Get the base query builder
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	public function getBaseQuery()
+	{
+		return $this->query->getQuery();
+	}
+
+	/**
+	 * Get the parent model of the relation.
+	 *
+	 * @return Mappable
+	 */
+	public function getParent()
+	{
+		return $this->parent;
+	}
+
+	/**
+	 * Get the fully qualified parent key name.
+	 *
+	 * @return string
+	 */
+	protected function getQualifiedParentKeyName()
+	{
+		return $this->parent->getQualifiedKeyName();
+	}
+
+	/**
+	 * Get the related entity of the relation.
+	 *
+	 * @return \Analogue\ORM\Entity
+	 */
+	public function getRelated()
+	{
+		return $this->related;
+	}
+
+	/**
+	 * Get the related mapper for the relation
+	 *
+	 * @return \Analogue\ORM\System\Mapper
+	 */
+	public function getRelatedMapper()
+	{
+		return $this->relatedMapper;
+	}
+
+
+	/**
+	 * Get the name of the "created at" column.
+	 *
+	 * @return string
+	 */
+	public function createdAt()
+	{
+		return $this->parentMap->getCreatedAtColumn();
+	}
+
+	/**
+	 * Get the name of the "updated at" column.
+	 *
+	 * @return string
+	 */
+	public function updatedAt()
+	{
+		return $this->parentMap->getUpdatedAtColumn();
+	}
+
+	/**
+	 * Get the name of the related model's "updated at" column.
+	 *
+	 * @return string
+	 */
+	public function relatedUpdatedAt()
+	{
+		return $this->related->getUpdatedAtColumn();
+	}
+
+	/**
+	 * Wrap the given value with the parent query's grammar.
+	 *
+	 * @param  string  $value
+	 * @return string
+	 */
+	public function wrap($value)
+	{
+		return $this->parentMapper->getQuery()->getQuery()->getGrammar()->wrap($value);
+	}
+
+	/**
+	 * Get a fresh timestamp
+	 *
+	 * @return \Carbon\Carbon
+	 */
+	protected function freshTimestamp()
+	{
+		return new Carbon;
+	}
+
+	/**
+	 * Cache the link between parent and related
+	 * into the mapper's Entity Cache.
+	 *
+	 * @param  EntityCollection|Mappable $results 	result of the relation query
+	 * @param  string  $relation 					Name of the relation method on the parent entity
+	 *
+	 * @return void
+	 */
+	protected function cacheRelation($results, $relation)
+	{
+		$cache = $this->parentMapper->getEntityCache();
+
+		$cache->cacheLoadedRelationResult($this->parent, $relation, $results, $this);
+	}
+
+	/**
+	 * Return Pivot attributes when available on a relationship
+	 *
+	 * @return array
+	 */
+	public function getPivotAttributes()
+	{
+		return [];
+	}
+
+	/**
+	 * Get a combo type.primaryKey
+	 *
+	 * @param  Mappable $entity
+	 * @return string
+	 */
+	protected function getEntityHash(Mappable $entity)
+	{
+		$class = get_class($entity);
         
-        $keyName = Mapper::getMapper($class)->getEntityMap()->getKeyName();
+		$keyName = Mapper::getMapper($class)->getEntityMap()->getKeyName();
         
-        $hash = $class.'.'.$entity->getEntityAttribute($keyName);
-
-        return $hash;
-    }
-
-    /**
-     * Run synchronization content if needed by the
-     * relation type.
-     *
-     * @param  array  $actualContent
-     * @return void
-     */
-    public function sync(array $actualContent)
-    {
-        //
-    }
-
-    /**
-     * Handle dynamic method calls to the relationship.
-     *
-     * @param  string  $method
-     * @param  array   $parameters
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        $result = call_user_func_array(array($this->query, $method), $parameters);
-
-        if ($result === $this->query) {
-            return $this;
-        }
-
-        return $result;
-    }
+		$hash = $class.'.'.$entity->getEntityAttribute($keyName);
+
+		return $hash;
+	}
+
+	/**
+	 * Run synchronization content if needed by the
+	 * relation type.
+	 *
+	 * @param  array  $actualContent
+	 * @return void
+	 */
+	public function sync(array $actualContent)
+	{
+		//
+	}
+
+	/**
+	 * Handle dynamic method calls to the relationship.
+	 *
+	 * @param  string  $method
+	 * @param  array   $parameters
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		$result = call_user_func_array(array($this->query, $method), $parameters);
+
+		if ($result === $this->query) {
+			return $this;
+		}
+
+		return $result;
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -254,8 +254,8 @@
 
         $host = $this;
 
-        return array_unique(array_values(array_map(function ($value) use ($key, $host) {
-            if (! $value instanceof InternallyMappable) {
+        return array_unique(array_values(array_map(function($value) use ($key, $host) {
+            if (!$value instanceof InternallyMappable) {
                 $value = $host->factory->make($value);
             }
 

src/Repository.php

Doc Comments +2 added lines, -2 removed lines

@@ -24,7 +24,7 @@ 
      * - Mappable object instance
      * - Instance of mapper
      *
-     * @param Mapper|Mappable|string $mapper
+     * @param Mapper $mapper
      * @param EntityMap 			 $entityMap (optionnal)
      *
      * @throws \InvalidArgumentException
@@ -97,7 +97,7 @@ 
      * Delete an entity or an entity collection from the database
      *
      * @param  Mappable|Collection $entity
-     * @return null
+     * @return \Illuminate\Support\Collection|null
      */
     public function delete($entity)
     {

Indentation +111 added lines, -111 removed lines

@@ -10,124 +10,124 @@
 class Repository
 {
 
-    /**
-     * The mapper object for the corresponding entity
-     *
-     * @var \Analogue\ORM\System\Mapper
-     */
-    protected $mapper;
+	/**
+	 * The mapper object for the corresponding entity
+	 *
+	 * @var \Analogue\ORM\System\Mapper
+	 */
+	protected $mapper;
 
-    /**
-     * To build a repository, either provide :
-     *
-     * - Mappable object's class name as a string
-     * - Mappable object instance
-     * - Instance of mapper
-     *
-     * @param Mapper|Mappable|string $mapper
-     * @param EntityMap 			 $entityMap (optionnal)
-     *
-     * @throws \InvalidArgumentException
-     */
-    public function __construct($mapper, EntityMap $entityMap = null)
-    {
-        if ($mapper instanceof Mappable || is_string($mapper)) {
-            $this->mapper = Manager::getMapper($mapper, $entityMap);
-        } elseif ($mapper instanceof Mapper) {
-            $this->mapper = $mapper;
-        } else {
-            new InvalidArgumentException('Repository class constuctor need a valid Mapper or Mappable object.');
-        }
-    }
+	/**
+	 * To build a repository, either provide :
+	 *
+	 * - Mappable object's class name as a string
+	 * - Mappable object instance
+	 * - Instance of mapper
+	 *
+	 * @param Mapper|Mappable|string $mapper
+	 * @param EntityMap 			 $entityMap (optionnal)
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public function __construct($mapper, EntityMap $entityMap = null)
+	{
+		if ($mapper instanceof Mappable || is_string($mapper)) {
+			$this->mapper = Manager::getMapper($mapper, $entityMap);
+		} elseif ($mapper instanceof Mapper) {
+			$this->mapper = $mapper;
+		} else {
+			new InvalidArgumentException('Repository class constuctor need a valid Mapper or Mappable object.');
+		}
+	}
 
-    /**
-     * Return all Entities from database
-     *
-     * @return \Analogue\ORM\EntityCollection
-     */
-    public function all()
-    {
-        return $this->mapper->get();
-    }
+	/**
+	 * Return all Entities from database
+	 *
+	 * @return \Analogue\ORM\EntityCollection
+	 */
+	public function all()
+	{
+		return $this->mapper->get();
+	}
     
-    /**
-     * Fetch a record from the database
-     * @param  integer $id
-     * @return \Analogue\ORM\Mappable
-     */
-    public function find($id)
-    {
-        return $this->mapper->find($id);
-    }
+	/**
+	 * Fetch a record from the database
+	 * @param  integer $id
+	 * @return \Analogue\ORM\Mappable
+	 */
+	public function find($id)
+	{
+		return $this->mapper->find($id);
+	}
 
-    /**
-     * Get the first entity matching the given attributes.
-     *
-     * @param  array  $attributes
-     * @return \Analogue\ORM\Mappable|null
-     */
-    public function firstMatching(array $attributes)
-    {
-        return $this->mapper->where($attributes)->first();
-    }
+	/**
+	 * Get the first entity matching the given attributes.
+	 *
+	 * @param  array  $attributes
+	 * @return \Analogue\ORM\Mappable|null
+	 */
+	public function firstMatching(array $attributes)
+	{
+		return $this->mapper->where($attributes)->first();
+	}
 
-    /**
-     * Return all the entities matching the given attributes
-     *
-     * @param array $attributes
-     * @return \Analogue\ORM\EntityCollection
-     */
-    public function allMatching(array $attributes)
-    {
-        return $this->mapper->where($attributes)->get();
-    }
+	/**
+	 * Return all the entities matching the given attributes
+	 *
+	 * @param array $attributes
+	 * @return \Analogue\ORM\EntityCollection
+	 */
+	public function allMatching(array $attributes)
+	{
+		return $this->mapper->where($attributes)->get();
+	}
 
-    /**
-     * Return a paginator instance on the EntityCollection
-     *
-     * @param  int $perPage number of item per page (fallback on default setup in entity map)
-     * @return
-     */
-    public function paginate($perPage = null)
-    {
-        return $this->mapper->paginate($perPage);
-    }
+	/**
+	 * Return a paginator instance on the EntityCollection
+	 *
+	 * @param  int $perPage number of item per page (fallback on default setup in entity map)
+	 * @return
+	 */
+	public function paginate($perPage = null)
+	{
+		return $this->mapper->paginate($perPage);
+	}
 
-    /**
-     * Delete an entity or an entity collection from the database
-     *
-     * @param  Mappable|Collection $entity
-     * @return null
-     */
-    public function delete($entity)
-    {
-        return $this->mapper->delete($entity);
-    }
+	/**
+	 * Delete an entity or an entity collection from the database
+	 *
+	 * @param  Mappable|Collection $entity
+	 * @return null
+	 */
+	public function delete($entity)
+	{
+		return $this->mapper->delete($entity);
+	}
 
-    /**
-     * Persist an entity or an entity collection in the database.
-     *
-     * @param  Mappable|Collection|array $entity
-     * @return Mappable|Collection|array
-     */
-    public function store($entity)
-    {
-        return $this->mapper->store($entity);
-    }
+	/**
+	 * Persist an entity or an entity collection in the database.
+	 *
+	 * @param  Mappable|Collection|array $entity
+	 * @return Mappable|Collection|array
+	 */
+	public function store($entity)
+	{
+		return $this->mapper->store($entity);
+	}
 
-    /**
-     * Make custom mapper custom commands available in repository
-     *
-     * @param  string  $method
-     * @param  array   $parameters
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        if ($this->mapper->hasCustomCommand($method)) {
-            call_user_func_array(array($this->mapper, $method), $parameters);
-        } else {
-            throw new Exception("No method $method on ".get_class($this));
-        }
-    }
+	/**
+	 * Make custom mapper custom commands available in repository
+	 *
+	 * @param  string  $method
+	 * @param  array   $parameters
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		if ($this->mapper->hasCustomCommand($method)) {
+			call_user_func_array(array($this->mapper, $method), $parameters);
+		} else {
+			throw new Exception("No method $method on ".get_class($this));
+		}
+	}
 }

src/System/Aggregate.php

Doc Comments +3 added lines, -3 removed lines

@@ -151,7 +151,7 @@ 
      * Parse a 'single' relationship
      *
      * @param  string $relation
-     * @return void|boolean
+     * @return boolean
      */
     protected function parseSingleRelationship($relation)
     {
@@ -194,7 +194,7 @@ 
      * Check if value isn't parent or root in the aggregate
      *
      * @param  mixed
-     * @return boolean
+     * @return boolean|null
      */
     protected function isParentOrRoot($value)
     {
@@ -274,6 +274,7 @@ 
      * Create a child, aggregated entity
      *
      * @param  mixed $entities
+     * @param string $relation
      * @return
      */
     protected function createSubAggregates($entities, $relation)
@@ -656,7 +657,6 @@ 
      * Get foreign key attribute(s) from a parent entity in this
      * aggregate context
      *
-     * @param  string $relation
      * @return array
      */
     protected function getForeignKeyAttributesFromParent()

Indentation +984 added lines, -984 removed lines

@@ -14,1003 +14,1003 @@
 class Aggregate implements InternallyMappable
 {
 
-    /**
-     * The Root Entity
-     *
-     * @var \Analogue\ORM\System\Wrappers\Wrapper
-     */
-    protected $wrappedEntity;
-
-    /**
-     * Parent Root Aggregate
-     *
-     * @var \Analogue\ORM\System\Aggregate
-     */
-    protected $parent;
-
-    /**
-     * Parent's relationship method
-     *
-     * @var string
-     */
-    protected $parentRelationship;
-
-    /**
-     * Root Entity
-     *
-     * @var \Analogue\ORM\System\Aggregate
-     */
-    protected $root;
-
-    /**
-     * An associative array containing entity's
-     * relationships converted to Aggregates
-     *
-     * @var array
-     */
-    protected $relationships = [];
-
-    /**
-     * Relationship that need post-command synchronization
-     *
-     * @var array
-     */
-    protected $needSync = [];
-
-    /**
-     * Mapper
-     *
-     * @var \Analogue\ORM\System\Mapper;
-     */
-    protected $mapper;
-
-    /**
-     * Entity Map
-     *
-     * @var \Analogue\ORM\EntityMap;
-     */
-    protected $entityMap;
-
-    /**
-     * Create a new Aggregated Entity instance
-     *
-     * @param mixed          $entity             [description]
-     * @param Aggregate|null $parent             [description]
-     * @param string         $parentRelationship [description]
-     * @param Aggregate|null $root               [description]
-     */
-    public function __construct($entity, Aggregate $parent = null, $parentRelationship = null, Aggregate $root = null)
-    {
-        $factory = new Factory;
-
-        $this->wrappedEntity = $factory->make($entity);
-
-        $this->parent = $parent;
-
-        $this->parentRelationship = $parentRelationship;
-
-        $this->root = $root;
-
-        $this->mapper = Manager::getMapper($entity);
-
-        $this->entityMap = $this->mapper->getEntityMap();
+	/**
+	 * The Root Entity
+	 *
+	 * @var \Analogue\ORM\System\Wrappers\Wrapper
+	 */
+	protected $wrappedEntity;
+
+	/**
+	 * Parent Root Aggregate
+	 *
+	 * @var \Analogue\ORM\System\Aggregate
+	 */
+	protected $parent;
+
+	/**
+	 * Parent's relationship method
+	 *
+	 * @var string
+	 */
+	protected $parentRelationship;
+
+	/**
+	 * Root Entity
+	 *
+	 * @var \Analogue\ORM\System\Aggregate
+	 */
+	protected $root;
+
+	/**
+	 * An associative array containing entity's
+	 * relationships converted to Aggregates
+	 *
+	 * @var array
+	 */
+	protected $relationships = [];
+
+	/**
+	 * Relationship that need post-command synchronization
+	 *
+	 * @var array
+	 */
+	protected $needSync = [];
+
+	/**
+	 * Mapper
+	 *
+	 * @var \Analogue\ORM\System\Mapper;
+	 */
+	protected $mapper;
+
+	/**
+	 * Entity Map
+	 *
+	 * @var \Analogue\ORM\EntityMap;
+	 */
+	protected $entityMap;
+
+	/**
+	 * Create a new Aggregated Entity instance
+	 *
+	 * @param mixed          $entity             [description]
+	 * @param Aggregate|null $parent             [description]
+	 * @param string         $parentRelationship [description]
+	 * @param Aggregate|null $root               [description]
+	 */
+	public function __construct($entity, Aggregate $parent = null, $parentRelationship = null, Aggregate $root = null)
+	{
+		$factory = new Factory;
+
+		$this->wrappedEntity = $factory->make($entity);
+
+		$this->parent = $parent;
+
+		$this->parentRelationship = $parentRelationship;
+
+		$this->root = $root;
+
+		$this->mapper = Manager::getMapper($entity);
+
+		$this->entityMap = $this->mapper->getEntityMap();
              
-        $this->parseRelationships();
-    }
-
-    /**
-     * Parse Every relationships defined on the entity
-     *
-     * @return void
-     */
-    protected function parseRelationships()
-    {
-        foreach ($this->entityMap->getSingleRelationships() as $relation) {
-            $this->parseSingleRelationship($relation);
-        }
-
-        foreach ($this->entityMap->getManyRelationships() as $relation) {
-            $this->parseManyRelationship($relation);
-        }
-    }
-
-    /**
-     * Parse for values common to single & many relations
-     *
-     * @param  string    $relation
-     * @return mixed|boolean
-     */
-    protected function parseForCommonValues($relation)
-    {
-        if (! $this->hasAttribute($relation)) {
-            // If no attribute exists for this relationships
-            // we'll make it a simple empty array. This will
-            // save us from constantly checking for the attributes
-            // actual existence.
-            $this->relationships[$relation] = [];
-            return false;
-        }
-
-        $value = $this->getRelationshipValue($relation);
-
-        if (is_null($value)) {
-            $this->relationships[$relation] = [];
-
-            // If the relationship's content is the null value
-            // and the Entity's exist in DB, we'll interpret this
-            // as the need to detach all related Entities,
-            // therefore a sync operation is needed.
-            $this->needSync[] = $relation;
-            return false;
-        }
-
-        return $value;
-    }
-
-    /**
-     * Parse a 'single' relationship
-     *
-     * @param  string $relation
-     * @return void|boolean
-     */
-    protected function parseSingleRelationship($relation)
-    {
-        if (! $value = $this->parseForCommonValues($relation)) {
-            return true;
-        }
+		$this->parseRelationships();
+	}
+
+	/**
+	 * Parse Every relationships defined on the entity
+	 *
+	 * @return void
+	 */
+	protected function parseRelationships()
+	{
+		foreach ($this->entityMap->getSingleRelationships() as $relation) {
+			$this->parseSingleRelationship($relation);
+		}
+
+		foreach ($this->entityMap->getManyRelationships() as $relation) {
+			$this->parseManyRelationship($relation);
+		}
+	}
+
+	/**
+	 * Parse for values common to single & many relations
+	 *
+	 * @param  string    $relation
+	 * @return mixed|boolean
+	 */
+	protected function parseForCommonValues($relation)
+	{
+		if (! $this->hasAttribute($relation)) {
+			// If no attribute exists for this relationships
+			// we'll make it a simple empty array. This will
+			// save us from constantly checking for the attributes
+			// actual existence.
+			$this->relationships[$relation] = [];
+			return false;
+		}
+
+		$value = $this->getRelationshipValue($relation);
+
+		if (is_null($value)) {
+			$this->relationships[$relation] = [];
+
+			// If the relationship's content is the null value
+			// and the Entity's exist in DB, we'll interpret this
+			// as the need to detach all related Entities,
+			// therefore a sync operation is needed.
+			$this->needSync[] = $relation;
+			return false;
+		}
+
+		return $value;
+	}
+
+	/**
+	 * Parse a 'single' relationship
+	 *
+	 * @param  string $relation
+	 * @return void|boolean
+	 */
+	protected function parseSingleRelationship($relation)
+	{
+		if (! $value = $this->parseForCommonValues($relation)) {
+			return true;
+		}
         
-        if ($value instanceof Collection || is_array($value) || $value instanceof CollectionProxy) {
-            throw new MappingException("Entity's attribute $relation should not be array, or collection");
-        }
-
-        if ($value instanceof EntityProxy && ! $value->isLoaded()) {
-            $this->relationships[$relation] = [];
-            return true;
-        }
-
-        // If the attribute is a loaded proxy, swap it for its
-        // loaded entity.
-        if ($value instanceof EntityProxy && $value->isLoaded()) {
-            $value = $value->getUnderlyingObject();
-        }
-
-        if ($this->isParentOrRoot($value)) {
-            $this->relationships[$relation] = [];
-            return true;
-        }
-
-        // At this point, we can assume the attribute is an Entity instance
-        // so we'll treat it as such.
-        $subAggregate = $this->createSubAggregate($value, $relation);
+		if ($value instanceof Collection || is_array($value) || $value instanceof CollectionProxy) {
+			throw new MappingException("Entity's attribute $relation should not be array, or collection");
+		}
+
+		if ($value instanceof EntityProxy && ! $value->isLoaded()) {
+			$this->relationships[$relation] = [];
+			return true;
+		}
+
+		// If the attribute is a loaded proxy, swap it for its
+		// loaded entity.
+		if ($value instanceof EntityProxy && $value->isLoaded()) {
+			$value = $value->getUnderlyingObject();
+		}
+
+		if ($this->isParentOrRoot($value)) {
+			$this->relationships[$relation] = [];
+			return true;
+		}
+
+		// At this point, we can assume the attribute is an Entity instance
+		// so we'll treat it as such.
+		$subAggregate = $this->createSubAggregate($value, $relation);
        
-        // Even if it's a single entity, we'll store it as an array
-        // just for consistency with other relationships
-        $this->relationships[$relation] = [$subAggregate];
+		// Even if it's a single entity, we'll store it as an array
+		// just for consistency with other relationships
+		$this->relationships[$relation] = [$subAggregate];
  
-        return true;
-    }
-
-    /**
-     * Check if value isn't parent or root in the aggregate
-     *
-     * @param  mixed
-     * @return boolean
-     */
-    protected function isParentOrRoot($value)
-    {
-        if (! is_null($this->root)) {
-            $rootClass = get_class($this->root->getEntityObject());
-            if ($rootClass == get_class($value)) {
-                return true;
-            }
-        }
-
-
-        if (! is_null($this->parent)) {
-            $parentClass = get_class($this->parent->getEntityObject());
-            if ($parentClass == get_class($value)) {
-                return true;
-            }
-        }
-    }
-
-    /**
-     * Parse a 'many' relationship
-     *
-     * @param  string $relation
-     * @return boolean
-     */
-    protected function parseManyRelationship($relation)
-    {
-        if (! $value = $this->parseForCommonValues($relation)) {
-            return true;
-        }
-
-        if (is_array($value) || $value instanceof Collection) {
-            $this->needSync[] = $relation;
-        }
-        // If the relation is a proxy, we test is the relation
-        // has been lazy loaded, otherwise we'll just treat
-        // the subset of newly added items.
-        if ($value instanceof CollectionProxy && $value->isLoaded()) {
-            $this->needSync[] = $relation;
-            $value = $value->getUnderlyingCollection();
-        }
-
-        if ($value instanceof CollectionProxy && ! $value->isLoaded()) {
-            $value = $value->getAddedItems();
-        }
-
-        // At this point $value should be either an array or an instance
-        // of a collection class.
-        if (! is_array($value) && ! $value instanceof Collection) {
-            throw new MappingException("'$relation' attribute should be array() or Collection");
-        }
-
-        $this->relationships[$relation] = $this->createSubAggregates($value, $relation);
+		return true;
+	}
+
+	/**
+	 * Check if value isn't parent or root in the aggregate
+	 *
+	 * @param  mixed
+	 * @return boolean
+	 */
+	protected function isParentOrRoot($value)
+	{
+		if (! is_null($this->root)) {
+			$rootClass = get_class($this->root->getEntityObject());
+			if ($rootClass == get_class($value)) {
+				return true;
+			}
+		}
+
+
+		if (! is_null($this->parent)) {
+			$parentClass = get_class($this->parent->getEntityObject());
+			if ($parentClass == get_class($value)) {
+				return true;
+			}
+		}
+	}
+
+	/**
+	 * Parse a 'many' relationship
+	 *
+	 * @param  string $relation
+	 * @return boolean
+	 */
+	protected function parseManyRelationship($relation)
+	{
+		if (! $value = $this->parseForCommonValues($relation)) {
+			return true;
+		}
+
+		if (is_array($value) || $value instanceof Collection) {
+			$this->needSync[] = $relation;
+		}
+		// If the relation is a proxy, we test is the relation
+		// has been lazy loaded, otherwise we'll just treat
+		// the subset of newly added items.
+		if ($value instanceof CollectionProxy && $value->isLoaded()) {
+			$this->needSync[] = $relation;
+			$value = $value->getUnderlyingCollection();
+		}
+
+		if ($value instanceof CollectionProxy && ! $value->isLoaded()) {
+			$value = $value->getAddedItems();
+		}
+
+		// At this point $value should be either an array or an instance
+		// of a collection class.
+		if (! is_array($value) && ! $value instanceof Collection) {
+			throw new MappingException("'$relation' attribute should be array() or Collection");
+		}
+
+		$this->relationships[$relation] = $this->createSubAggregates($value, $relation);
         
-        return true;
-    }
-
-    /**
-     * Return Entity's relationship attribute
-     *
-     * @param  string $relation
-     * @return mixed
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     */
-    protected function getRelationshipValue($relation)
-    {
-        $value = $this->getEntityAttribute($relation);
-
-        if (is_bool($value) || is_float($value) || is_int($value) || is_string($value)) {
-            throw new MappingException("Entity's attribute $relation should be array, object, collection or null");
-        }
-
-        return $value;
-    }
-
-    /**
-     * Create a child, aggregated entity
-     *
-     * @param  mixed $entities
-     * @return
-     */
-    protected function createSubAggregates($entities, $relation)
-    {
-        $aggregates = [];
-
-        foreach ($entities as $entity) {
-            $aggregates[] = $this->createSubAggregate($entity, $relation);
-        }
-
-        return $aggregates;
-    }
-
-    /**
-     * Create a related subAggregate
-     *
-     * @param  mixed $entity
-     * @return \Analogue\ORM\System\RootAggregate;
-     */
-    protected function createSubAggregate($entity, $relation)
-    {
-        // If root isn't defined, then this is the Aggregate Root
-        if (is_null($this->root)) {
-            $root = $this;
-        } else {
-            $root = $this->root;
-        }
-
-        $aggregate = new Aggregate($entity, $this, $relation, $root);
-
-        return $aggregate;
-    }
-
-    /**
-     * Get the Entity's primary key attribute
-     *
-     * @return string|integer
-     */
-    public function getEntityId()
-    {
-        return $this->wrappedEntity->getEntityAttribute($this->entityMap->getKeyName());
-    }
-
-    /**
-     * Get the name of the primary key
-     *
-     * @return string
-     */
-    public function getEntityKey()
-    {
-        return $this->entityMap->getKeyName();
-    }
-
-    /**
-     * Return the entity map for the current entity
-     *
-     * @return \Analogue\ORM\EntityMap
-     */
-    public function getEntityMap()
-    {
-        return $this->entityMap;
-    }
-
-    /**
-     * Return the Entity's hash $class.$id
-     *
-     * @return string
-     */
-    public function getEntityHash()
-    {
-        return $this->getEntityClass().'.'.$this->getEntityId();
-    }
-
-    /**
-     * Get wrapped entity class
-     *
-     * @return
-     */
-    public function getEntityClass()
-    {
-        return $this->entityMap->getClass();
-    }
-
-    /**
-     * Return the Mapper's entity cache
-     *
-     * @return \Analogue\ORM\System\EntityCache
-     */
-    protected function getEntityCache()
-    {
-        return $this->mapper->getEntityCache();
-    }
-
-    /**
-     * Get a relationship as an aggregated entities' array
-     *
-     * @param  string $name
-     * @return array
-     */
-    public function getRelationship($name)
-    {
-        if (array_key_exists($name, $this->relationships)) {
-            return $this->relationships[$name];
-        } else {
-            return [];
-        }
-    }
-
-    /**
-     * [TO IMPLEMENT]
-     *
-     * @return array
-     */
-    public function getPivotAttributes()
-    {
-        return [];
-    }
-
-    /**
-     * Get Non existing related entities from several relationships
-     *
-     * @param  array  $relationships
-     * @return array
-     */
-    public function getNonExistingRelated(array $relationships)
-    {
-        $nonExisting = [];
-
-        foreach ($relationships as $relation) {
-            if ($this->hasAttribute($relation) && array_key_exists($relation, $this->relationships)) {
-                $nonExisting = array_merge($nonExisting, $this->getNonExistingFromRelation($relation));
-            }
-        }
-
-        return $nonExisting;
-    }
-
-    /**
-     * Get non-existing related entities from a single relation
-     *
-     * @param  string $relation
-     * @return array
-     */
-    protected function getNonExistingFromRelation($relation)
-    {
-        $nonExisting = [];
-
-        foreach ($this->relationships[$relation] as $aggregate) {
-            if (! $aggregate->exists()) {
-                $nonExisting[] = $aggregate;
-            }
-        }
-
-        return $nonExisting;
-    }
-
-    /**
-     * Synchronize relationships if needed
-     *
-     * @return
-     */
-    public function syncRelationships()
-    {
-        if ($this->exists()) {
-            foreach ($this->needSync as $relation) {
-                $this->synchronize($relation);
-            }
-        }
-    }
-
-    /**
-     * Synchronize a relationship attribute
-     *
-     * @return void
-     */
-    protected function synchronize($relation)
-    {
-        $actualContent = $this->relationships[$relation];
-
-        $this->entityMap->$relation($this->getEntityObject())->sync($actualContent);
-    }
-
-    /**
-     * Returns an array of Missing related Entities for the
-     * given $relation
-     *
-     * @param  string $relation
-     * @return array
-     */
-    public function getMissingEntities($relation)
-    {
-        $cachedRelations = $this->getCachedAttribute($relation);
-
-        if (! is_null($cachedRelations)) {
-            $missing = [];
-
-            foreach ($cachedRelations as $hash) {
-                if (! $this->getRelatedAggregateFromHash($hash, $relation)) {
-                    $missing[] = $hash;
-                }
-            }
-
-            return $missing;
-        } else {
-            return [];
-        }
-    }
+		return true;
+	}
+
+	/**
+	 * Return Entity's relationship attribute
+	 *
+	 * @param  string $relation
+	 * @return mixed
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 */
+	protected function getRelationshipValue($relation)
+	{
+		$value = $this->getEntityAttribute($relation);
+
+		if (is_bool($value) || is_float($value) || is_int($value) || is_string($value)) {
+			throw new MappingException("Entity's attribute $relation should be array, object, collection or null");
+		}
+
+		return $value;
+	}
+
+	/**
+	 * Create a child, aggregated entity
+	 *
+	 * @param  mixed $entities
+	 * @return
+	 */
+	protected function createSubAggregates($entities, $relation)
+	{
+		$aggregates = [];
+
+		foreach ($entities as $entity) {
+			$aggregates[] = $this->createSubAggregate($entity, $relation);
+		}
+
+		return $aggregates;
+	}
+
+	/**
+	 * Create a related subAggregate
+	 *
+	 * @param  mixed $entity
+	 * @return \Analogue\ORM\System\RootAggregate;
+	 */
+	protected function createSubAggregate($entity, $relation)
+	{
+		// If root isn't defined, then this is the Aggregate Root
+		if (is_null($this->root)) {
+			$root = $this;
+		} else {
+			$root = $this->root;
+		}
+
+		$aggregate = new Aggregate($entity, $this, $relation, $root);
+
+		return $aggregate;
+	}
+
+	/**
+	 * Get the Entity's primary key attribute
+	 *
+	 * @return string|integer
+	 */
+	public function getEntityId()
+	{
+		return $this->wrappedEntity->getEntityAttribute($this->entityMap->getKeyName());
+	}
+
+	/**
+	 * Get the name of the primary key
+	 *
+	 * @return string
+	 */
+	public function getEntityKey()
+	{
+		return $this->entityMap->getKeyName();
+	}
+
+	/**
+	 * Return the entity map for the current entity
+	 *
+	 * @return \Analogue\ORM\EntityMap
+	 */
+	public function getEntityMap()
+	{
+		return $this->entityMap;
+	}
+
+	/**
+	 * Return the Entity's hash $class.$id
+	 *
+	 * @return string
+	 */
+	public function getEntityHash()
+	{
+		return $this->getEntityClass().'.'.$this->getEntityId();
+	}
+
+	/**
+	 * Get wrapped entity class
+	 *
+	 * @return
+	 */
+	public function getEntityClass()
+	{
+		return $this->entityMap->getClass();
+	}
+
+	/**
+	 * Return the Mapper's entity cache
+	 *
+	 * @return \Analogue\ORM\System\EntityCache
+	 */
+	protected function getEntityCache()
+	{
+		return $this->mapper->getEntityCache();
+	}
+
+	/**
+	 * Get a relationship as an aggregated entities' array
+	 *
+	 * @param  string $name
+	 * @return array
+	 */
+	public function getRelationship($name)
+	{
+		if (array_key_exists($name, $this->relationships)) {
+			return $this->relationships[$name];
+		} else {
+			return [];
+		}
+	}
+
+	/**
+	 * [TO IMPLEMENT]
+	 *
+	 * @return array
+	 */
+	public function getPivotAttributes()
+	{
+		return [];
+	}
+
+	/**
+	 * Get Non existing related entities from several relationships
+	 *
+	 * @param  array  $relationships
+	 * @return array
+	 */
+	public function getNonExistingRelated(array $relationships)
+	{
+		$nonExisting = [];
+
+		foreach ($relationships as $relation) {
+			if ($this->hasAttribute($relation) && array_key_exists($relation, $this->relationships)) {
+				$nonExisting = array_merge($nonExisting, $this->getNonExistingFromRelation($relation));
+			}
+		}
+
+		return $nonExisting;
+	}
+
+	/**
+	 * Get non-existing related entities from a single relation
+	 *
+	 * @param  string $relation
+	 * @return array
+	 */
+	protected function getNonExistingFromRelation($relation)
+	{
+		$nonExisting = [];
+
+		foreach ($this->relationships[$relation] as $aggregate) {
+			if (! $aggregate->exists()) {
+				$nonExisting[] = $aggregate;
+			}
+		}
+
+		return $nonExisting;
+	}
+
+	/**
+	 * Synchronize relationships if needed
+	 *
+	 * @return
+	 */
+	public function syncRelationships()
+	{
+		if ($this->exists()) {
+			foreach ($this->needSync as $relation) {
+				$this->synchronize($relation);
+			}
+		}
+	}
+
+	/**
+	 * Synchronize a relationship attribute
+	 *
+	 * @return void
+	 */
+	protected function synchronize($relation)
+	{
+		$actualContent = $this->relationships[$relation];
+
+		$this->entityMap->$relation($this->getEntityObject())->sync($actualContent);
+	}
+
+	/**
+	 * Returns an array of Missing related Entities for the
+	 * given $relation
+	 *
+	 * @param  string $relation
+	 * @return array
+	 */
+	public function getMissingEntities($relation)
+	{
+		$cachedRelations = $this->getCachedAttribute($relation);
+
+		if (! is_null($cachedRelations)) {
+			$missing = [];
+
+			foreach ($cachedRelations as $hash) {
+				if (! $this->getRelatedAggregateFromHash($hash, $relation)) {
+					$missing[] = $hash;
+				}
+			}
+
+			return $missing;
+		} else {
+			return [];
+		}
+	}
        
-    /**
-     * Get Relationships who have dirty attributes / dirty relationships
-     *
-     * @return array
-     */
-    public function getDirtyRelationships()
-    {
-        $dirtyAggregates = [];
-
-        foreach ($this->relationships as $relation) {
-            foreach ($relation as $aggregate) {
-                if (! $aggregate->exists() || $aggregate->isDirty() || count($aggregate->getDirtyRelationships() > 0)) {
-                    $dirtyAggregates[] = $aggregate;
-                }
-            }
-        }
-
-        return $dirtyAggregates;
-    }
+	/**
+	 * Get Relationships who have dirty attributes / dirty relationships
+	 *
+	 * @return array
+	 */
+	public function getDirtyRelationships()
+	{
+		$dirtyAggregates = [];
+
+		foreach ($this->relationships as $relation) {
+			foreach ($relation as $aggregate) {
+				if (! $aggregate->exists() || $aggregate->isDirty() || count($aggregate->getDirtyRelationships() > 0)) {
+					$dirtyAggregates[] = $aggregate;
+				}
+			}
+		}
+
+		return $dirtyAggregates;
+	}
     
-    /**
-     * Compare the object's raw attributes with the record in cache
-     *
-     * @return boolean
-     */
-    public function isDirty()
-    {
-        if (count($this->getDirtyRawAttributes()) > 0) {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    /**
-     * Get Raw Entity's attributes, as they are represented
-     * in the database, including value objects & foreign keys
-     *
-     * @return array
-     */
-    public function getRawAttributes()
-    {
-        $attributes = $this->wrappedEntity->getEntityAttributes();
-
-        foreach ($this->entityMap->getRelationships() as $relation) {
-            unset($attributes[$relation]);
-        }
-
-        $attributes = $this->flattenEmbeddables($attributes);
-
-        $foreignKeys = $this->getForeignKeyAttributes();
-
-        return $attributes + $foreignKeys;
-    }
-
-    /**
-     * Convert Value Objects to raw db attributes
-     *
-     * @param  array $attributes
-     * @return array
-     */
-    protected function flattenEmbeddables($attributes)
-    {
-        $embeddables = $this->entityMap->getEmbeddables();
+	/**
+	 * Compare the object's raw attributes with the record in cache
+	 *
+	 * @return boolean
+	 */
+	public function isDirty()
+	{
+		if (count($this->getDirtyRawAttributes()) > 0) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * Get Raw Entity's attributes, as they are represented
+	 * in the database, including value objects & foreign keys
+	 *
+	 * @return array
+	 */
+	public function getRawAttributes()
+	{
+		$attributes = $this->wrappedEntity->getEntityAttributes();
+
+		foreach ($this->entityMap->getRelationships() as $relation) {
+			unset($attributes[$relation]);
+		}
+
+		$attributes = $this->flattenEmbeddables($attributes);
+
+		$foreignKeys = $this->getForeignKeyAttributes();
+
+		return $attributes + $foreignKeys;
+	}
+
+	/**
+	 * Convert Value Objects to raw db attributes
+	 *
+	 * @param  array $attributes
+	 * @return array
+	 */
+	protected function flattenEmbeddables($attributes)
+	{
+		$embeddables = $this->entityMap->getEmbeddables();
         
-        foreach ($embeddables as $localKey => $embed) {
-            // Retrieve the value object from the entity's attributes
-            $valueObject = $attributes[$localKey];
+		foreach ($embeddables as $localKey => $embed) {
+			// Retrieve the value object from the entity's attributes
+			$valueObject = $attributes[$localKey];
 
-            // Unset the corresponding key
-            unset($attributes[$localKey]);
+			// Unset the corresponding key
+			unset($attributes[$localKey]);
 
-            // TODO Make wrapper object compatible with value objects
-            $valueObjectAttributes = $valueObject->getEntityAttributes();
+			// TODO Make wrapper object compatible with value objects
+			$valueObjectAttributes = $valueObject->getEntityAttributes();
 
-            // Now (if setup in the entity map) we prefix the value object's
-            // attributes with the snake_case name of the embedded class.
-            $prefix = snake_case(class_basename($embed));
+			// Now (if setup in the entity map) we prefix the value object's
+			// attributes with the snake_case name of the embedded class.
+			$prefix = snake_case(class_basename($embed));
 
-            foreach ($valueObjectAttributes as $key=>$value) {
-                $valueObjectAttributes[$prefix.'_'.$key] = $value;
-                unset($valueObjectAttributes[$key]);
-            }
+			foreach ($valueObjectAttributes as $key=>$value) {
+				$valueObjectAttributes[$prefix.'_'.$key] = $value;
+				unset($valueObjectAttributes[$key]);
+			}
 
-            $attributes = array_merge($attributes, $valueObjectAttributes);
-        }
+			$attributes = array_merge($attributes, $valueObjectAttributes);
+		}
         
-        return $attributes;
-    }
-
-    /**
-     * Return's entity raw attributes in the state they were at last
-     * query.
-     *
-     * @return array
-     */
-    protected function getCachedRawAttributes(array $columns = null)
-    {
-        $cachedAttributes = $this->getCache()->get($this->getEntityId());
-
-        if (is_null($columns)) {
-            return $cachedAttributes;
-        } else {
-            return array_only($cachedAttributes, $columns);
-        }
-    }
-
-    /**
-     * Return a single attribute from the cache
-     * @param  string $key
-     * @return mixed
-     */
-    protected function getCachedAttribute($key)
-    {
-        $cachedAttributes = $this->getCache()->get($this->getEntityId());
-
-        if (! array_key_exists($key, $cachedAttributes)) {
-            return null;
-        } else {
-            return $cachedAttributes[$key];
-        }
-    }
-
-    /**
-     * Convert related Entity's attributes to foreign keys
-     *
-     * @return array
-     */
-    protected function getForeignKeyAttributes()
-    {
-        $foreignKeys = [];
-
-        foreach ($this->entityMap->getLocalRelationships() as $relation) {
-            // check if relationship has been parsed, meaning it has an actual object
-            // in the entity's attributes
-            if ($this->isActualRelationships($relation)) {
-                $foreignKeys = $foreignKeys + $this->getForeignKeyAttributesFromRelation($relation);
-            }
-        }
-
-        if (! is_null($this->parent)) {
-            $foreignKeys = $foreignKeys + $this->getForeignKeyAttributesFromParent();
-        }
-
-        return $foreignKeys;
-    }
-
-    /**
-     * Return an associative array containing the key-value pair(s) from
-     * the related entity.
-     *
-     * @param  string $relation
-     * @return array
-     */
-    protected function getForeignKeyAttributesFromRelation($relation)
-    {
-        $localRelations = $this->entityMap->getLocalRelationships();
-
-        if (in_array($relation, $localRelations)) {
-            // Call Relationship's method
-            $relationship = $this->entityMap->$relation($this->getEntityObject());
-
-            $relatedAggregate = $this->relationships[$relation][0];
-
-            return $relationship->getForeignKeyValuePair($relatedAggregate->getEntityObject());
-        } else {
-            return [];
-        }
-    }
-
-    /**
-     * Get foreign key attribute(s) from a parent entity in this
-     * aggregate context
-     *
-     * @param  string $relation
-     * @return array
-     */
-    protected function getForeignKeyAttributesFromParent()
-    {
-        $parentMap = $this->parent->getEntityMap();
-
-        $parentForeignRelations = $parentMap->getForeignRelationships();
-        $parentPivotRelations = $parentMap->getPivotRelationships();
-
-        $parentRelation = $this->parentRelationship;
-
-        if (in_array($parentRelation, $parentForeignRelations)
-            && ! in_array($parentRelation, $parentPivotRelations)) {
-            $parentObject = $this->parent->getEntityObject();
-
-            // Call Relationship's method on parent map
-            $relationship = $parentMap->$parentRelation($parentObject);
-
-            return $relationship->getForeignKeyValuePair();
-        } else {
-            return [];
-        }
-    }
-
-    /**
-     * Update Pivot records on loaded relationships, by comparing the
-     * values from the Entity Cache to the actual relationship inside
-     * the aggregated entity.
-     *
-     * @return void
-     */
-    public function updatePivotRecords()
-    {
-        $pivots = $this->entityMap->getPivotRelationships();
-
-        foreach ($pivots as $pivot) {
-            if (array_key_exists($pivot, $this->relationships)) {
-                $this->updatePivotRelation($pivot);
-            }
-        }
-    }
-
-    /**
-     * Update Single pivot relationship
-     *
-     * @param  string $relation
-     * @return void
-     */
-    protected function updatePivotRelation($relation)
-    {
-        $hashes = $this->getEntityHashesFromRelation($relation);
-
-        $cachedAttributes = $this->getCachedRawAttributes();
-
-        if (array_key_exists($relation, $cachedAttributes)) {
-            // Compare the two array of hashes to find out existing
-            // pivot records, and the ones to be created.
-            $new = array_diff($hashes, array_keys($cachedAttributes[$relation]));
-            $existing = array_intersect($hashes, array_keys($cachedAttributes[$relation]));
-        } else {
-            $existing = [];
-            $new = $hashes;
-        }
-
-        if (count($new) > 0) {
-            $relatedCollection = $this->getEntityAttribute($relation);
-
-            $pivots = $this->getRelatedAggregatesFromHashes($new, $relation);
-
-            $this->entityMap->$relation($this->getEntityObject())->createPivots($pivots);
-        }
-
-        if (count($existing) > 0) {
-            foreach ($existing as $pivotHash) {
-                $this->updatePivotIfDirty($pivotHash, $relation);
-            }
-        }
-    }
-
-    /**
-     * Compare existing pivot record in cache and update it
-     * if the pivot attributes are dirty
-     *
-     * @param  string $pivotHash
-     * @param  string $relation
-     * @return void
-     */
-    protected function updatePivotIfDirty($pivotHash, $relation)
-    {
-        $aggregate = $this->getRelatedAggregateFromHash($pivotHash, $relation);
-
-        if ($aggregate->hasAttribute('pivot')) {
-            $pivot = $aggregate->getEntityAttribute('pivot')->getEntityAttributes();
-
-            $cachedPivotAttributes = $this->getPivotAttributesFromCache($pivotHash, $relation);
-
-            $actualPivotAttributes = array_only($pivot, array_keys($cachedPivotAttributes));
-
-            $dirty = $this->getDirtyAttributes($actualPivotAttributes, $cachedPivotAttributes);
+		return $attributes;
+	}
+
+	/**
+	 * Return's entity raw attributes in the state they were at last
+	 * query.
+	 *
+	 * @return array
+	 */
+	protected function getCachedRawAttributes(array $columns = null)
+	{
+		$cachedAttributes = $this->getCache()->get($this->getEntityId());
+
+		if (is_null($columns)) {
+			return $cachedAttributes;
+		} else {
+			return array_only($cachedAttributes, $columns);
+		}
+	}
+
+	/**
+	 * Return a single attribute from the cache
+	 * @param  string $key
+	 * @return mixed
+	 */
+	protected function getCachedAttribute($key)
+	{
+		$cachedAttributes = $this->getCache()->get($this->getEntityId());
+
+		if (! array_key_exists($key, $cachedAttributes)) {
+			return null;
+		} else {
+			return $cachedAttributes[$key];
+		}
+	}
+
+	/**
+	 * Convert related Entity's attributes to foreign keys
+	 *
+	 * @return array
+	 */
+	protected function getForeignKeyAttributes()
+	{
+		$foreignKeys = [];
+
+		foreach ($this->entityMap->getLocalRelationships() as $relation) {
+			// check if relationship has been parsed, meaning it has an actual object
+			// in the entity's attributes
+			if ($this->isActualRelationships($relation)) {
+				$foreignKeys = $foreignKeys + $this->getForeignKeyAttributesFromRelation($relation);
+			}
+		}
+
+		if (! is_null($this->parent)) {
+			$foreignKeys = $foreignKeys + $this->getForeignKeyAttributesFromParent();
+		}
+
+		return $foreignKeys;
+	}
+
+	/**
+	 * Return an associative array containing the key-value pair(s) from
+	 * the related entity.
+	 *
+	 * @param  string $relation
+	 * @return array
+	 */
+	protected function getForeignKeyAttributesFromRelation($relation)
+	{
+		$localRelations = $this->entityMap->getLocalRelationships();
+
+		if (in_array($relation, $localRelations)) {
+			// Call Relationship's method
+			$relationship = $this->entityMap->$relation($this->getEntityObject());
+
+			$relatedAggregate = $this->relationships[$relation][0];
+
+			return $relationship->getForeignKeyValuePair($relatedAggregate->getEntityObject());
+		} else {
+			return [];
+		}
+	}
+
+	/**
+	 * Get foreign key attribute(s) from a parent entity in this
+	 * aggregate context
+	 *
+	 * @param  string $relation
+	 * @return array
+	 */
+	protected function getForeignKeyAttributesFromParent()
+	{
+		$parentMap = $this->parent->getEntityMap();
+
+		$parentForeignRelations = $parentMap->getForeignRelationships();
+		$parentPivotRelations = $parentMap->getPivotRelationships();
+
+		$parentRelation = $this->parentRelationship;
+
+		if (in_array($parentRelation, $parentForeignRelations)
+			&& ! in_array($parentRelation, $parentPivotRelations)) {
+			$parentObject = $this->parent->getEntityObject();
+
+			// Call Relationship's method on parent map
+			$relationship = $parentMap->$parentRelation($parentObject);
+
+			return $relationship->getForeignKeyValuePair();
+		} else {
+			return [];
+		}
+	}
+
+	/**
+	 * Update Pivot records on loaded relationships, by comparing the
+	 * values from the Entity Cache to the actual relationship inside
+	 * the aggregated entity.
+	 *
+	 * @return void
+	 */
+	public function updatePivotRecords()
+	{
+		$pivots = $this->entityMap->getPivotRelationships();
+
+		foreach ($pivots as $pivot) {
+			if (array_key_exists($pivot, $this->relationships)) {
+				$this->updatePivotRelation($pivot);
+			}
+		}
+	}
+
+	/**
+	 * Update Single pivot relationship
+	 *
+	 * @param  string $relation
+	 * @return void
+	 */
+	protected function updatePivotRelation($relation)
+	{
+		$hashes = $this->getEntityHashesFromRelation($relation);
+
+		$cachedAttributes = $this->getCachedRawAttributes();
+
+		if (array_key_exists($relation, $cachedAttributes)) {
+			// Compare the two array of hashes to find out existing
+			// pivot records, and the ones to be created.
+			$new = array_diff($hashes, array_keys($cachedAttributes[$relation]));
+			$existing = array_intersect($hashes, array_keys($cachedAttributes[$relation]));
+		} else {
+			$existing = [];
+			$new = $hashes;
+		}
+
+		if (count($new) > 0) {
+			$relatedCollection = $this->getEntityAttribute($relation);
+
+			$pivots = $this->getRelatedAggregatesFromHashes($new, $relation);
+
+			$this->entityMap->$relation($this->getEntityObject())->createPivots($pivots);
+		}
+
+		if (count($existing) > 0) {
+			foreach ($existing as $pivotHash) {
+				$this->updatePivotIfDirty($pivotHash, $relation);
+			}
+		}
+	}
+
+	/**
+	 * Compare existing pivot record in cache and update it
+	 * if the pivot attributes are dirty
+	 *
+	 * @param  string $pivotHash
+	 * @param  string $relation
+	 * @return void
+	 */
+	protected function updatePivotIfDirty($pivotHash, $relation)
+	{
+		$aggregate = $this->getRelatedAggregateFromHash($pivotHash, $relation);
+
+		if ($aggregate->hasAttribute('pivot')) {
+			$pivot = $aggregate->getEntityAttribute('pivot')->getEntityAttributes();
+
+			$cachedPivotAttributes = $this->getPivotAttributesFromCache($pivotHash, $relation);
+
+			$actualPivotAttributes = array_only($pivot, array_keys($cachedPivotAttributes));
+
+			$dirty = $this->getDirtyAttributes($actualPivotAttributes, $cachedPivotAttributes);
             
-            if (count($dirty) > 0) {
-                $id = $aggregate->getEntityId();
-
-                $this->entityMap->$relation($this->getEntityObject())->updateExistingPivot($id, $dirty);
-            }
-        }
-    }
-
-    /**
-     * Compare two attributes array and return dirty attributes
-     *
-     * @param  array  $actual
-     * @param  array  $cached
-     * @return array
-     */
-    protected function getDirtyAttributes(array $actual, array $cached)
-    {
-        $dirty = [];
-
-        foreach ($actual as $key => $value) {
-            if (! $this->originalIsNumericallyEquivalent($value, $cached[$key])) {
-                $dirty[$key] = $actual[$key];
-            }
-        }
-
-        return $dirty;
-    }
-
-    /**
-     *
-     * @param  string $pivotHash
-     * @param  string $relation
-     * @return array
-     */
-    protected function getPivotAttributesFromCache($pivotHash, $relation)
-    {
-        $cachedAttributes = $this->getCachedRawAttributes();
-
-        $cachedRelations = $cachedAttributes[$relation];
-
-        foreach ($cachedRelations as $cachedRelation) {
-            if ($cachedRelation == $pivotHash) {
-                return $cachedRelation->getPivotAttributes();
-            }
-        }
-    }
-
-    /**
-     * Returns an array of related Aggregates from its entity hashes
-     *
-     * @param  array  $hashes
-     * @param  string $relation
-     * @return array
-     */
-    protected function getRelatedAggregatesFromHashes(array $hashes, $relation)
-    {
-        $related = [];
-
-        foreach ($hashes as $hash) {
-            $aggregate = $this->getRelatedAggregateFromHash($hash, $relation);
-
-            if (! is_null($aggregate)) {
-                $related[] = $aggregate;
-            }
-        }
-
-        return $related;
-    }
-
-    /**
-     * Get related aggregate from its hash
-     *
-     * @param  string $hash
-     * @param  string $relation
-     * @return \Analogue\ORM\System\Aggregate | null
-     */
-    protected function getRelatedAggregateFromHash($hash, $relation)
-    {
-        foreach ($this->relationships[$relation] as $aggregate) {
-            if ($aggregate->getEntityHash() == $hash) {
-                return $aggregate;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Return an array of Entity Hashes from a specific relation
-     *
-     * @param  string $relation
-     * @return array
-     */
-    protected function getEntityHashesFromRelation($relation)
-    {
-        return array_map(function ($aggregate) {
-            return $aggregate->getEntityHash();
-        }, $this->relationships[$relation]);
-    }
-
-    /**
-     * Check the existence of an actual relationship
-     *
-     * @param  string $relation
-     * @return boolean
-     */
-    protected function isActualRelationships($relation)
-    {
-        return array_key_exists($relation, $this->relationships)
-            && count($this->relationships[$relation]) > 0;
-    }
-
-    /**
-     * Return cache instance for the current entity type
-     *
-     * @return \Analogue\ORM\System\EntityCache
-     */
-    protected function getCache()
-    {
-        return $this->mapper->getEntityCache();
-    }
-
-    /**
-     * Get Only Raw Entiy's attributes which have been modified
-     * since last query
-     *
-     * @return array
-     */
-    public function getDirtyRawAttributes()
-    {
-        $attributes = $this->getRawAttributes();
-        $cachedAttributes = $this->getCachedRawAttributes(array_keys($attributes));
-
-        $dirty = [];
-
-        foreach ($attributes as $key => $value) {
-            if ($this->isRelation($key) || $key == 'pivot') {
-                continue;
-            }
-
-            if (! array_key_exists($key, $cachedAttributes) && ! $value instanceof Pivot) {
-                $dirty[$key] = $value;
-            } elseif ($value !== $cachedAttributes[$key] &&
-                ! $this->originalIsNumericallyEquivalent($value, $cachedAttributes[$key])) {
-                $dirty[$key] = $value;
-            }
-        }
-
-        return $dirty;
-    }
-
-    protected function isRelation($key)
-    {
-        return in_array($key, $this->entityMap->getRelationships());
-    }
-
-    /**
-     * Determine if the new and old values for a given key are numerically equivalent.
-     *
-     * @return boolean
-     */
-    protected function originalIsNumericallyEquivalent($current, $original)
-    {
-        return is_numeric($current) && is_numeric($original) && strcmp((string) $current, (string) $original) === 0;
-    }
-
-    /**
-     * Get the underlying entity object
-     *
-     * @return mixed
-     */
-    public function getEntityObject()
-    {
-        return $this->wrappedEntity->getObject();
-    }
-
-    /**
-     * Return the Mapper instance for the current Entity Type
-     *
-     * @return \Analogue\ORM\System\Mapper
-     */
-    public function getMapper()
-    {
-        return $this->mapper;
-    }
-
-    /**
-     * Check that the entity already exists in the database, by checking
-     * if it has an EntityCache record
-     *
-     * @return boolean
-     */
-    public function exists()
-    {
-        return $this->getCache()->has($this->getEntityId());
-    }
-
-    /**
-     * Set the object attribute raw values (hydration)
-     *
-     * @param array $attributes
-     */
-    public function setEntityAttributes(array $attributes)
-    {
-        $this->wrappedEntity->setEntityAttributes($attributes);
-    }
-
-    /**
-     * Get the raw object's values.
-     *
-     * @return array
-     */
-    public function getEntityAttributes()
-    {
-        return $this->wrappedEntity->getEntityAttributes();
-    }
-
-    /**
-     * Set the raw entity attributes
-     * @param string $key
-     * @param string $value
-     */
-    public function setEntityAttribute($key, $value)
-    {
-        $this->wrappedEntity->setEntityAttribute($key, $value);
-    }
-
-    /**
-     * Return the entity's attribute
-     * @param  string $key
-     * @return mixed
-     */
-    public function getEntityAttribute($key)
-    {
-        return $this->wrappedEntity->getEntityAttribute($key);
-    }
-
-    /**
-     * Does the attribute exists on the entity
-     *
-     * @param  string  $key
-     * @return boolean
-     */
-    public function hasAttribute($key)
-    {
-        return $this->wrappedEntity->hasAttribute($key);
-    }
-
-    /**
-     * Set the lazyloading proxies on the wrapped entity
-     *
-     * @return void
-     */
-    public function setProxies()
-    {
-        return $this->wrappedEntity->setProxies();
-    }
+			if (count($dirty) > 0) {
+				$id = $aggregate->getEntityId();
+
+				$this->entityMap->$relation($this->getEntityObject())->updateExistingPivot($id, $dirty);
+			}
+		}
+	}
+
+	/**
+	 * Compare two attributes array and return dirty attributes
+	 *
+	 * @param  array  $actual
+	 * @param  array  $cached
+	 * @return array
+	 */
+	protected function getDirtyAttributes(array $actual, array $cached)
+	{
+		$dirty = [];
+
+		foreach ($actual as $key => $value) {
+			if (! $this->originalIsNumericallyEquivalent($value, $cached[$key])) {
+				$dirty[$key] = $actual[$key];
+			}
+		}
+
+		return $dirty;
+	}
+
+	/**
+	 *
+	 * @param  string $pivotHash
+	 * @param  string $relation
+	 * @return array
+	 */
+	protected function getPivotAttributesFromCache($pivotHash, $relation)
+	{
+		$cachedAttributes = $this->getCachedRawAttributes();
+
+		$cachedRelations = $cachedAttributes[$relation];
+
+		foreach ($cachedRelations as $cachedRelation) {
+			if ($cachedRelation == $pivotHash) {
+				return $cachedRelation->getPivotAttributes();
+			}
+		}
+	}
+
+	/**
+	 * Returns an array of related Aggregates from its entity hashes
+	 *
+	 * @param  array  $hashes
+	 * @param  string $relation
+	 * @return array
+	 */
+	protected function getRelatedAggregatesFromHashes(array $hashes, $relation)
+	{
+		$related = [];
+
+		foreach ($hashes as $hash) {
+			$aggregate = $this->getRelatedAggregateFromHash($hash, $relation);
+
+			if (! is_null($aggregate)) {
+				$related[] = $aggregate;
+			}
+		}
+
+		return $related;
+	}
+
+	/**
+	 * Get related aggregate from its hash
+	 *
+	 * @param  string $hash
+	 * @param  string $relation
+	 * @return \Analogue\ORM\System\Aggregate | null
+	 */
+	protected function getRelatedAggregateFromHash($hash, $relation)
+	{
+		foreach ($this->relationships[$relation] as $aggregate) {
+			if ($aggregate->getEntityHash() == $hash) {
+				return $aggregate;
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Return an array of Entity Hashes from a specific relation
+	 *
+	 * @param  string $relation
+	 * @return array
+	 */
+	protected function getEntityHashesFromRelation($relation)
+	{
+		return array_map(function ($aggregate) {
+			return $aggregate->getEntityHash();
+		}, $this->relationships[$relation]);
+	}
+
+	/**
+	 * Check the existence of an actual relationship
+	 *
+	 * @param  string $relation
+	 * @return boolean
+	 */
+	protected function isActualRelationships($relation)
+	{
+		return array_key_exists($relation, $this->relationships)
+			&& count($this->relationships[$relation]) > 0;
+	}
+
+	/**
+	 * Return cache instance for the current entity type
+	 *
+	 * @return \Analogue\ORM\System\EntityCache
+	 */
+	protected function getCache()
+	{
+		return $this->mapper->getEntityCache();
+	}
+
+	/**
+	 * Get Only Raw Entiy's attributes which have been modified
+	 * since last query
+	 *
+	 * @return array
+	 */
+	public function getDirtyRawAttributes()
+	{
+		$attributes = $this->getRawAttributes();
+		$cachedAttributes = $this->getCachedRawAttributes(array_keys($attributes));
+
+		$dirty = [];
+
+		foreach ($attributes as $key => $value) {
+			if ($this->isRelation($key) || $key == 'pivot') {
+				continue;
+			}
+
+			if (! array_key_exists($key, $cachedAttributes) && ! $value instanceof Pivot) {
+				$dirty[$key] = $value;
+			} elseif ($value !== $cachedAttributes[$key] &&
+				! $this->originalIsNumericallyEquivalent($value, $cachedAttributes[$key])) {
+				$dirty[$key] = $value;
+			}
+		}
+
+		return $dirty;
+	}
+
+	protected function isRelation($key)
+	{
+		return in_array($key, $this->entityMap->getRelationships());
+	}
+
+	/**
+	 * Determine if the new and old values for a given key are numerically equivalent.
+	 *
+	 * @return boolean
+	 */
+	protected function originalIsNumericallyEquivalent($current, $original)
+	{
+		return is_numeric($current) && is_numeric($original) && strcmp((string) $current, (string) $original) === 0;
+	}
+
+	/**
+	 * Get the underlying entity object
+	 *
+	 * @return mixed
+	 */
+	public function getEntityObject()
+	{
+		return $this->wrappedEntity->getObject();
+	}
+
+	/**
+	 * Return the Mapper instance for the current Entity Type
+	 *
+	 * @return \Analogue\ORM\System\Mapper
+	 */
+	public function getMapper()
+	{
+		return $this->mapper;
+	}
+
+	/**
+	 * Check that the entity already exists in the database, by checking
+	 * if it has an EntityCache record
+	 *
+	 * @return boolean
+	 */
+	public function exists()
+	{
+		return $this->getCache()->has($this->getEntityId());
+	}
+
+	/**
+	 * Set the object attribute raw values (hydration)
+	 *
+	 * @param array $attributes
+	 */
+	public function setEntityAttributes(array $attributes)
+	{
+		$this->wrappedEntity->setEntityAttributes($attributes);
+	}
+
+	/**
+	 * Get the raw object's values.
+	 *
+	 * @return array
+	 */
+	public function getEntityAttributes()
+	{
+		return $this->wrappedEntity->getEntityAttributes();
+	}
+
+	/**
+	 * Set the raw entity attributes
+	 * @param string $key
+	 * @param string $value
+	 */
+	public function setEntityAttribute($key, $value)
+	{
+		$this->wrappedEntity->setEntityAttribute($key, $value);
+	}
+
+	/**
+	 * Return the entity's attribute
+	 * @param  string $key
+	 * @return mixed
+	 */
+	public function getEntityAttribute($key)
+	{
+		return $this->wrappedEntity->getEntityAttribute($key);
+	}
+
+	/**
+	 * Does the attribute exists on the entity
+	 *
+	 * @param  string  $key
+	 * @return boolean
+	 */
+	public function hasAttribute($key)
+	{
+		return $this->wrappedEntity->hasAttribute($key);
+	}
+
+	/**
+	 * Set the lazyloading proxies on the wrapped entity
+	 *
+	 * @return void
+	 */
+	public function setProxies()
+	{
+		return $this->wrappedEntity->setProxies();
+	}
 }

Spacing +20 added lines, -20 removed lines

@@ -122,7 +122,7 @@ 
      */
     protected function parseForCommonValues($relation)
     {
-        if (! $this->hasAttribute($relation)) {
+        if (!$this->hasAttribute($relation)) {
             // If no attribute exists for this relationships
             // we'll make it a simple empty array. This will
             // save us from constantly checking for the attributes
@@ -155,7 +155,7 @@ 
      */
     protected function parseSingleRelationship($relation)
     {
-        if (! $value = $this->parseForCommonValues($relation)) {
+        if (!$value = $this->parseForCommonValues($relation)) {
             return true;
         }
         
@@ -163,7 +163,7 @@ 
             throw new MappingException("Entity's attribute $relation should not be array, or collection");
         }
 
-        if ($value instanceof EntityProxy && ! $value->isLoaded()) {
+        if ($value instanceof EntityProxy && !$value->isLoaded()) {
             $this->relationships[$relation] = [];
             return true;
         }
@@ -198,7 +198,7 @@ 
      */
     protected function isParentOrRoot($value)
     {
-        if (! is_null($this->root)) {
+        if (!is_null($this->root)) {
             $rootClass = get_class($this->root->getEntityObject());
             if ($rootClass == get_class($value)) {
                 return true;
@@ -206,7 +206,7 @@ 
         }
 
 
-        if (! is_null($this->parent)) {
+        if (!is_null($this->parent)) {
             $parentClass = get_class($this->parent->getEntityObject());
             if ($parentClass == get_class($value)) {
                 return true;
@@ -222,7 +222,7 @@ 
      */
     protected function parseManyRelationship($relation)
     {
-        if (! $value = $this->parseForCommonValues($relation)) {
+        if (!$value = $this->parseForCommonValues($relation)) {
             return true;
         }
 
@@ -237,13 +237,13 @@ 
             $value = $value->getUnderlyingCollection();
         }
 
-        if ($value instanceof CollectionProxy && ! $value->isLoaded()) {
+        if ($value instanceof CollectionProxy && !$value->isLoaded()) {
             $value = $value->getAddedItems();
         }
 
         // At this point $value should be either an array or an instance
         // of a collection class.
-        if (! is_array($value) && ! $value instanceof Collection) {
+        if (!is_array($value) && !$value instanceof Collection) {
             throw new MappingException("'$relation' attribute should be array() or Collection");
         }
 
@@ -422,7 +422,7 @@ 
         $nonExisting = [];
 
         foreach ($this->relationships[$relation] as $aggregate) {
-            if (! $aggregate->exists()) {
+            if (!$aggregate->exists()) {
                 $nonExisting[] = $aggregate;
             }
         }
@@ -467,11 +467,11 @@ 
     {
         $cachedRelations = $this->getCachedAttribute($relation);
 
-        if (! is_null($cachedRelations)) {
+        if (!is_null($cachedRelations)) {
             $missing = [];
 
             foreach ($cachedRelations as $hash) {
-                if (! $this->getRelatedAggregateFromHash($hash, $relation)) {
+                if (!$this->getRelatedAggregateFromHash($hash, $relation)) {
                     $missing[] = $hash;
                 }
             }
@@ -493,7 +493,7 @@ 
 
         foreach ($this->relationships as $relation) {
             foreach ($relation as $aggregate) {
-                if (! $aggregate->exists() || $aggregate->isDirty() || count($aggregate->getDirtyRelationships() > 0)) {
+                if (!$aggregate->exists() || $aggregate->isDirty() || count($aggregate->getDirtyRelationships() > 0)) {
                     $dirtyAggregates[] = $aggregate;
                 }
             }
@@ -598,7 +598,7 @@ 
     {
         $cachedAttributes = $this->getCache()->get($this->getEntityId());
 
-        if (! array_key_exists($key, $cachedAttributes)) {
+        if (!array_key_exists($key, $cachedAttributes)) {
             return null;
         } else {
             return $cachedAttributes[$key];
@@ -622,7 +622,7 @@ 
             }
         }
 
-        if (! is_null($this->parent)) {
+        if (!is_null($this->parent)) {
             $foreignKeys = $foreignKeys + $this->getForeignKeyAttributesFromParent();
         }
 
@@ -669,7 +669,7 @@ 
         $parentRelation = $this->parentRelationship;
 
         if (in_array($parentRelation, $parentForeignRelations)
-            && ! in_array($parentRelation, $parentPivotRelations)) {
+            && !in_array($parentRelation, $parentPivotRelations)) {
             $parentObject = $this->parent->getEntityObject();
 
             // Call Relationship's method on parent map
@@ -777,7 +777,7 @@ 
         $dirty = [];
 
         foreach ($actual as $key => $value) {
-            if (! $this->originalIsNumericallyEquivalent($value, $cached[$key])) {
+            if (!$this->originalIsNumericallyEquivalent($value, $cached[$key])) {
                 $dirty[$key] = $actual[$key];
             }
         }
@@ -818,7 +818,7 @@ 
         foreach ($hashes as $hash) {
             $aggregate = $this->getRelatedAggregateFromHash($hash, $relation);
 
-            if (! is_null($aggregate)) {
+            if (!is_null($aggregate)) {
                 $related[] = $aggregate;
             }
         }
@@ -851,7 +851,7 @@ 
      */
     protected function getEntityHashesFromRelation($relation)
     {
-        return array_map(function ($aggregate) {
+        return array_map(function($aggregate) {
             return $aggregate->getEntityHash();
         }, $this->relationships[$relation]);
     }
@@ -896,10 +896,10 @@ 
                 continue;
             }
 
-            if (! array_key_exists($key, $cachedAttributes) && ! $value instanceof Pivot) {
+            if (!array_key_exists($key, $cachedAttributes) && !$value instanceof Pivot) {
                 $dirty[$key] = $value;
             } elseif ($value !== $cachedAttributes[$key] &&
-                ! $this->originalIsNumericallyEquivalent($value, $cachedAttributes[$key])) {
+                !$this->originalIsNumericallyEquivalent($value, $cachedAttributes[$key])) {
                 $dirty[$key] = $value;
             }
         }

Unused Use Statements -1 removed lines

@@ -9,7 +9,6 @@
 use Analogue\ORM\System\InternallyMappable;
 use Analogue\ORM\Relationships\Relationship;
 use Analogue\ORM\Exceptions\MappingException;
-use Analogue\ORM\System\Proxies\ProxyInterface;
 
 /**
  * The EntityCache class is responsible for tracking entity's attribute states

src/System/EntityBuilder.php

Doc Comments +2 added lines, -2 removed lines

@@ -108,7 +108,7 @@ 
     /**
      * Get the correct wrapper prototype corresponding to the object type
      *
-     * @return mixed
+     * @return InternallyMappable
      */
     protected function getWrapperInstance()
     {
@@ -174,7 +174,7 @@ 
     /**
      * Build lazy loading proxies for the current entity
      *
-     * @param \Analogue\ORM\Mappable $entity
+     * @param InternallyMappable $entity
      *
      * @return array
      */

Indentation +175 added lines, -175 removed lines

@@ -11,189 +11,189 @@
 class EntityBuilder
 {
 
-    /**
-     * The mapper for the entity to build
-     * @var \Analogue\ORM\System\Mapper
-     */
-    protected $mapper;
-
-    /**
-     * The Entity Map for the entity to build.
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * Relations that will be eager loaded on this query
-     *
-     * @var array
-     */
-    protected $eagerLoads;
-
-    /**
-     * Relations that will be lazy loaded on this query
-     *
-     * @var array
-     */
-    protected $lazyLoads;
-
-    /**
-     * Entity Wrapper Factory
-     * @var \Analogue\ORM\System\Wrappers\Factory
-     */
-    protected $factory;
-
-    public function __construct(Mapper $mapper, array $eagerLoads)
-    {
-        $this->mapper = $mapper;
-
-        $this->entityMap = $mapper->getEntityMap();
-
-        $this->eagerLoads = $eagerLoads;
-
-        $this->lazyLoads = $this->prepareLazyLoading();
-
-        $this->entityMap = $mapper->getEntityMap();
-
-        $this->factory = new Factory;
-    }
-
-    /**
-     * Convert a result set into an array of entities
-     *
-     * @param  array  $results
-     *
-     * @return array
-     */
-    public function build(array $results)
-    {
-        $entities = array();
-
-        //$prototype = $this->getWrapperPrototype();
-        //$prototype = $this->mapper->newInstance();
-
-        $keyName = $this->entityMap->getKeyName();
-
-        $tmpCache = [];
-
-        foreach ($results as $result) {
-            //$instance = clone $prototype;
-            $instance = $this->getWrapperInstance();
-
-            $resultArray = (array) $result;
-
-            $tmpCache[$resultArray[$keyName] ] = $resultArray;
-
-            // Hydrate any embedded Value Object
-            $this->hydrateValueObjects($resultArray);
-
-            $instance->setEntityAttributes($resultArray);
-
-            // Hydrate relation attributes with lazyloading proxies
-            if (count($this->lazyLoads) > 0) {
-                $proxies = $this->getLazyLoadingProxies($instance);
-                $instance->setEntityAttributes($resultArray + $proxies);
-            }
-
-            // Directly Unwrap the entity now that it has been hydrated
-            $entities[] = $instance->getObject();
-        }
-
-        $this->mapper->getEntityCache()->add($tmpCache);
-
-        return $entities;
-    }
-
-    /**
-     * Get the correct wrapper prototype corresponding to the object type
-     *
-     * @return mixed
-     */
-    protected function getWrapperInstance()
-    {
-        return $this->factory->make($this->mapper->newInstance());
-    }
-
-    /**
-     * Hydrate value object embedded in this entity
-     *
-     * @param  array $attributes
-     * @return void
-     */
-    protected function hydrateValueObjects(& $attributes)
-    {
-        foreach ($this->entityMap->getEmbeddables() as $localKey => $valueClass) {
-            $this->hydrateValueObject($attributes, $localKey, $valueClass);
-        }
-    }
-
-    /**
-     * Hydrate a single value object
-     *
-     * @param  array $attributes
-     * @param  string $localKey
-     * @param  string $valueClass
-     * @return void
-     */
-    protected function hydrateValueObject(& $attributes, $localKey, $valueClass)
-    {
-        $map = $this->mapper->getManager()->getValueMap($valueClass);
+	/**
+	 * The mapper for the entity to build
+	 * @var \Analogue\ORM\System\Mapper
+	 */
+	protected $mapper;
+
+	/**
+	 * The Entity Map for the entity to build.
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * Relations that will be eager loaded on this query
+	 *
+	 * @var array
+	 */
+	protected $eagerLoads;
+
+	/**
+	 * Relations that will be lazy loaded on this query
+	 *
+	 * @var array
+	 */
+	protected $lazyLoads;
+
+	/**
+	 * Entity Wrapper Factory
+	 * @var \Analogue\ORM\System\Wrappers\Factory
+	 */
+	protected $factory;
+
+	public function __construct(Mapper $mapper, array $eagerLoads)
+	{
+		$this->mapper = $mapper;
+
+		$this->entityMap = $mapper->getEntityMap();
+
+		$this->eagerLoads = $eagerLoads;
+
+		$this->lazyLoads = $this->prepareLazyLoading();
+
+		$this->entityMap = $mapper->getEntityMap();
+
+		$this->factory = new Factory;
+	}
+
+	/**
+	 * Convert a result set into an array of entities
+	 *
+	 * @param  array  $results
+	 *
+	 * @return array
+	 */
+	public function build(array $results)
+	{
+		$entities = array();
+
+		//$prototype = $this->getWrapperPrototype();
+		//$prototype = $this->mapper->newInstance();
+
+		$keyName = $this->entityMap->getKeyName();
+
+		$tmpCache = [];
+
+		foreach ($results as $result) {
+			//$instance = clone $prototype;
+			$instance = $this->getWrapperInstance();
+
+			$resultArray = (array) $result;
+
+			$tmpCache[$resultArray[$keyName] ] = $resultArray;
+
+			// Hydrate any embedded Value Object
+			$this->hydrateValueObjects($resultArray);
+
+			$instance->setEntityAttributes($resultArray);
+
+			// Hydrate relation attributes with lazyloading proxies
+			if (count($this->lazyLoads) > 0) {
+				$proxies = $this->getLazyLoadingProxies($instance);
+				$instance->setEntityAttributes($resultArray + $proxies);
+			}
+
+			// Directly Unwrap the entity now that it has been hydrated
+			$entities[] = $instance->getObject();
+		}
+
+		$this->mapper->getEntityCache()->add($tmpCache);
+
+		return $entities;
+	}
+
+	/**
+	 * Get the correct wrapper prototype corresponding to the object type
+	 *
+	 * @return mixed
+	 */
+	protected function getWrapperInstance()
+	{
+		return $this->factory->make($this->mapper->newInstance());
+	}
+
+	/**
+	 * Hydrate value object embedded in this entity
+	 *
+	 * @param  array $attributes
+	 * @return void
+	 */
+	protected function hydrateValueObjects(& $attributes)
+	{
+		foreach ($this->entityMap->getEmbeddables() as $localKey => $valueClass) {
+			$this->hydrateValueObject($attributes, $localKey, $valueClass);
+		}
+	}
+
+	/**
+	 * Hydrate a single value object
+	 *
+	 * @param  array $attributes
+	 * @param  string $localKey
+	 * @param  string $valueClass
+	 * @return void
+	 */
+	protected function hydrateValueObject(& $attributes, $localKey, $valueClass)
+	{
+		$map = $this->mapper->getManager()->getValueMap($valueClass);
 
-        $embeddedAttributes = $map->getAttributes();
+		$embeddedAttributes = $map->getAttributes();
 
-        //$nestedValueObjects = $map->getEmbeddables();
+		//$nestedValueObjects = $map->getEmbeddables();
 
-        $valueObject = $this->mapper->getManager()->getValueObjectInstance($valueClass);
+		$valueObject = $this->mapper->getManager()->getValueObjectInstance($valueClass);
 
-        foreach ($embeddedAttributes as $key) {
-            $prefix = snake_case(class_basename($valueClass)).'_';
+		foreach ($embeddedAttributes as $key) {
+			$prefix = snake_case(class_basename($valueClass)).'_';
 
-            $voWrapper = $this->factory->make($valueObject);
+			$voWrapper = $this->factory->make($valueObject);
 
-            $voWrapper->setEntityAttribute($key, $attributes[$prefix.$key]);
+			$voWrapper->setEntityAttribute($key, $attributes[$prefix.$key]);
             
-            unset($attributes[$prefix.$key]);
-        }
+			unset($attributes[$prefix.$key]);
+		}
         
-        $attributes[$localKey] = $valueObject;
-    }
-
-    /**
-     * Deduce the relationships that will be lazy loaded from the eagerLoads array
-     *
-     * @return array
-     */
-    protected function prepareLazyLoading()
-    {
-        $relations = $this->entityMap->getRelationships();
+		$attributes[$localKey] = $valueObject;
+	}
+
+	/**
+	 * Deduce the relationships that will be lazy loaded from the eagerLoads array
+	 *
+	 * @return array
+	 */
+	protected function prepareLazyLoading()
+	{
+		$relations = $this->entityMap->getRelationships();
        
-        return array_diff($relations, $this->eagerLoads);
-    }
-
-    /**
-     * Build lazy loading proxies for the current entity
-     *
-     * @param \Analogue\ORM\Mappable $entity
-     *
-     * @return array
-     */
-    protected function getLazyLoadingProxies(InternallyMappable $entity)
-    {
-        $proxies = [];
-
-        $singleRelations = $this->entityMap->getSingleRelationships();
-        $manyRelations = $this->entityMap->getManyRelationships();
-
-        foreach ($this->lazyLoads as $relation) {
-            if (in_array($relation, $singleRelations)) {
-                $proxies[$relation] = new EntityProxy($entity->getObject(), $relation);
-            }
-            if (in_array($relation, $manyRelations)) {
-                $proxies[$relation] = new CollectionProxy($entity->getObject(), $relation);
-            }
-        }
+		return array_diff($relations, $this->eagerLoads);
+	}
+
+	/**
+	 * Build lazy loading proxies for the current entity
+	 *
+	 * @param \Analogue\ORM\Mappable $entity
+	 *
+	 * @return array
+	 */
+	protected function getLazyLoadingProxies(InternallyMappable $entity)
+	{
+		$proxies = [];
+
+		$singleRelations = $this->entityMap->getSingleRelationships();
+		$manyRelations = $this->entityMap->getManyRelationships();
+
+		foreach ($this->lazyLoads as $relation) {
+			if (in_array($relation, $singleRelations)) {
+				$proxies[$relation] = new EntityProxy($entity->getObject(), $relation);
+			}
+			if (in_array($relation, $manyRelations)) {
+				$proxies[$relation] = new CollectionProxy($entity->getObject(), $relation);
+			}
+		}
         
-        return $proxies;
-    }
+		return $proxies;
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -83,7 +83,7 @@
 
             $resultArray = (array) $result;
 
-            $tmpCache[$resultArray[$keyName] ] = $resultArray;
+            $tmpCache[$resultArray[$keyName]] = $resultArray;
 
             // Hydrate any embedded Value Object
             $this->hydrateValueObjects($resultArray);

src/System/EntityCache.php

Doc Comments +4 added lines, -5 removed lines

@@ -190,8 +190,8 @@ 
      * Cache a many relationship
      *
      * @param  [type]       $parentKey    [description]
-     * @param  [type]       $relation     [description]
-     * @param  [type]       $results      [description]
+     * @param  string       $relation     [description]
+     * @param  EntityCollection       $results      [description]
      * @param  Relationship $relationship [description]
      * @return [type]                     [description]
      */
@@ -212,8 +212,8 @@ 
      * Cache a single relationship
      *
      * @param  [type]       $parentKey    [description]
-     * @param  [type]       $relation     [description]
-     * @param  [type]       $results      [description]
+     * @param  string       $relation     [description]
+     * @param  Mappable       $result      [description]
      * @param  Relationship $relationship [description]
      * @return [type]                     [description]
      */
@@ -253,7 +253,6 @@ 
     /**
      * Transform an Aggregated Entity into a cache record
      *
-     * @param  Aggregate $entity
      * @return array
      */
     protected function transform(Aggregate $aggregatedEntity)

Unused Use Statements -1 removed lines

@@ -9,7 +9,6 @@
 use Analogue\ORM\System\InternallyMappable;
 use Analogue\ORM\Relationships\Relationship;
 use Analogue\ORM\Exceptions\MappingException;
-use Analogue\ORM\System\Proxies\ProxyInterface;
 
 /**
  * The EntityCache class is responsible for tracking entity's attribute states

Indentation +289 added lines, -289 removed lines

@@ -18,302 +18,302 @@
 class EntityCache
 {
 
-    /**
-     * Entity's raw attributes/relationships
-     *
-     * @var array
-     */
-    protected $cache = [];
-
-    /**
-     * Entity Map for the current Entity Type
-     * @var [type]
-     */
-    protected $entityMap;
-
-    /**
-     * Wrapper factory
-     *
-     * @var \Analogue\ORM\System\Wrappers\Factory
-     */
-    protected $factory;
-
-    /**
-     * Associative array containing list of pivot attributes per relationship
-     * so we don't have to call relationship method on refresh.
-     *
-     * @var array
-     */
-    protected $pivotAttributes = [];
-
-    public function __construct(EntityMap $entityMap)
-    {
-        $this->entityMap = $entityMap;
-
-        $this->factory = new Factory;
-    }
-
-    /**
-     * Add an array of key=>attributes representing
-     * the initial state of loaded entities.
-     *
-     * @param array $entities
-     */
-    public function add(array $entities)
-    {
-        if (count($this->cache) == 0) {
-            $this->cache = $entities;
-        } else {
-            $this->mergeCacheResults($entities);
-        }
-    }
-
-    /**
-     * Retrieve initial attributes for a single entity
-     *
-     * @param  string $id
-     * @return array
-     */
-    public function get($id)
-    {
-        if ($this->has($id)) {
-            return $this->cache[$id];
-        } else {
-            return [];
-        }
-    }
-
-    /**
-     * Check if a record for this id exists.
-     *
-     * @param  string  $id
-     * @return boolean
-     */
-    public function has($id)
-    {
-        return array_key_exists($id, $this->cache);
-    }
-
-    /**
-     * Combine new result set with existing attributes in
-     * cache.
-     *
-     * @param  array $entities
-     * @return void
-     */
-    protected function mergeCacheResults($entities)
-    {
-        foreach ($entities as $key => $entity) {
-            if (array_key_exists($key, $this->cache)) {
-                /*
+	/**
+	 * Entity's raw attributes/relationships
+	 *
+	 * @var array
+	 */
+	protected $cache = [];
+
+	/**
+	 * Entity Map for the current Entity Type
+	 * @var [type]
+	 */
+	protected $entityMap;
+
+	/**
+	 * Wrapper factory
+	 *
+	 * @var \Analogue\ORM\System\Wrappers\Factory
+	 */
+	protected $factory;
+
+	/**
+	 * Associative array containing list of pivot attributes per relationship
+	 * so we don't have to call relationship method on refresh.
+	 *
+	 * @var array
+	 */
+	protected $pivotAttributes = [];
+
+	public function __construct(EntityMap $entityMap)
+	{
+		$this->entityMap = $entityMap;
+
+		$this->factory = new Factory;
+	}
+
+	/**
+	 * Add an array of key=>attributes representing
+	 * the initial state of loaded entities.
+	 *
+	 * @param array $entities
+	 */
+	public function add(array $entities)
+	{
+		if (count($this->cache) == 0) {
+			$this->cache = $entities;
+		} else {
+			$this->mergeCacheResults($entities);
+		}
+	}
+
+	/**
+	 * Retrieve initial attributes for a single entity
+	 *
+	 * @param  string $id
+	 * @return array
+	 */
+	public function get($id)
+	{
+		if ($this->has($id)) {
+			return $this->cache[$id];
+		} else {
+			return [];
+		}
+	}
+
+	/**
+	 * Check if a record for this id exists.
+	 *
+	 * @param  string  $id
+	 * @return boolean
+	 */
+	public function has($id)
+	{
+		return array_key_exists($id, $this->cache);
+	}
+
+	/**
+	 * Combine new result set with existing attributes in
+	 * cache.
+	 *
+	 * @param  array $entities
+	 * @return void
+	 */
+	protected function mergeCacheResults($entities)
+	{
+		foreach ($entities as $key => $entity) {
+			if (array_key_exists($key, $this->cache)) {
+				/*
                 $existingValue = $this->cache[$key];
 
                 $this->cache[$key] = $entity + $existingValue;*/
 
-                $this->cache[$key] = $entity;
-            } else {
-                $this->cache[$key] = $entity;
-            }
-        }
-    }
-
-    /**
-     * Cache Relation's query result for an entity
-     *
-     * @param  mixed 	$parent
-     * @param  string   $relation name of the relation
-     * @param  mixed 	$results  results of the relationship's query
-     *
-     * @return void
-     */
-    public function cacheLoadedRelationResult($parent, $relation, $results, Relationship $relationship)
-    {
-        $keyName = $this->entityMap->getKeyName();
-
-        if (! $parent instanceof InternallyMappable) {
-            $parent = $this->factory->make($parent);
-        }
-
-        $key = $parent->getEntityAttribute($keyName);
+				$this->cache[$key] = $entity;
+			} else {
+				$this->cache[$key] = $entity;
+			}
+		}
+	}
+
+	/**
+	 * Cache Relation's query result for an entity
+	 *
+	 * @param  mixed 	$parent
+	 * @param  string   $relation name of the relation
+	 * @param  mixed 	$results  results of the relationship's query
+	 *
+	 * @return void
+	 */
+	public function cacheLoadedRelationResult($parent, $relation, $results, Relationship $relationship)
+	{
+		$keyName = $this->entityMap->getKeyName();
+
+		if (! $parent instanceof InternallyMappable) {
+			$parent = $this->factory->make($parent);
+		}
+
+		$key = $parent->getEntityAttribute($keyName);
         
-        if ($results instanceof EntityCollection) {
-            $this->cacheManyRelationResults($key, $relation, $results, $relationship);
-        }
-
-        // POPO : Maybe this check isn't needed, or we have to check for stdClass
-        // instead
-        if ($results instanceof Mappable) {
-            $this->cacheSingleRelationResult($key, $relation, $results, $relationship);
-        }
-    }
-
-    /**
-     * Create a cachedRelationship instance which will hold related entity's hash and pivot attributes, if any.
-     *
-     * @param  [type]       $parentKey    [description]
-     * @param  [type]       $relation     [description]
-     * @param  [type]       $result       [description]
-     * @param  Relationship $relationship [description]
-     * @return [type]                     [description]
-     */
-    protected function getCachedRelationship($parentKey, $relation, $result, Relationship $relationship)
-    {
-        $pivotColumns = $relationship->getPivotAttributes();
-
-        if (! array_key_exists($relation, $this->pivotAttributes)) {
-            $this->pivotAttributes[$relation] = $pivotColumns;
-        }
-
-        $wrapper = $this->factory->make($result);
-
-        $hash = $this->getEntityHash($wrapper);
-
-        if (count($pivotColumns) > 0) {
-            $pivotAttributes = [];
-            foreach ($pivotColumns as $column) {
-                $pivot = $wrapper->getEntityAttribute('pivot');
-
-                $pivotWrapper = $this->factory->make($pivot);
-
-                $pivotAttributes[$column] = $pivotWrapper->getEntityAttribute($column);
-            }
-
-            $cachedRelationship = new CachedRelationship($hash, $pivotAttributes);
-        } else {
-            $cachedRelationship = new CachedRelationship($hash);
-        }
-
-        return $cachedRelationship;
-    }
-
-    /**
-     * Cache a many relationship
-     *
-     * @param  [type]       $parentKey    [description]
-     * @param  [type]       $relation     [description]
-     * @param  [type]       $results      [description]
-     * @param  Relationship $relationship [description]
-     * @return [type]                     [description]
-     */
-    protected function cacheManyRelationResults($parentKey, $relation, $results, Relationship $relationship)
-    {
-        $this->cache[$parentKey][$relation] = [];
-
-        foreach ($results as $result) {
-            $cachedRelationship = $this->getCachedRelationship($parentKey, $relation, $result, $relationship);
-
-            $relatedHash = $cachedRelationship->getHash();
-
-            $this->cache[$parentKey][$relation][$relatedHash] = $cachedRelationship;
-        }
-    }
-
-    /**
-     * Cache a single relationship
-     *
-     * @param  [type]       $parentKey    [description]
-     * @param  [type]       $relation     [description]
-     * @param  [type]       $results      [description]
-     * @param  Relationship $relationship [description]
-     * @return [type]                     [description]
-     */
-    protected function cacheSingleRelationResult($parentKey, $relation, $result, Relationship $relationship)
-    {
-        $this->cache[$parentKey][$relation] = $this->getCachedRelationship($parentKey, $relation, $result, $relationship);
-    }
-
-    /**
-     * Get Entity's Hash
-     *
-     * @param  $entity
-     * @return string
-     */
-    protected function getEntityHash(InternallyMappable $entity)
-    {
-        $class = get_class($entity->getObject());
-
-        $mapper = Manager::getMapper($class);
-
-        $keyName = $mapper->getEntityMap()->getKeyName();
-
-        return $class.'.'.$entity->getEntityAttribute($keyName);
-    }
-
-    /**
-     * Refresh the cache record for an aggregated entity after a write operation
-     *
-     * @param  InternallyMappable $entity [description]
-     * @return [type]                     [description]
-     */
-    public function refresh(Aggregate $entity)
-    {
-        $this->cache[$entity->getEntityId()] = $this->transform($entity);
-    }
-
-    /**
-     * Transform an Aggregated Entity into a cache record
-     *
-     * @param  Aggregate $entity
-     * @return array
-     */
-    protected function transform(Aggregate $aggregatedEntity)
-    {
-        $baseAttributes = $aggregatedEntity->getRawAttributes();
-
-        $relationAttributes = [];
-
-        // First we'll handle each relationships that are a one to one
-        // relation, and which will be saved as a CachedRelationship
-        // object inside the cache.
+		if ($results instanceof EntityCollection) {
+			$this->cacheManyRelationResults($key, $relation, $results, $relationship);
+		}
+
+		// POPO : Maybe this check isn't needed, or we have to check for stdClass
+		// instead
+		if ($results instanceof Mappable) {
+			$this->cacheSingleRelationResult($key, $relation, $results, $relationship);
+		}
+	}
+
+	/**
+	 * Create a cachedRelationship instance which will hold related entity's hash and pivot attributes, if any.
+	 *
+	 * @param  [type]       $parentKey    [description]
+	 * @param  [type]       $relation     [description]
+	 * @param  [type]       $result       [description]
+	 * @param  Relationship $relationship [description]
+	 * @return [type]                     [description]
+	 */
+	protected function getCachedRelationship($parentKey, $relation, $result, Relationship $relationship)
+	{
+		$pivotColumns = $relationship->getPivotAttributes();
+
+		if (! array_key_exists($relation, $this->pivotAttributes)) {
+			$this->pivotAttributes[$relation] = $pivotColumns;
+		}
+
+		$wrapper = $this->factory->make($result);
+
+		$hash = $this->getEntityHash($wrapper);
+
+		if (count($pivotColumns) > 0) {
+			$pivotAttributes = [];
+			foreach ($pivotColumns as $column) {
+				$pivot = $wrapper->getEntityAttribute('pivot');
+
+				$pivotWrapper = $this->factory->make($pivot);
+
+				$pivotAttributes[$column] = $pivotWrapper->getEntityAttribute($column);
+			}
+
+			$cachedRelationship = new CachedRelationship($hash, $pivotAttributes);
+		} else {
+			$cachedRelationship = new CachedRelationship($hash);
+		}
+
+		return $cachedRelationship;
+	}
+
+	/**
+	 * Cache a many relationship
+	 *
+	 * @param  [type]       $parentKey    [description]
+	 * @param  [type]       $relation     [description]
+	 * @param  [type]       $results      [description]
+	 * @param  Relationship $relationship [description]
+	 * @return [type]                     [description]
+	 */
+	protected function cacheManyRelationResults($parentKey, $relation, $results, Relationship $relationship)
+	{
+		$this->cache[$parentKey][$relation] = [];
+
+		foreach ($results as $result) {
+			$cachedRelationship = $this->getCachedRelationship($parentKey, $relation, $result, $relationship);
+
+			$relatedHash = $cachedRelationship->getHash();
+
+			$this->cache[$parentKey][$relation][$relatedHash] = $cachedRelationship;
+		}
+	}
+
+	/**
+	 * Cache a single relationship
+	 *
+	 * @param  [type]       $parentKey    [description]
+	 * @param  [type]       $relation     [description]
+	 * @param  [type]       $results      [description]
+	 * @param  Relationship $relationship [description]
+	 * @return [type]                     [description]
+	 */
+	protected function cacheSingleRelationResult($parentKey, $relation, $result, Relationship $relationship)
+	{
+		$this->cache[$parentKey][$relation] = $this->getCachedRelationship($parentKey, $relation, $result, $relationship);
+	}
+
+	/**
+	 * Get Entity's Hash
+	 *
+	 * @param  $entity
+	 * @return string
+	 */
+	protected function getEntityHash(InternallyMappable $entity)
+	{
+		$class = get_class($entity->getObject());
+
+		$mapper = Manager::getMapper($class);
+
+		$keyName = $mapper->getEntityMap()->getKeyName();
+
+		return $class.'.'.$entity->getEntityAttribute($keyName);
+	}
+
+	/**
+	 * Refresh the cache record for an aggregated entity after a write operation
+	 *
+	 * @param  InternallyMappable $entity [description]
+	 * @return [type]                     [description]
+	 */
+	public function refresh(Aggregate $entity)
+	{
+		$this->cache[$entity->getEntityId()] = $this->transform($entity);
+	}
+
+	/**
+	 * Transform an Aggregated Entity into a cache record
+	 *
+	 * @param  Aggregate $entity
+	 * @return array
+	 */
+	protected function transform(Aggregate $aggregatedEntity)
+	{
+		$baseAttributes = $aggregatedEntity->getRawAttributes();
+
+		$relationAttributes = [];
+
+		// First we'll handle each relationships that are a one to one
+		// relation, and which will be saved as a CachedRelationship
+		// object inside the cache.
         
-        // NOTE : storing localRelationships maybe useless has we store
-        // the foreign key in the attributes already.
+		// NOTE : storing localRelationships maybe useless has we store
+		// the foreign key in the attributes already.
 
-        foreach ($this->entityMap->getSingleRelationships() as $relation) {
-            $aggregates = $aggregatedEntity->getRelationship($relation);
+		foreach ($this->entityMap->getSingleRelationships() as $relation) {
+			$aggregates = $aggregatedEntity->getRelationship($relation);
             
-            if (count($aggregates) == 1) {
-                $related = $aggregates[0];
-                $relationAttributes[$relation] = new CachedRelationship($related->getEntityHash());
-            }
-            if (count($aggregates) > 1) {
-                throw new MappingException("Single Relationship '$relation' contains several related entities");
-            }
-        }
-
-        // Then we'll handle the 'many' relationships and store them as
-        // an array of CachedRelationship objects.
-
-        foreach ($this->entityMap->getManyRelationships() as $relation) {
-            $aggregates = $aggregatedEntity->getRelationship($relation);
-
-            $relationAttributes[$relation] = [];
-
-            foreach ($aggregates as $aggregate) {
-                $relationAttributes[$relation][] = new CachedRelationship(
-                    $aggregate->getEntityHash(),
-                    $aggregate->getPivotAttributes()
-                );
-            }
-        }
-
-        return $baseAttributes + $relationAttributes;
-    }
+			if (count($aggregates) == 1) {
+				$related = $aggregates[0];
+				$relationAttributes[$relation] = new CachedRelationship($related->getEntityHash());
+			}
+			if (count($aggregates) > 1) {
+				throw new MappingException("Single Relationship '$relation' contains several related entities");
+			}
+		}
+
+		// Then we'll handle the 'many' relationships and store them as
+		// an array of CachedRelationship objects.
+
+		foreach ($this->entityMap->getManyRelationships() as $relation) {
+			$aggregates = $aggregatedEntity->getRelationship($relation);
+
+			$relationAttributes[$relation] = [];
+
+			foreach ($aggregates as $aggregate) {
+				$relationAttributes[$relation][] = new CachedRelationship(
+					$aggregate->getEntityHash(),
+					$aggregate->getPivotAttributes()
+				);
+			}
+		}
+
+		return $baseAttributes + $relationAttributes;
+	}
         
-    protected function getPivotValues($relation, InternallyMappable $entity)
-    {
-        $values = [];
-
-        $entityAttributes = $entity->getEntityAttributes();
-
-        if (array_key_exists($relation, $this->pivotAttributes)) {
-            foreach ($this->pivotAttributes[$relation] as $attribute) {
-                if (array_key_exists($attribute, $entityAttributes)) {
-                    $values[$attribute] = $entity->getEntityAttribute('pivot')->$attribute;
-                }
-            }
-        }
-
-        return $values;
-    }
+	protected function getPivotValues($relation, InternallyMappable $entity)
+	{
+		$values = [];
+
+		$entityAttributes = $entity->getEntityAttributes();
+
+		if (array_key_exists($relation, $this->pivotAttributes)) {
+			foreach ($this->pivotAttributes[$relation] as $attribute) {
+				if (array_key_exists($attribute, $entityAttributes)) {
+					$values[$attribute] = $entity->getEntityAttribute('pivot')->$attribute;
+				}
+			}
+		}
+
+		return $values;
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -130,7 +130,7 @@ 
     {
         $keyName = $this->entityMap->getKeyName();
 
-        if (! $parent instanceof InternallyMappable) {
+        if (!$parent instanceof InternallyMappable) {
             $parent = $this->factory->make($parent);
         }
 
@@ -160,7 +160,7 @@ 
     {
         $pivotColumns = $relationship->getPivotAttributes();
 
-        if (! array_key_exists($relation, $this->pivotAttributes)) {
+        if (!array_key_exists($relation, $this->pivotAttributes)) {
             $this->pivotAttributes[$relation] = $pivotColumns;
         }