analogueorm / analogue

src/System/ScopeInterface.php

Indentation +16 added lines, -16 removed lines

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

src/System/Aggregate.php

Indentation +1115 added lines, -1115 removed lines

@@ -16,1119 +16,1119 @@
  */
 class Aggregate implements InternallyMappable
 {
-    /**
-     * The Root Entity.
-     *
-     * @var \Analogue\ORM\System\Wrappers\Wrapper
-     */
-    protected $wrappedEntity;
-
-    /**
-     * Class of the entity being aggregated.
-     *
-     * @var string
-     */
-    protected $class;
-
-    /**
-     * 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
-     * @param Aggregate|null $parent
-     * @param string         $parentRelationship
-     * @param Aggregate|null $root
-     *
-     * @throws MappingException
-     */
-    public function __construct($entity, Aggregate $parent = null, $parentRelationship = null, Aggregate $root = null)
-    {
-        $factory = new Factory();
-
-        $this->class = get_class($entity);
-
-        $this->wrappedEntity = $factory->make($entity);
-
-        $this->parent = $parent;
-
-        $this->parentRelationship = $parentRelationship;
-
-        $this->root = $root;
-
-        $mapper = $this->getMapper($entity);
-
-        $this->entityMap = $mapper->getEntityMap();
-
-        $this->parseRelationships();
-    }
-
-    /**
-     * Parse Every relationships defined on the entity.
-     *
-     * @throws MappingException
-     *
-     * @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
-     *
-     * @throws MappingException
-     *
-     * @return mixed|bool
-     */
-    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
-     *
-     * @throws MappingException
-     *
-     * @return bool
-     */
-    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 LazyLoadingInterface && !$value->isProxyInitialized()) {
-            $this->relationships[$relation] = [];
-
-            return true;
-        }
-
-        // If the attribute is a loaded proxy, swap it for its
-        // loaded entity.
-        if ($value instanceof LazyLoadingInterface && $value->isProxyInitialized()) {
-            $value = $value->getWrappedValueHolderValue();
-        }
-
-        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];
-
-        // We always need to check a loaded relation is in sync
-        // with its local key
-        $this->needSync[] = $relation;
-
-        return true;
-    }
-
-    /**
-     * Check if value isn't parent or root in the aggregate.
-     *
-     * @param  mixed
-     *
-     * @return bool|null
-     */
-    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
-     *
-     * @throws MappingException
-     *
-     * @return bool
-     */
-    protected function parseManyRelationship($relation)
-    {
-        if (!$value = $this->parseForCommonValues($relation)) {
-            return true;
-        }
-
-        if (is_array($value) || (!$value instanceof CollectionProxy && $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->isProxyInitialized()) {
-            $this->needSync[] = $relation;
-            //$value = $value->getUnderlyingCollection();
-        }
-
-        if ($value instanceof CollectionProxy && !$value->isProxyInitialized()) {
-            $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
-     *
-     * @throws MappingException
-     *
-     * @return mixed
-     */
-    protected function getRelationshipValue($relation)
-    {
-        $value = $this->getEntityAttribute($relation);
-        //if($relation == "role") tdd($this->wrappedEntity->getEntityAttributes());
-        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
-     * @param string $relation
-     *
-     * @return array
-     */
-    protected function createSubAggregates($entities, $relation)
-    {
-        $aggregates = [];
-
-        foreach ($entities as $entity) {
-            $aggregates[] = $this->createSubAggregate($entity, $relation);
-        }
-
-        return $aggregates;
-    }
-
-    /**
-     * Create a related subAggregate.
-     *
-     * @param mixed  $entity
-     * @param string $relation
-     *
-     * @throws MappingException
-     *
-     * @return self
-     */
-    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;
-        }
-
-        return new self($entity, $this, $relation, $root);
-    }
-
-    /**
-     * Get the Entity's primary key attribute.
-     *
-     * @return string|int
-     */
-    public function getEntityId()
-    {
-        return $this->wrappedEntity->getEntityKey();
-    }
-
-    /**
-     * 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 string
-     */
-    public function getEntityClass()
-    {
-        return $this->entityMap->getClass();
-    }
-
-    /**
-     * Return the Mapper's entity cache.
-     *
-     * @return \Analogue\ORM\System\EntityCache
-     */
-    protected function getEntityCache()
-    {
-        return $this->getMapper()->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.
-     *
-     * @param array
-     *
-     * @return void
-     */
-    public function syncRelationships(array $relationships)
-    {
-        foreach ($relationships as $relation) {
-            if (in_array($relation, $this->needSync)) {
-                $this->synchronize($relation);
-            }
-        }
-    }
-
-    /**
-     * Synchronize a relationship attribute.
-     *
-     * @param $relation
-     *
-     * @return void
-     */
-    protected function synchronize($relation)
-    {
-        $actualContent = $this->relationships[$relation];
-
-        $relationshipObject = $this->entityMap->$relation($this->getEntityObject());
-        $relationshipObject->setParent($this->wrappedEntity);
-        $relationshipObject->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;
-    }
-
-    /**
-     * Compare the object's raw attributes with the record in cache.
-     *
-     * @return bool
-     */
-    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,
-     * and discriminator column.
-     *
-     * @return array
-     */
-    public function getRawAttributes()
-    {
-        $attributes = $this->wrappedEntity->getEntityAttributes();
-
-        foreach ($this->entityMap->getRelationships() as $relation) {
-            unset($attributes[$relation]);
-        }
-
-        if ($this->entityMap->getInheritanceType() == 'single_table') {
-            $attributes = $this->addDiscriminatorColumn($attributes);
-        }
-
-        $attributes = $this->flattenEmbeddables($attributes);
-
-        $foreignKeys = $this->getForeignKeyAttributes();
-
-        return $attributes + $foreignKeys;
-    }
-
-    /**
-     * Add Discriminator Column if it doesn't exist on the actual entity.
-     *
-     * @param array $attributes
-     *
-     * @return array
-     */
-    protected function addDiscriminatorColumn($attributes)
-    {
-        $discriminatorColumn = $this->entityMap->getDiscriminatorColumn();
-        $entityClass = $this->entityMap->getClass();
-
-        if (!array_key_exists($discriminatorColumn, $attributes)) {
-
-            // Use key if present in discriminatorMap
-            $map = $this->entityMap->getDiscriminatorColumnMap();
-
-            $type = array_search($entityClass, $map);
-
-            if ($type === false) {
-                // Use entity FQDN if no corresponding key is set
-                $attributes[$discriminatorColumn] = $entityClass;
-            } else {
-                $attributes[$discriminatorColumn] = $type;
-            }
-        }
-
-        return $attributes;
-    }
-
-    /**
-     * 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];
-
-            // Unset the corresponding key
-            unset($attributes[$localKey]);
-
-            // 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));
-
-            foreach ($valueObjectAttributes as $key=>$value) {
-                $valueObjectAttributes[$prefix.'_'.$key] = $value;
-                unset($valueObjectAttributes[$key]);
-            }
-
-            $attributes = array_merge($attributes, $valueObjectAttributes);
-        }
-
-        return $attributes;
-    }
-
-    /**
-     * Return's entity raw attributes in the state they were at last
-     * query.
-     *
-     * @param array|null $columns
-     *
-     * @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;
-        } 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.
-     *
-     * @return array
-     */
-    protected function getForeignKeyAttributesFromParent()
-    {
-        $parentMap = $this->parent->getEntityMap();
-
-        $parentForeignRelations = $parentMap->getForeignRelationships();
-        $parentPivotRelations = $parentMap->getPivotRelationships();
-
-        // The parentRelation is the name of the relationship
-        // methods on the parent entity map
-        $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) {
-            $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 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 bool
-     */
-    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->getMapper()->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;
-    }
-
-    /**
-     * @param $key
-     *
-     * @return bool
-     */
-    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.
-     *
-     * @param $current
-     * @param $original
-     *
-     * @return bool
-     */
-    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 Manager::getMapper($this->class);
-    }
-
-    /**
-     * Check that the entity already exists in the database, by checking
-     * if it has an EntityCache record.
-     *
-     * @return bool
-     */
-    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 bool
-     */
-    public function hasAttribute($key)
-    {
-        return $this->wrappedEntity->hasAttribute($key);
-    }
-
-    /**
-     * Set the lazyloading proxies on the wrapped entity.
-     *
-     * @return void
-     */
-    public function setProxies()
-    {
-        $this->wrappedEntity->setProxies();
-    }
-
-    /**
-     * Hydrate the actual entity.
-     *
-     * @return void
-     */
-    public function hydrate()
-    {
-        $this->wrappedEntity->hydrate();
-    }
+	/**
+	 * The Root Entity.
+	 *
+	 * @var \Analogue\ORM\System\Wrappers\Wrapper
+	 */
+	protected $wrappedEntity;
+
+	/**
+	 * Class of the entity being aggregated.
+	 *
+	 * @var string
+	 */
+	protected $class;
+
+	/**
+	 * 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
+	 * @param Aggregate|null $parent
+	 * @param string         $parentRelationship
+	 * @param Aggregate|null $root
+	 *
+	 * @throws MappingException
+	 */
+	public function __construct($entity, Aggregate $parent = null, $parentRelationship = null, Aggregate $root = null)
+	{
+		$factory = new Factory();
+
+		$this->class = get_class($entity);
+
+		$this->wrappedEntity = $factory->make($entity);
+
+		$this->parent = $parent;
+
+		$this->parentRelationship = $parentRelationship;
+
+		$this->root = $root;
+
+		$mapper = $this->getMapper($entity);
+
+		$this->entityMap = $mapper->getEntityMap();
+
+		$this->parseRelationships();
+	}
+
+	/**
+	 * Parse Every relationships defined on the entity.
+	 *
+	 * @throws MappingException
+	 *
+	 * @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
+	 *
+	 * @throws MappingException
+	 *
+	 * @return mixed|bool
+	 */
+	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
+	 *
+	 * @throws MappingException
+	 *
+	 * @return bool
+	 */
+	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 LazyLoadingInterface && !$value->isProxyInitialized()) {
+			$this->relationships[$relation] = [];
+
+			return true;
+		}
+
+		// If the attribute is a loaded proxy, swap it for its
+		// loaded entity.
+		if ($value instanceof LazyLoadingInterface && $value->isProxyInitialized()) {
+			$value = $value->getWrappedValueHolderValue();
+		}
+
+		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];
+
+		// We always need to check a loaded relation is in sync
+		// with its local key
+		$this->needSync[] = $relation;
+
+		return true;
+	}
+
+	/**
+	 * Check if value isn't parent or root in the aggregate.
+	 *
+	 * @param  mixed
+	 *
+	 * @return bool|null
+	 */
+	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
+	 *
+	 * @throws MappingException
+	 *
+	 * @return bool
+	 */
+	protected function parseManyRelationship($relation)
+	{
+		if (!$value = $this->parseForCommonValues($relation)) {
+			return true;
+		}
+
+		if (is_array($value) || (!$value instanceof CollectionProxy && $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->isProxyInitialized()) {
+			$this->needSync[] = $relation;
+			//$value = $value->getUnderlyingCollection();
+		}
+
+		if ($value instanceof CollectionProxy && !$value->isProxyInitialized()) {
+			$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
+	 *
+	 * @throws MappingException
+	 *
+	 * @return mixed
+	 */
+	protected function getRelationshipValue($relation)
+	{
+		$value = $this->getEntityAttribute($relation);
+		//if($relation == "role") tdd($this->wrappedEntity->getEntityAttributes());
+		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
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	protected function createSubAggregates($entities, $relation)
+	{
+		$aggregates = [];
+
+		foreach ($entities as $entity) {
+			$aggregates[] = $this->createSubAggregate($entity, $relation);
+		}
+
+		return $aggregates;
+	}
+
+	/**
+	 * Create a related subAggregate.
+	 *
+	 * @param mixed  $entity
+	 * @param string $relation
+	 *
+	 * @throws MappingException
+	 *
+	 * @return self
+	 */
+	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;
+		}
+
+		return new self($entity, $this, $relation, $root);
+	}
+
+	/**
+	 * Get the Entity's primary key attribute.
+	 *
+	 * @return string|int
+	 */
+	public function getEntityId()
+	{
+		return $this->wrappedEntity->getEntityKey();
+	}
+
+	/**
+	 * 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 string
+	 */
+	public function getEntityClass()
+	{
+		return $this->entityMap->getClass();
+	}
+
+	/**
+	 * Return the Mapper's entity cache.
+	 *
+	 * @return \Analogue\ORM\System\EntityCache
+	 */
+	protected function getEntityCache()
+	{
+		return $this->getMapper()->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.
+	 *
+	 * @param array
+	 *
+	 * @return void
+	 */
+	public function syncRelationships(array $relationships)
+	{
+		foreach ($relationships as $relation) {
+			if (in_array($relation, $this->needSync)) {
+				$this->synchronize($relation);
+			}
+		}
+	}
+
+	/**
+	 * Synchronize a relationship attribute.
+	 *
+	 * @param $relation
+	 *
+	 * @return void
+	 */
+	protected function synchronize($relation)
+	{
+		$actualContent = $this->relationships[$relation];
+
+		$relationshipObject = $this->entityMap->$relation($this->getEntityObject());
+		$relationshipObject->setParent($this->wrappedEntity);
+		$relationshipObject->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;
+	}
+
+	/**
+	 * Compare the object's raw attributes with the record in cache.
+	 *
+	 * @return bool
+	 */
+	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,
+	 * and discriminator column.
+	 *
+	 * @return array
+	 */
+	public function getRawAttributes()
+	{
+		$attributes = $this->wrappedEntity->getEntityAttributes();
+
+		foreach ($this->entityMap->getRelationships() as $relation) {
+			unset($attributes[$relation]);
+		}
+
+		if ($this->entityMap->getInheritanceType() == 'single_table') {
+			$attributes = $this->addDiscriminatorColumn($attributes);
+		}
+
+		$attributes = $this->flattenEmbeddables($attributes);
+
+		$foreignKeys = $this->getForeignKeyAttributes();
+
+		return $attributes + $foreignKeys;
+	}
+
+	/**
+	 * Add Discriminator Column if it doesn't exist on the actual entity.
+	 *
+	 * @param array $attributes
+	 *
+	 * @return array
+	 */
+	protected function addDiscriminatorColumn($attributes)
+	{
+		$discriminatorColumn = $this->entityMap->getDiscriminatorColumn();
+		$entityClass = $this->entityMap->getClass();
+
+		if (!array_key_exists($discriminatorColumn, $attributes)) {
+
+			// Use key if present in discriminatorMap
+			$map = $this->entityMap->getDiscriminatorColumnMap();
+
+			$type = array_search($entityClass, $map);
+
+			if ($type === false) {
+				// Use entity FQDN if no corresponding key is set
+				$attributes[$discriminatorColumn] = $entityClass;
+			} else {
+				$attributes[$discriminatorColumn] = $type;
+			}
+		}
+
+		return $attributes;
+	}
+
+	/**
+	 * 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];
+
+			// Unset the corresponding key
+			unset($attributes[$localKey]);
+
+			// 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));
+
+			foreach ($valueObjectAttributes as $key=>$value) {
+				$valueObjectAttributes[$prefix.'_'.$key] = $value;
+				unset($valueObjectAttributes[$key]);
+			}
+
+			$attributes = array_merge($attributes, $valueObjectAttributes);
+		}
+
+		return $attributes;
+	}
+
+	/**
+	 * Return's entity raw attributes in the state they were at last
+	 * query.
+	 *
+	 * @param array|null $columns
+	 *
+	 * @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;
+		} 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.
+	 *
+	 * @return array
+	 */
+	protected function getForeignKeyAttributesFromParent()
+	{
+		$parentMap = $this->parent->getEntityMap();
+
+		$parentForeignRelations = $parentMap->getForeignRelationships();
+		$parentPivotRelations = $parentMap->getPivotRelationships();
+
+		// The parentRelation is the name of the relationship
+		// methods on the parent entity map
+		$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) {
+			$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 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 bool
+	 */
+	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->getMapper()->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;
+	}
+
+	/**
+	 * @param $key
+	 *
+	 * @return bool
+	 */
+	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.
+	 *
+	 * @param $current
+	 * @param $original
+	 *
+	 * @return bool
+	 */
+	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 Manager::getMapper($this->class);
+	}
+
+	/**
+	 * Check that the entity already exists in the database, by checking
+	 * if it has an EntityCache record.
+	 *
+	 * @return bool
+	 */
+	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 bool
+	 */
+	public function hasAttribute($key)
+	{
+		return $this->wrappedEntity->hasAttribute($key);
+	}
+
+	/**
+	 * Set the lazyloading proxies on the wrapped entity.
+	 *
+	 * @return void
+	 */
+	public function setProxies()
+	{
+		$this->wrappedEntity->setProxies();
+	}
+
+	/**
+	 * Hydrate the actual entity.
+	 *
+	 * @return void
+	 */
+	public function hydrate()
+	{
+		$this->wrappedEntity->hydrate();
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -946,7 +946,7 @@
      */
     protected function getEntityHashesFromRelation($relation)
     {
-        return array_map(function ($aggregate) {
+        return array_map(function($aggregate) {
             return $aggregate->getEntityHash();
         }, $this->relationships[$relation]);
     }

src/System/InternallyMappable.php

Indentation +35 added lines, -35 removed lines

@@ -4,43 +4,43 @@
 
 interface InternallyMappable
 {
-    /**
-     * Set the object attribute raw values (hydration).
-     *
-     * @param array $attributes
-     */
-    public function setEntityAttributes(array $attributes);
+	/**
+	 * Set the object attribute raw values (hydration).
+	 *
+	 * @param array $attributes
+	 */
+	public function setEntityAttributes(array $attributes);
 
-    /**
-     * Get the raw object's values.
-     *
-     * @return array
-     */
-    public function getEntityAttributes();
+	/**
+	 * Get the raw object's values.
+	 *
+	 * @return array
+	 */
+	public function getEntityAttributes();
 
-    /**
-     * Set the raw entity attributes.
-     *
-     * @param string $key
-     * @param string $value
-     */
-    public function setEntityAttribute($key, $value);
+	/**
+	 * Set the raw entity attributes.
+	 *
+	 * @param string $key
+	 * @param string $value
+	 */
+	public function setEntityAttribute($key, $value);
 
-    /**
-     * Return the entity's attribute.
-     *
-     * @param string $key
-     *
-     * @return mixed
-     */
-    public function getEntityAttribute($key);
+	/**
+	 * Return the entity's attribute.
+	 *
+	 * @param string $key
+	 *
+	 * @return mixed
+	 */
+	public function getEntityAttribute($key);
 
-    /**
-     * Does the entity posses the given attribute.
-     *
-     * @param string $key
-     *
-     * @return bool
-     */
-    public function hasAttribute($key);
+	/**
+	 * Does the entity posses the given attribute.
+	 *
+	 * @param string $key
+	 *
+	 * @return bool
+	 */
+	public function hasAttribute($key);
 }

src/System/Proxies/ProxyFactory.php

Indentation +43 added lines, -43 removed lines

@@ -14,47 +14,47 @@
  */
 class ProxyFactory
 {
-    public function make($entity, $relation, $class)
-    {
-        $entityMap = Manager::getMapper($entity)->getEntityMap();
-
-        $singleRelations = $entityMap->getSingleRelationships();
-        $manyRelations = $entityMap->getManyRelationships();
-
-        if (in_array($relation, $singleRelations)) {
-            return $this->makeEntityProxy($entity, $relation, $class);
-        }
-
-        if (in_array($relation, $manyRelations)) {
-            return new CollectionProxy($entity, $relation);
-        }
-
-        throw new MappingException('Could not identity relation '.$relation);
-    }
-
-    /**
-     * Create an instance of a proxy object, extending the actual
-     * related class.
-     *
-     * @param mixed  $entity   parent object
-     * @param string $relation the name of the relationship method
-     * @param string $class    the class name of the related object
-     *
-     * @return mixed
-     */
-    protected function makeEntityProxy($entity, $relation, $class)
-    {
-        $factory = new LazyLoadingValueHolderFactory();
-
-        $initializer = function (&$wrappedObject, LazyLoadingInterface $proxy, $method, array $parameters, &$initializer) use ($entity, $relation) {
-            $entityMap = Manager::getMapper($entity)->getEntityMap();
-
-            $wrappedObject = $entityMap->$relation($entity)->getResults($relation);
-
-            $initializer = null; // disable initialization
-            return true; // confirm that initialization occurred correctly
-        };
-
-        return $factory->createProxy($class, $initializer);
-    }
+	public function make($entity, $relation, $class)
+	{
+		$entityMap = Manager::getMapper($entity)->getEntityMap();
+
+		$singleRelations = $entityMap->getSingleRelationships();
+		$manyRelations = $entityMap->getManyRelationships();
+
+		if (in_array($relation, $singleRelations)) {
+			return $this->makeEntityProxy($entity, $relation, $class);
+		}
+
+		if (in_array($relation, $manyRelations)) {
+			return new CollectionProxy($entity, $relation);
+		}
+
+		throw new MappingException('Could not identity relation '.$relation);
+	}
+
+	/**
+	 * Create an instance of a proxy object, extending the actual
+	 * related class.
+	 *
+	 * @param mixed  $entity   parent object
+	 * @param string $relation the name of the relationship method
+	 * @param string $class    the class name of the related object
+	 *
+	 * @return mixed
+	 */
+	protected function makeEntityProxy($entity, $relation, $class)
+	{
+		$factory = new LazyLoadingValueHolderFactory();
+
+		$initializer = function (&$wrappedObject, LazyLoadingInterface $proxy, $method, array $parameters, &$initializer) use ($entity, $relation) {
+			$entityMap = Manager::getMapper($entity)->getEntityMap();
+
+			$wrappedObject = $entityMap->$relation($entity)->getResults($relation);
+
+			$initializer = null; // disable initialization
+			return true; // confirm that initialization occurred correctly
+		};
+
+		return $factory->createProxy($class, $initializer);
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -46,7 +46,7 @@
     {
         $factory = new LazyLoadingValueHolderFactory();
 
-        $initializer = function (&$wrappedObject, LazyLoadingInterface $proxy, $method, array $parameters, &$initializer) use ($entity, $relation) {
+        $initializer = function(&$wrappedObject, LazyLoadingInterface $proxy, $method, array $parameters, &$initializer) use ($entity, $relation) {
             $entityMap = Manager::getMapper($entity)->getEntityMap();
 
             $wrappedObject = $entityMap->$relation($entity)->getResults($relation);

src/System/SingleTableInheritanceScope.php

Indentation +106 added lines, -106 removed lines

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

Doc Comments +1 added lines, -1 removed lines

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

src/MappableTrait.php

Indentation +57 added lines, -57 removed lines

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

src/Mappable.php

Indentation +12 added lines, -12 removed lines

@@ -4,17 +4,17 @@
 
 interface Mappable
 {
-    /**
-     * Set the object attribute raw values (hydration).
-     *
-     * @param array $attributes
-     */
-    public function setEntityAttributes(array $attributes);
+	/**
+	 * Set the object attribute raw values (hydration).
+	 *
+	 * @param array $attributes
+	 */
+	public function setEntityAttributes(array $attributes);
 
-    /**
-     * Get the raw object's values.
-     *
-     * @return array
-     */
-    public function getEntityAttributes();
+	/**
+	 * Get the raw object's values.
+	 *
+	 * @return array
+	 */
+	public function getEntityAttributes();
 }

src/Relationships/MorphPivot.php

Indentation +52 added lines, -52 removed lines

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

src/Relationships/BelongsTo.php

Indentation +287 added lines, -287 removed lines

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

Spacing +1 added lines, -1 removed lines

@@ -185,7 +185,7 @@
         // Once we have the dictionary constructed, we can loop through all the parents
         // and match back onto their children using these keys of the dictionary and
         // the primary key of the children to map them onto the correct instances.
-        return array_map(function ($result) use ($dictionary, $foreign, $relation) {
+        return array_map(function($result) use ($dictionary, $foreign, $relation) {
             if (isset($dictionary[$result[$foreign]])) {
                 $result[$relation] = $dictionary[$result[$foreign]];
             } else {