analogueorm / analogue

src/Relationships/MorphTo.php

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();

Indentation +222 added lines, -222 removed lines

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

src/EntityMap.php

Doc Comments +1 added lines, -3 removed lines

@@ -931,7 +931,6 @@ 
      * @param string      $related
      * @param string|null $foreignKey
      * @param string|null $otherKey
-     * @param string|null $relation
      *
      * @throws MappingException
      *
@@ -1138,11 +1137,10 @@ 
      * Define a many-to-many relationship.
      *
      * @param mixed       $entity
-     * @param string      $relatedClass
+     * @param string      $related
      * @param string|null $table
      * @param string|null $foreignKey
      * @param string|null $otherKey
-     * @param string|null $relation
      *
      * @throws MappingException
      *

Indentation +1432 added lines, -1432 removed lines

@@ -23,1436 +23,1436 @@
  */
 class EntityMap
 {
-    /**
-     * The mapping driver to use with this entity.
-     *
-     * @var string
-     */
-    protected $driver = 'illuminate';
-
-    /**
-     * The Database Connection name for the model.
-     *
-     * @var string
-     */
-    protected $connection;
-
-    /**
-     * The table associated with the entity.
-     *
-     * @var string|null
-     */
-    protected $table = null;
-
-    /**
-     * The primary key for the model.
-     *
-     * @var string
-     */
-    protected $primaryKey = 'id';
-
-    /**
-     * Name of the entity's array property that should
-     * contain the attributes.
-     * If set to null, analogue will only hydrate object's properties.
-     *
-     * @var string|null
-     */
-    protected $arrayName = 'attributes';
-
-    /**
-     * Array containing the list of database columns to be mapped
-     * in the attributes array of the entity.
-     *
-     * @var array
-     */
-    protected $attributes = [];
-
-    /**
-     * Array containing the list of database columns to be mapped
-     * to the entity's class properties.
-     *
-     * @var array
-     */
-    protected $properties = [];
-
-    /**
-     * The Custom Domain Class to use with this mapping.
-     *
-     * @var string|null
-     */
-    protected $class = null;
-
-    /**
-     * Embedded Value Objects.
-     *
-     * @var array
-     */
-    protected $embeddables = [];
-
-    /**
-     * Determine the relationships method used on the entity.
-     * If not set, mapper will autodetect them.
-     *
-     * @var array
-     */
-    private $relationships = [];
-
-    /**
-     * Relationships that should be treated as collection.
-     *
-     * @var array
-     */
-    private $manyRelations = [];
-
-    /**
-     * Relationships that should be treated as single entity.
-     *
-     * @var array
-     */
-    private $singleRelations = [];
-
-    /**
-     * Relationships for which the key is stored in the Entity itself.
-     *
-     * @var array
-     */
-    private $localRelations = [];
-
-    /**
-     * List of local keys associated to local relation methods.
-     *
-     * @var array
-     */
-    private $localForeignKeys = [];
-
-    /**
-     * Relationships for which the key is stored in the Related Entity.
-     *
-     * @var array
-     */
-    private $foreignRelations = [];
-
-    /**
-     * Relationships which use a pivot record.
-     *
-     * @var array
-     */
-    private $pivotRelations = [];
-
-    /**
-     * Dynamic relationships.
-     *
-     * @var array
-     */
-    private $dynamicRelationships = [];
-
-    /**
-     * Targetted class for the relationship method. value is set to `null` for
-     * polymorphic relations.
-     *
-     * @var array
-     */
-    private $relatedClasses = [];
-
-    /**
-     * Some relation methods like embedded objects, or HasOne and MorphOne,
-     * will never have a proxy loaded on them.
-     *
-     * @var array
-     */
-    private $nonProxyRelationships = [];
-
-    /**
-     * The number of models to return for pagination.
-     *
-     * @var int
-     */
-    protected $perPage = 15;
-
-    /**
-     * The relations to eager load on every query.
-     *
-     * @var array
-     */
-    protected $with = [];
-
-    /**
-     * The class name to be used in polymorphic relations.
-     *
-     * @var string
-     */
-    protected $morphClass;
-
-    /**
-     * Sequence name, to be used with postgreSql
-     * defaults to %table_name%_id_seq.
-     *
-     * @var string|null
-     */
-    protected $sequence = null;
-
-    /**
-     * Indicates if the entity should be timestamped.
-     *
-     * @var bool
-     */
-    public $timestamps = false;
-
-    /**
-     * The name of the "created at" column.
-     *
-     * @var string
-     */
-    protected $createdAtColumn = 'created_at';
-
-    /**
-     * The name of the "updated at" column.
-     *
-     * @var string
-     */
-    protected $updatedAtColumn = 'updated_at';
-
-    /**
-     * Indicates if the entity uses softdeletes.
-     *
-     * @var bool
-     */
-    public $softDeletes = false;
-
-    /**
-     * The name of the "deleted at" column.
-     *
-     * @var string
-     */
-    protected $deletedAtColumn = 'deleted_at';
-
-    /**
-     * The date format to use with the current database connection.
-     *
-     * @var string
-     */
-    protected $dateFormat;
-
-    /**
-     * Set this property to true if the entity should be instantiated
-     * using the IoC Container.
-     *
-     * @var bool
-     */
-    protected $dependencyInjection = false;
-
-    /**
-     * Set the usage of inheritance, possible values are :
-     * "single_table"
-     * null.
-     *
-     * @var string | null
-     */
-    protected $inheritanceType = null;
-
-    /**
-     * Discriminator column name.
-     *
-     * @var string
-     */
-    protected $discriminatorColumn = 'type';
-
-    /**
-     * Allow using a string to define which entity type should be instantiated.
-     * If not set, analogue will uses entity's FQDN.
-     *
-     * @var array
-     */
-    protected $discriminatorColumnMap = [];
-
-    /**
-     * Return Domain class attributes, useful when mapping to a Plain PHP Object.
-     *
-     * @return array
-     */
-    public function getAttributes() : array
-    {
-        return $this->attributes;
-    }
-
-    /**
-     * Set the domain class attributes.
-     *
-     * @param array $attributeNames
-     */
-    public function setAttributes(array $attributeNames)
-    {
-        $this->attributes = $attributeNames;
-    }
-
-    /**
-     * Return true if the Entity has an 'attributes' array property.
-     *
-     * @return bool
-     */
-    public function usesAttributesArray() : bool
-    {
-        return $this->arrayName === null ? false : true;
-    }
-
-    /**
-     * Return the name of the Entity's attributes property.
-     *
-     * @return string|null
-     */
-    public function getAttributesArrayName()
-    {
-        return $this->arrayName;
-    }
-
-    /**
-     * Get all the attribute names for the class, including relationships, embeddables and primary key.
-     *
-     * @return array
-     */
-    public function getCompiledAttributes() : array
-    {
-        $key = $this->getKeyName();
-
-        $embeddables = array_keys($this->getEmbeddables());
-
-        $relationships = $this->getRelationships();
-
-        $attributes = $this->getAttributes();
-
-        return array_merge([$key], $embeddables, $relationships, $attributes);
-    }
-
-    /**
-     * Set the date format to use with the current database connection.
-     *
-     * @param string $format
-     */
-    public function setDateFormat($format)
-    {
-        $this->dateFormat = $format;
-    }
-
-    /**
-     * Get the date format to use with the current database connection.
-     *
-     *  @return string
-     */
-    public function getDateFormat() : string
-    {
-        return $this->dateFormat;
-    }
-
-    /**
-     * Set the Driver for this mapping.
-     *
-     * @param string $driver
-     */
-    public function setDriver($driver)
-    {
-        $this->driver = $driver;
-    }
-
-    /**
-     * Get the Driver for this mapping.
-     *
-     * @return string
-     */
-    public function getDriver() : string
-    {
-        return $this->driver;
-    }
-
-    /**
-     * Set the db connection to use on the table.
-     *
-     * @param $connection
-     */
-    public function setConnection($connection)
-    {
-        $this->connection = $connection;
-    }
-
-    /**
-     * Get the Database connection the Entity is stored on.
-     *
-     * @return string | null
-     */
-    public function getConnection()
-    {
-        return $this->connection;
-    }
-
-    /**
-     * Get the table associated with the entity.
-     *
-     * @return string
-     */
-    public function getTable() : string
-    {
-        if (!is_null($this->table)) {
-            return $this->table;
-        }
-
-        return str_replace('\\', '', snake_case(str_plural(class_basename($this->getClass()))));
-    }
-
-    /**
-     * Set the database table name.
-     *
-     * @param string $table
-     */
-    public function setTable($table)
-    {
-        $this->table = $table;
-    }
-
-    /**
-     * Get the pgSql sequence name.
-     *
-     * @return string
-     */
-    public function getSequence() : string
-    {
-        if (!is_null($this->sequence)) {
-            return $this->sequence;
-        } else {
-            return $this->getTable().'_id_seq';
-        }
-    }
-
-    /**
-     * Get the custom entity class.
-     *
-     * @return string namespaced class name
-     */
-    public function getClass() : string
-    {
-        return isset($this->class) ? $this->class : null;
-    }
-
-    /**
-     * Set the custom entity class.
-     *
-     * @param string $class namespaced class name
-     */
-    public function setClass($class)
-    {
-        $this->class = $class;
-    }
-
-    /**
-     * Get the embedded Value Objects.
-     *
-     * @return array
-     */
-    public function getEmbeddables() : array
-    {
-        return $this->embeddables;
-    }
-
-    /**
-     * Return attributes that should be mapped to class properties.
-     *
-     * @return array
-     */
-    public function getProperties() : array
-    {
-        return $this->properties;
-    }
-
-    /**
-     * Return the array property in which will be mapped all attributes
-     * that are not mapped to class properties.
-     *
-     * @return string
-     */
-    public function getAttributesPropertyName() : string
-    {
-    }
-
-    /**
-     * Set the embedded Value Objects.
-     *
-     * @param array $embeddables
-     */
-    public function setEmbeddables(array $embeddables)
-    {
-        $this->embeddables = $embeddables;
-    }
-
-    /**
-     * Get the relationships to map on a custom domain
-     * class.
-     *
-     * @return array
-     */
-    public function getRelationships() : array
-    {
-        return $this->relationships;
-    }
-
-    /**
-     * Get the relationships that will not have a proxy
-     * set on them.
-     *
-     * @return array
-     */
-    public function getRelationshipsWithoutProxy() : array
-    {
-        return $this->nonProxyRelationships;
-    }
-
-    /**
-     * Relationships of the Entity type.
-     *
-     * @return array
-     */
-    public function getSingleRelationships() : array
-    {
-        return $this->singleRelations;
-    }
-
-    /**
-     * Relationships of type Collection.
-     *
-     * @return array
-     */
-    public function getManyRelationships() : array
-    {
-        return $this->manyRelations;
-    }
-
-    /**
-     * Relationships with foreign key in the mapped entity record.
-     *
-     * @return array
-     */
-    public function getLocalRelationships() : array
-    {
-        return $this->localRelations;
-    }
-
-    /**
-     * Return the local keys associated to the relationship.
-     *
-     * @param string $relation
-     *
-     * @return string | array | null
-     */
-    public function getLocalKeys($relation)
-    {
-        return isset($this->localForeignKeys[$relation]) ? $this->localForeignKeys[$relation] : null;
-    }
-
-    /**
-     * Relationships with foreign key in the related Entity record.
-     *
-     * @return array
-     */
-    public function getForeignRelationships() : array
-    {
-        return $this->foreignRelations;
-    }
-
-    /**
-     * Relationships which keys are stored in a pivot record.
-     *
-     * @return array
-     */
-    public function getPivotRelationships() : array
-    {
-        return $this->pivotRelations;
-    }
-
-    /**
-     * Get the targetted type for a relationship. Return null if polymorphic.
-     *
-     * @param string $relation
-     *
-     * @return string | null
-     */
-    public function getTargettedClass($relation)
-    {
-        return $this->relatedClasses[$relation];
-    }
-
-    /**
-     * Add a Dynamic Relationship method at runtime. This has to be done
-     * by hooking the 'initializing' event, before entityMap is initialized.
-     *
-     * @param string   $name         Relation name
-     * @param \Closure $relationship
-     *
-     * @return void
-     */
-    public function addRelationshipMethod($name, \Closure $relationship)
-    {
-        $this->dynamicRelationships[$name] = $relationship;
-    }
-
-    /**
-     * Get the dynamic relationship method names.
-     *
-     * @return array
-     */
-    public function getDynamicRelationships() : array
-    {
-        return array_keys($this->dynamicRelationships);
-    }
-
-    /**
-     * Get the relationships that have to be eager loaded
-     * on each request.
-     *
-     * @return array
-     */
-    public function getEagerloadedRelationships() : array
-    {
-        return $this->with;
-    }
-
-    /**
-     * Get the primary key attribute for the entity.
-     *
-     * @return string
-     */
-    public function getKeyName() : string
-    {
-        return $this->primaryKey;
-    }
-
-    /**
-     * Set the primary key for the entity.
-     *
-     * @param $key
-     *
-     * @return void
-     */
-    public function setKeyName($key)
-    {
-        $this->primaryKey = $key;
-    }
-
-    /**
-     * Get the table qualified key name.
-     *
-     * @return string
-     */
-    public function getQualifiedKeyName() : string
-    {
-        return $this->getTable().'.'.$this->getKeyName();
-    }
-
-    /**
-     * Get the number of models to return per page.
-     *
-     * @return int
-     */
-    public function getPerPage() : int
-    {
-        return $this->perPage;
-    }
-
-    /**
-     * Set the number of models to return per page.
-     *
-     * @param int $perPage
-     *
-     * @return void
-     */
-    public function setPerPage($perPage)
-    {
-        $this->perPage = $perPage;
-    }
-
-    /**
-     * Determine if the entity uses get.
-     *
-     * @return bool
-     */
-    public function usesTimestamps() : bool
-    {
-        return $this->timestamps;
-    }
-
-    /**
-     * Determine if the entity uses soft deletes.
-     *
-     * @return bool
-     */
-    public function usesSoftDeletes() : bool
-    {
-        return $this->softDeletes;
-    }
-
-    /**
-     * Get the 'created_at' column name.
-     *
-     * @return string
-     */
-    public function getCreatedAtColumn() : string
-    {
-        return $this->createdAtColumn;
-    }
-
-    /**
-     * Get the 'updated_at' column name.
-     *
-     * @return string
-     */
-    public function getUpdatedAtColumn() : string
-    {
-        return $this->updatedAtColumn;
-    }
-
-    /**
-     * Get the deleted_at column.
-     *
-     * @return string
-     */
-    public function getQualifiedDeletedAtColumn() : string
-    {
-        return $this->deletedAtColumn;
-    }
-
-    /**
-     * Get the default foreign key name for the model.
-     *
-     * @return string
-     */
-    public function getForeignKey() : string
-    {
-        return snake_case(class_basename($this->getClass())).'_id';
-    }
-
-    /**
-     * Return the inheritance type used by the entity.
-     *
-     * @return string|null
-     */
-    public function getInheritanceType()
-    {
-        return $this->inheritanceType;
-    }
-
-    /**
-     * Return the discriminator column name on the entity that's
-     * used for table inheritance.
-     *
-     * @return string
-     */
-    public function getDiscriminatorColumn() : string
-    {
-        return $this->discriminatorColumn;
-    }
-
-    /**
-     * Return the mapping of discriminator column values to
-     * entity class names that are used for table inheritance.
-     *
-     * @return array
-     */
-    public function getDiscriminatorColumnMap() : array
-    {
-        return $this->discriminatorColumnMap;
-    }
-
-    /**
-     * Return true if the entity should be instanciated using
-     * the IoC Container.
-     *
-     * @return bool
-     */
-    public function useDependencyInjection() : bool
-    {
-        return $this->dependencyInjection;
-    }
-
-    /**
-     * Add a single relation method name once.
-     *
-     * @param string $relation
-     */
-    protected function addSingleRelation($relation)
-    {
-        if (!in_array($relation, $this->singleRelations)) {
-            $this->singleRelations[] = $relation;
-        }
-    }
-
-    /**
-     * Add a foreign relation method name once.
-     *
-     * @param string $relation
-     */
-    protected function addForeignRelation($relation)
-    {
-        if (!in_array($relation, $this->foreignRelations)) {
-            $this->foreignRelations[] = $relation;
-        }
-    }
-
-    /**
-     * Add a non proxy relation method name once.
-     *
-     * @param string $relation
-     */
-    protected function addNonProxyRelation($relation)
-    {
-        if (!in_array($relation, $this->nonProxyRelationships)) {
-            $this->nonProxyRelationships[] = $relation;
-        }
-    }
-
-    /**
-     * Add a local relation method name once.
-     *
-     * @param string $relation
-     */
-    protected function addLocalRelation($relation)
-    {
-        if (!in_array($relation, $this->localRelations)) {
-            $this->localRelations[] = $relation;
-        }
-    }
-
-    /**
-     * Add a many relation method name once.
-     *
-     * @param string $relation
-     */
-    protected function addManyRelation($relation)
-    {
-        if (!in_array($relation, $this->manyRelations)) {
-            $this->manyRelations[] = $relation;
-        }
-    }
-
-    /**
-     * Add a pivot relation method name once.
-     *
-     * @param string $relation
-     */
-    protected function addPivotRelation($relation)
-    {
-        if (!in_array($relation, $this->pivotRelations)) {
-            $this->pivotRelations[] = $relation;
-        }
-    }
-
-    /**
-     * Define a one-to-one relationship.
-     *
-     * @param mixed  $entity
-     * @param string $related    entity class
-     * @param string $foreignKey
-     * @param string $localKey
-     *
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\Relationships\HasOne
-     */
-    public function hasOne($entity, $related, $foreignKey = null, $localKey = null)
-    {
-        $foreignKey = $foreignKey ?: $this->getForeignKey();
-
-        $relatedMapper = Manager::getInstance()->mapper($related);
-
-        $relatedMap = $relatedMapper->getEntityMap();
-
-        $localKey = $localKey ?: $this->getKeyName();
-
-        // Add the relation to the definition in map
-        list(, $caller) = debug_backtrace(false);
-        $relation = $caller['function'];
-        $this->relatedClasses[$relation] = $related;
-
-        $this->addSingleRelation($relation);
-        $this->addForeignRelation($relation);
-        $this->addNonProxyRelation($relation);
-
-        // This relationship will always be eager loaded, as proxying it would
-        // mean having an object that doesn't actually exists.
-        if (!in_array($relation, $this->with)) {
-            $this->with[] = $relation;
-        }
-
-        return new HasOne($relatedMapper, $entity, $relatedMap->getTable().'.'.$foreignKey, $localKey);
-    }
-
-    /**
-     * Define a polymorphic one-to-one relationship.
-     *
-     * @param mixed       $entity
-     * @param string      $related
-     * @param string      $name
-     * @param string|null $type
-     * @param string|null $id
-     * @param string|null $localKey
-     *
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\Relationships\MorphOne
-     */
-    public function morphOne($entity, $related, $name, $type = null, $id = null, $localKey = null)
-    {
-        list($type, $id) = $this->getMorphs($name, $type, $id);
-
-        $localKey = $localKey ?: $this->getKeyName();
-
-        $relatedMapper = Manager::getInstance()->mapper($related);
-
-        $table = $relatedMapper->getEntityMap()->getTable();
-
-        // Add the relation to the definition in map
-        list(, $caller) = debug_backtrace(false);
-        $relation = $caller['function'];
-        $this->relatedClasses[$relation] = $related;
-
-        $this->addSingleRelation($relation);
-        $this->addForeignRelation($relation);
-        $this->addNonProxyRelation($relation);
-
-        // This relationship will always be eager loaded, as proxying it would
-        // mean having an object that doesn't actually exists.
-        if (!in_array($relation, $this->with)) {
-            $this->with[] = $relation;
-        }
-
-        return new MorphOne($relatedMapper, $entity, $table.'.'.$type, $table.'.'.$id, $localKey);
-    }
-
-    /**
-     * Define an inverse one-to-one or many relationship.
-     *
-     * @param mixed       $entity
-     * @param string      $related
-     * @param string|null $foreignKey
-     * @param string|null $otherKey
-     * @param string|null $relation
-     *
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\Relationships\BelongsTo
-     */
-    public function belongsTo($entity, $related, $foreignKey = null, $otherKey = null)
-    {
-        // Add the relation to the definition in map
-        list(, $caller) = debug_backtrace(false);
-        $relation = $caller['function'];
-        $this->relatedClasses[$relation] = $related;
-
-        $this->addSingleRelation($relation);
-        $this->addLocalRelation($relation);
-
-        // If no foreign key was supplied, we can use a backtrace to guess the proper
-        // foreign key name by using the name of the relationship function, which
-        // when combined with an "_id" should conventionally match the columns.
-        if (is_null($foreignKey)) {
-            $foreignKey = snake_case($relation).'_id';
-        }
-
-        $this->localForeignKeys[$relation] = $foreignKey;
-
-        $relatedMapper = Manager::getInstance()->mapper($related);
-
-        $otherKey = $otherKey ?: $relatedMapper->getEntityMap()->getKeyName();
-
-        return new BelongsTo($relatedMapper, $entity, $foreignKey, $otherKey, $relation);
-    }
-
-    /**
-     * Define a polymorphic, inverse one-to-one or many relationship.
-     *
-     * @param mixed       $entity
-     * @param string|null $name
-     * @param string|null $type
-     * @param string|null $id
-     *
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\Relationships\MorphTo
-     */
-    public function morphTo($entity, $name = null, $type = null, $id = null)
-    {
-        // If no name is provided, we will use the backtrace to get the function name
-        // since that is most likely the name of the polymorphic interface. We can
-        // use that to get both the class and foreign key that will be utilized.
-        if (is_null($name)) {
-            list(, $caller) = debug_backtrace(false);
-
-            $name = snake_case($caller['function']);
-        }
-        $this->addSingleRelations($name);
-        $this->addLocalRelation($name);
-        $this->addForeignRelations($name);
-        $this->relatedClass[$relation] = null;
-
-        list($type, $id) = $this->getMorphs($name, $type, $id);
-
-        // Store the foreign key in the entity map.
-        // We might want to store the (key, type) as we might need it
-        // to build a MorphTo proxy
-        $this->localForeignKeys[$name] = [
-            'id'   => $id,
-            'type' => $type,
-        ];
-
-        $mapper = Manager::getInstance()->mapper(get_class($entity));
-
-        // If the type value is null it is probably safe to assume we're eager loading
-        // the relationship. When that is the case we will pass in a dummy query as
-        // there are multiple types in the morph and we can't use single queries.
-        $factory = new Factory();
-        $wrapper = $factory->make($entity);
-
-        if (is_null($class = $wrapper->getEntityAttribute($type))) {
-            return new MorphTo(
-                $mapper, $entity, $id, null, $type, $name
-            );
-        }
-
-        // If we are not eager loading the relationship we will essentially treat this
-        // as a belongs-to style relationship since morph-to extends that class and
-        // we will pass in the appropriate values so that it behaves as expected.
-        else {
-            $class = Manager::getInstance()->getInverseMorphMap($class);
-            $relatedMapper = Manager::getInstance()->mapper($class);
-
-            $foreignKey = $relatedMapper->getEntityMap()->getKeyName();
-
-            return new MorphTo(
-                $relatedMapper, $entity, $id, $foreignKey, $type, $name
-            );
-        }
-    }
-
-    /**
-     * Define a one-to-many relationship.
-     *
-     * @param mixed       $entity
-     * @param string      $related
-     * @param string|null $foreignKey
-     * @param string|null $localKey
-     *
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\Relationships\HasMany
-     */
-    public function hasMany($entity, $related, $foreignKey = null, $localKey = null)
-    {
-        $foreignKey = $foreignKey ?: $this->getForeignKey();
-
-        $relatedMapper = Manager::getInstance()->mapper($related);
-
-        $table = $relatedMapper->getEntityMap()->getTable().'.'.$foreignKey;
-
-        $localKey = $localKey ?: $this->getKeyName();
-
-        // Add the relation to the definition in map
-        list(, $caller) = debug_backtrace(false);
-        $relation = $caller['function'];
-        $this->relatedClasses[$relation] = $related;
-
-        $this->addManyRelation($relation);
-        $this->addForeignRelation($relation);
-
-        return new HasMany($relatedMapper, $entity, $table, $localKey);
-    }
-
-    /**
-     * Define a has-many-through relationship.
-     *
-     * @param mixed       $entity
-     * @param string      $related
-     * @param string      $through
-     * @param string|null $firstKey
-     * @param string|null $secondKey
-     *
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\Relationships\HasManyThrough
-     */
-    public function hasManyThrough($entity, $related, $through, $firstKey = null, $secondKey = null)
-    {
-        $relatedMapper = Manager::getInstance()->mapper($related);
-
-        $throughMapper = Manager::getInstance()->mapper($through);
-
-        $firstKey = $firstKey ?: $this->getForeignKey();
-
-        $throughMap = $throughMapper->getEntityMap();
-
-        $secondKey = $secondKey ?: $throughMap->getForeignKey();
-
-        // Add the relation to the definition in map
-        list(, $caller) = debug_backtrace(false);
-        $relation = $caller['function'];
-        $this->relatedClasses[$relation] = $related;
-
-        $this->addManyRelation($relation);
-        $this->addForeignRelation($relation);
-
-        return new HasManyThrough($relatedMapper, $entity, $throughMap, $firstKey, $secondKey);
-    }
-
-    /**
-     * Define a polymorphic one-to-many relationship.
-     *
-     * @param mixed       $entity
-     * @param string      $related
-     * @param string      $name
-     * @param string|null $type
-     * @param string|null $id
-     * @param string|null $localKey
-     *
-     * @return \Analogue\ORM\Relationships\MorphMany
-     */
-    public function morphMany($entity, $related, $name, $type = null, $id = null, $localKey = null)
-    {
-        // Here we will gather up the morph type and ID for the relationship so that we
-        // can properly query the intermediate table of a relation. Finally, we will
-        // get the table and create the relationship instances for the developers.
-        list($type, $id) = $this->getMorphs($name, $type, $id);
-
-        $relatedMapper = Manager::getInstance()->mapper($related);
-
-        $table = $relatedMapper->getEntityMap()->getTable();
-
-        $localKey = $localKey ?: $this->getKeyName();
-
-        // Add the relation to the definition in map
-        list(, $caller) = debug_backtrace(false);
-        $relation = $caller['function'];
-        $this->relatedClasses[$relation] = $related;
-
-        $this->addManyRelation($relation);
-        $this->addForeignRelation($relation);
-
-        return new MorphMany($relatedMapper, $entity, $table.'.'.$type, $table.'.'.$id, $localKey);
-    }
-
-    /**
-     * Define a many-to-many relationship.
-     *
-     * @param mixed       $entity
-     * @param string      $relatedClass
-     * @param string|null $table
-     * @param string|null $foreignKey
-     * @param string|null $otherKey
-     * @param string|null $relation
-     *
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\Relationships\BelongsToMany
-     */
-    public function belongsToMany($entity, $related, $table = null, $foreignKey = null, $otherKey = null)
-    {
-        // Add the relation to the definition in map
-        list(, $caller) = debug_backtrace(false);
-        $relation = $caller['function'];
-        $this->relatedClasses[$relation] = $related;
-
-        $this->addManyRelation($relation);
-        $this->addForeignRelation($relation);
-        $this->addPivotRelation($relation);
-
-        // First, we'll need to determine the foreign key and "other key" for the
-        // relationship. Once we have determined the keys we'll make the query
-        // instances as well as the relationship instances we need for this.
-        $foreignKey = $foreignKey ?: $this->getForeignKey();
-
-        $relatedMapper = Manager::getInstance()->mapper($related);
-
-        $relatedMap = $relatedMapper->getEntityMap();
-
-        $otherKey = $otherKey ?: $relatedMap->getForeignKey();
-
-        // If no table name was provided, we can guess it by concatenating the two
-        // models using underscores in alphabetical order. The two model names
-        // are transformed to snake case from their default CamelCase also.
-        if (is_null($table)) {
-            $table = $this->joiningTable($relatedMap);
-        }
-
-        return new BelongsToMany($relatedMapper, $entity, $table, $foreignKey, $otherKey, $relation);
-    }
-
-    /**
-     * Define a polymorphic many-to-many relationship.
-     *
-     * @param mixed       $entity
-     * @param string      $related
-     * @param string      $name
-     * @param string|null $table
-     * @param string|null $foreignKey
-     * @param string|null $otherKey
-     * @param bool        $inverse
-     *
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\Relationships\MorphToMany
-     */
-    public function morphToMany($entity, $related, $name, $table = null, $foreignKey = null, $otherKey = null, $inverse = false)
-    {
-        // Add the relation to the definition in map
-        list(, $caller) = debug_backtrace(false);
-        $relation = $caller['function'];
-        $this->relatedClasses[$relation] = $related;
-
-        $this->addManyRelation($relation);
-        $this->addForeignRelation($relation);
-        $this->addPivotRelation($relation);
-
-        // First, we will need to determine the foreign key and "other key" for the
-        // relationship. Once we have determined the keys we will make the query
-        // instances, as well as the relationship instances we need for these.
-        $foreignKey = $foreignKey ?: $name.'_id';
-
-        $relatedMapper = Manager::getInstance()->mapper($related);
-
-        $otherKey = $otherKey ?: $relatedMapper->getEntityMap()->getForeignKey();
-
-        $table = $table ?: str_plural($name);
-
-        return new MorphToMany($relatedMapper, $entity, $name, $table, $foreignKey, $otherKey, $caller, $inverse);
-    }
-
-    /**
-     * Define a polymorphic, inverse many-to-many relationship.
-     *
-     * @param mixed       $entity
-     * @param string      $related
-     * @param string      $name
-     * @param string|null $table
-     * @param string|null $foreignKey
-     * @param string|null $otherKey
-     *
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\Relationships\MorphToMany
-     */
-    public function morphedByMany($entity, $related, $name, $table = null, $foreignKey = null, $otherKey = null)
-    {
-        // Add the relation to the definition in map
-        list(, $caller) = debug_backtrace(false);
-        $relation = $caller['function'];
-        $this->relatedClasses[$relation] = $related;
-
-        $this->addManyRelation($relation);
-        $this->addForeignRelation($relation);
-
-        $foreignKey = $foreignKey ?: $this->getForeignKey();
-
-        // For the inverse of the polymorphic many-to-many relations, we will change
-        // the way we determine the foreign and other keys, as it is the opposite
-        // of the morph-to-many method since we're figuring out these inverses.
-        $otherKey = $otherKey ?: $name.'_id';
-
-        return $this->morphToMany($entity, $related, $name, $table, $foreignKey, $otherKey, true);
-    }
-
-    /**
-     * Get the joining table name for a many-to-many relation.
-     *
-     * @param EntityMap $relatedMap
-     *
-     * @return string
-     */
-    public function joiningTable($relatedMap)
-    {
-        // The joining table name, by convention, is simply the snake cased models
-        // sorted alphabetically and concatenated with an underscore, so we can
-        // just sort the models and join them together to get the table name.
-        $base = $this->getTable();
-
-        $related = $relatedMap->getTable();
-
-        $tables = [$related, $base];
-
-        // Now that we have the model names in an array we can just sort them and
-        // use the implode function to join them together with an underscores,
-        // which is typically used by convention within the database system.
-        sort($tables);
-
-        return strtolower(implode('_', $tables));
-    }
-
-    /**
-     * Get the polymorphic relationship columns.
-     *
-     * @param string $name
-     * @param string $type
-     * @param string $id
-     *
-     * @return string[]
-     */
-    protected function getMorphs($name, $type, $id)
-    {
-        $type = $type ?: $name.'_type';
-
-        $id = $id ?: $name.'_id';
-
-        return [$type, $id];
-    }
-
-    /**
-     * Get the class name for polymorphic relations.
-     *
-     * @return string
-     */
-    public function getMorphClass()
-    {
-        $morphClass = Manager::getInstance()->getMorphMap($this->getClass());
-
-        return $this->morphClass ?: $morphClass;
-    }
-
-    /**
-     * Create a new Entity Collection instance.
-     *
-     * @param array $entities
-     *
-     * @return \Analogue\ORM\EntityCollection
-     */
-    public function newCollection(array $entities = [])
-    {
-        $collection = new EntityCollection($entities, $this);
-
-        return $collection->keyBy($this->getKeyName());
-    }
-
-    /**
-     * Process EntityMap parsing at initialization time.
-     *
-     * @return void
-     */
-    public function initialize()
-    {
-        $userMethods = $this->getCustomMethods();
-
-        // Parse EntityMap for method based relationship
-        if (count($userMethods) > 0) {
-            $this->relationships = $this->parseMethodsForRelationship($userMethods);
-        }
-
-        // Parse EntityMap for dynamic relationships
-        if (count($this->dynamicRelationships) > 0) {
-            $this->relationships = $this->relationships + $this->getDynamicRelationships();
-        }
-    }
-
-    /**
-     * Parse every relationships on the EntityMap and sort
-     * them by type.
-     *
-     * @return void
-     */
-    public function boot()
-    {
-        if (count($this->relationships > 0)) {
-            $this->sortRelationshipsByType();
-        }
-    }
-
-    /**
-     * Get Methods that has been added in the child class.
-     *
-     * @return array
-     */
-    protected function getCustomMethods()
-    {
-        $mapMethods = get_class_methods($this);
-
-        $parentsMethods = get_class_methods('Analogue\ORM\EntityMap');
-
-        return array_diff($mapMethods, $parentsMethods);
-    }
-
-    /**
-     * Parse user's class methods for relationships.
-     *
-     * @param array $customMethods
-     *
-     * @return array
-     */
-    protected function parseMethodsForRelationship(array $customMethods)
-    {
-        $relationships = [];
-
-        $class = new ReflectionClass(get_class($this));
-
-        // Get the mapped Entity class, as we will detect relationships
-        // methods by testing that the first argument is type-hinted to
-        // the same class as the mapped Entity.
-        $entityClass = $this->getClass();
-
-        foreach ($customMethods as $methodName) {
-            $method = $class->getMethod($methodName);
-
-            if ($method->getNumberOfParameters() > 0) {
-                $params = $method->getParameters();
-
-                if ($params[0]->getClass() && ($params[0]->getClass()->name == $entityClass || is_subclass_of($entityClass, $params[0]->getClass()->name))) {
-                    $relationships[] = $methodName;
-                }
-            }
-        }
-
-        return $relationships;
-    }
-
-    /**
-     * Sort Relationships methods by type.
-     *
-     * TODO : replace this by direclty setting these value
-     * in the corresponding methods, so we won't need
-     * the correpondancy tabble
-     *
-     * @return void
-     */
-    protected function sortRelationshipsByType()
-    {
-        $entityClass = $this->getClass();
-
-        // Instantiate a dummy entity which we will pass to relationship methods.
-        $entity = unserialize(sprintf('O:%d:"%s":0:{}', strlen($entityClass), $entityClass));
-
-        foreach ($this->relationships as $relation) {
-            $this->$relation($entity);
-        }
-    }
-
-    /**
-     * Override this method for custom entity instantiation.
-     *
-     * @return null
-     */
-    public function activator()
-    {
-    }
-
-    /**
-     * Magic call to dynamic relationships.
-     *
-     * @param string $method
-     * @param array  $parameters
-     *
-     * @throws Exception
-     *
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        if (!array_key_exists($method, $this->dynamicRelationships)) {
-            throw new Exception(get_class($this)." has no method $method");
-        }
-
-        // Add $this to parameters so the closure can call relationship method on the map.
-        $parameters[] = $this;
-
-        return  call_user_func_array([$this->dynamicRelationships[$method], $parameters]);
-    }
+	/**
+	 * The mapping driver to use with this entity.
+	 *
+	 * @var string
+	 */
+	protected $driver = 'illuminate';
+
+	/**
+	 * The Database Connection name for the model.
+	 *
+	 * @var string
+	 */
+	protected $connection;
+
+	/**
+	 * The table associated with the entity.
+	 *
+	 * @var string|null
+	 */
+	protected $table = null;
+
+	/**
+	 * The primary key for the model.
+	 *
+	 * @var string
+	 */
+	protected $primaryKey = 'id';
+
+	/**
+	 * Name of the entity's array property that should
+	 * contain the attributes.
+	 * If set to null, analogue will only hydrate object's properties.
+	 *
+	 * @var string|null
+	 */
+	protected $arrayName = 'attributes';
+
+	/**
+	 * Array containing the list of database columns to be mapped
+	 * in the attributes array of the entity.
+	 *
+	 * @var array
+	 */
+	protected $attributes = [];
+
+	/**
+	 * Array containing the list of database columns to be mapped
+	 * to the entity's class properties.
+	 *
+	 * @var array
+	 */
+	protected $properties = [];
+
+	/**
+	 * The Custom Domain Class to use with this mapping.
+	 *
+	 * @var string|null
+	 */
+	protected $class = null;
+
+	/**
+	 * Embedded Value Objects.
+	 *
+	 * @var array
+	 */
+	protected $embeddables = [];
+
+	/**
+	 * Determine the relationships method used on the entity.
+	 * If not set, mapper will autodetect them.
+	 *
+	 * @var array
+	 */
+	private $relationships = [];
+
+	/**
+	 * Relationships that should be treated as collection.
+	 *
+	 * @var array
+	 */
+	private $manyRelations = [];
+
+	/**
+	 * Relationships that should be treated as single entity.
+	 *
+	 * @var array
+	 */
+	private $singleRelations = [];
+
+	/**
+	 * Relationships for which the key is stored in the Entity itself.
+	 *
+	 * @var array
+	 */
+	private $localRelations = [];
+
+	/**
+	 * List of local keys associated to local relation methods.
+	 *
+	 * @var array
+	 */
+	private $localForeignKeys = [];
+
+	/**
+	 * Relationships for which the key is stored in the Related Entity.
+	 *
+	 * @var array
+	 */
+	private $foreignRelations = [];
+
+	/**
+	 * Relationships which use a pivot record.
+	 *
+	 * @var array
+	 */
+	private $pivotRelations = [];
+
+	/**
+	 * Dynamic relationships.
+	 *
+	 * @var array
+	 */
+	private $dynamicRelationships = [];
+
+	/**
+	 * Targetted class for the relationship method. value is set to `null` for
+	 * polymorphic relations.
+	 *
+	 * @var array
+	 */
+	private $relatedClasses = [];
+
+	/**
+	 * Some relation methods like embedded objects, or HasOne and MorphOne,
+	 * will never have a proxy loaded on them.
+	 *
+	 * @var array
+	 */
+	private $nonProxyRelationships = [];
+
+	/**
+	 * The number of models to return for pagination.
+	 *
+	 * @var int
+	 */
+	protected $perPage = 15;
+
+	/**
+	 * The relations to eager load on every query.
+	 *
+	 * @var array
+	 */
+	protected $with = [];
+
+	/**
+	 * The class name to be used in polymorphic relations.
+	 *
+	 * @var string
+	 */
+	protected $morphClass;
+
+	/**
+	 * Sequence name, to be used with postgreSql
+	 * defaults to %table_name%_id_seq.
+	 *
+	 * @var string|null
+	 */
+	protected $sequence = null;
+
+	/**
+	 * Indicates if the entity should be timestamped.
+	 *
+	 * @var bool
+	 */
+	public $timestamps = false;
+
+	/**
+	 * The name of the "created at" column.
+	 *
+	 * @var string
+	 */
+	protected $createdAtColumn = 'created_at';
+
+	/**
+	 * The name of the "updated at" column.
+	 *
+	 * @var string
+	 */
+	protected $updatedAtColumn = 'updated_at';
+
+	/**
+	 * Indicates if the entity uses softdeletes.
+	 *
+	 * @var bool
+	 */
+	public $softDeletes = false;
+
+	/**
+	 * The name of the "deleted at" column.
+	 *
+	 * @var string
+	 */
+	protected $deletedAtColumn = 'deleted_at';
+
+	/**
+	 * The date format to use with the current database connection.
+	 *
+	 * @var string
+	 */
+	protected $dateFormat;
+
+	/**
+	 * Set this property to true if the entity should be instantiated
+	 * using the IoC Container.
+	 *
+	 * @var bool
+	 */
+	protected $dependencyInjection = false;
+
+	/**
+	 * Set the usage of inheritance, possible values are :
+	 * "single_table"
+	 * null.
+	 *
+	 * @var string | null
+	 */
+	protected $inheritanceType = null;
+
+	/**
+	 * Discriminator column name.
+	 *
+	 * @var string
+	 */
+	protected $discriminatorColumn = 'type';
+
+	/**
+	 * Allow using a string to define which entity type should be instantiated.
+	 * If not set, analogue will uses entity's FQDN.
+	 *
+	 * @var array
+	 */
+	protected $discriminatorColumnMap = [];
+
+	/**
+	 * Return Domain class attributes, useful when mapping to a Plain PHP Object.
+	 *
+	 * @return array
+	 */
+	public function getAttributes() : array
+	{
+		return $this->attributes;
+	}
+
+	/**
+	 * Set the domain class attributes.
+	 *
+	 * @param array $attributeNames
+	 */
+	public function setAttributes(array $attributeNames)
+	{
+		$this->attributes = $attributeNames;
+	}
+
+	/**
+	 * Return true if the Entity has an 'attributes' array property.
+	 *
+	 * @return bool
+	 */
+	public function usesAttributesArray() : bool
+	{
+		return $this->arrayName === null ? false : true;
+	}
+
+	/**
+	 * Return the name of the Entity's attributes property.
+	 *
+	 * @return string|null
+	 */
+	public function getAttributesArrayName()
+	{
+		return $this->arrayName;
+	}
+
+	/**
+	 * Get all the attribute names for the class, including relationships, embeddables and primary key.
+	 *
+	 * @return array
+	 */
+	public function getCompiledAttributes() : array
+	{
+		$key = $this->getKeyName();
+
+		$embeddables = array_keys($this->getEmbeddables());
+
+		$relationships = $this->getRelationships();
+
+		$attributes = $this->getAttributes();
+
+		return array_merge([$key], $embeddables, $relationships, $attributes);
+	}
+
+	/**
+	 * Set the date format to use with the current database connection.
+	 *
+	 * @param string $format
+	 */
+	public function setDateFormat($format)
+	{
+		$this->dateFormat = $format;
+	}
+
+	/**
+	 * Get the date format to use with the current database connection.
+	 *
+	 *  @return string
+	 */
+	public function getDateFormat() : string
+	{
+		return $this->dateFormat;
+	}
+
+	/**
+	 * Set the Driver for this mapping.
+	 *
+	 * @param string $driver
+	 */
+	public function setDriver($driver)
+	{
+		$this->driver = $driver;
+	}
+
+	/**
+	 * Get the Driver for this mapping.
+	 *
+	 * @return string
+	 */
+	public function getDriver() : string
+	{
+		return $this->driver;
+	}
+
+	/**
+	 * Set the db connection to use on the table.
+	 *
+	 * @param $connection
+	 */
+	public function setConnection($connection)
+	{
+		$this->connection = $connection;
+	}
+
+	/**
+	 * Get the Database connection the Entity is stored on.
+	 *
+	 * @return string | null
+	 */
+	public function getConnection()
+	{
+		return $this->connection;
+	}
+
+	/**
+	 * Get the table associated with the entity.
+	 *
+	 * @return string
+	 */
+	public function getTable() : string
+	{
+		if (!is_null($this->table)) {
+			return $this->table;
+		}
+
+		return str_replace('\\', '', snake_case(str_plural(class_basename($this->getClass()))));
+	}
+
+	/**
+	 * Set the database table name.
+	 *
+	 * @param string $table
+	 */
+	public function setTable($table)
+	{
+		$this->table = $table;
+	}
+
+	/**
+	 * Get the pgSql sequence name.
+	 *
+	 * @return string
+	 */
+	public function getSequence() : string
+	{
+		if (!is_null($this->sequence)) {
+			return $this->sequence;
+		} else {
+			return $this->getTable().'_id_seq';
+		}
+	}
+
+	/**
+	 * Get the custom entity class.
+	 *
+	 * @return string namespaced class name
+	 */
+	public function getClass() : string
+	{
+		return isset($this->class) ? $this->class : null;
+	}
+
+	/**
+	 * Set the custom entity class.
+	 *
+	 * @param string $class namespaced class name
+	 */
+	public function setClass($class)
+	{
+		$this->class = $class;
+	}
+
+	/**
+	 * Get the embedded Value Objects.
+	 *
+	 * @return array
+	 */
+	public function getEmbeddables() : array
+	{
+		return $this->embeddables;
+	}
+
+	/**
+	 * Return attributes that should be mapped to class properties.
+	 *
+	 * @return array
+	 */
+	public function getProperties() : array
+	{
+		return $this->properties;
+	}
+
+	/**
+	 * Return the array property in which will be mapped all attributes
+	 * that are not mapped to class properties.
+	 *
+	 * @return string
+	 */
+	public function getAttributesPropertyName() : string
+	{
+	}
+
+	/**
+	 * Set the embedded Value Objects.
+	 *
+	 * @param array $embeddables
+	 */
+	public function setEmbeddables(array $embeddables)
+	{
+		$this->embeddables = $embeddables;
+	}
+
+	/**
+	 * Get the relationships to map on a custom domain
+	 * class.
+	 *
+	 * @return array
+	 */
+	public function getRelationships() : array
+	{
+		return $this->relationships;
+	}
+
+	/**
+	 * Get the relationships that will not have a proxy
+	 * set on them.
+	 *
+	 * @return array
+	 */
+	public function getRelationshipsWithoutProxy() : array
+	{
+		return $this->nonProxyRelationships;
+	}
+
+	/**
+	 * Relationships of the Entity type.
+	 *
+	 * @return array
+	 */
+	public function getSingleRelationships() : array
+	{
+		return $this->singleRelations;
+	}
+
+	/**
+	 * Relationships of type Collection.
+	 *
+	 * @return array
+	 */
+	public function getManyRelationships() : array
+	{
+		return $this->manyRelations;
+	}
+
+	/**
+	 * Relationships with foreign key in the mapped entity record.
+	 *
+	 * @return array
+	 */
+	public function getLocalRelationships() : array
+	{
+		return $this->localRelations;
+	}
+
+	/**
+	 * Return the local keys associated to the relationship.
+	 *
+	 * @param string $relation
+	 *
+	 * @return string | array | null
+	 */
+	public function getLocalKeys($relation)
+	{
+		return isset($this->localForeignKeys[$relation]) ? $this->localForeignKeys[$relation] : null;
+	}
+
+	/**
+	 * Relationships with foreign key in the related Entity record.
+	 *
+	 * @return array
+	 */
+	public function getForeignRelationships() : array
+	{
+		return $this->foreignRelations;
+	}
+
+	/**
+	 * Relationships which keys are stored in a pivot record.
+	 *
+	 * @return array
+	 */
+	public function getPivotRelationships() : array
+	{
+		return $this->pivotRelations;
+	}
+
+	/**
+	 * Get the targetted type for a relationship. Return null if polymorphic.
+	 *
+	 * @param string $relation
+	 *
+	 * @return string | null
+	 */
+	public function getTargettedClass($relation)
+	{
+		return $this->relatedClasses[$relation];
+	}
+
+	/**
+	 * Add a Dynamic Relationship method at runtime. This has to be done
+	 * by hooking the 'initializing' event, before entityMap is initialized.
+	 *
+	 * @param string   $name         Relation name
+	 * @param \Closure $relationship
+	 *
+	 * @return void
+	 */
+	public function addRelationshipMethod($name, \Closure $relationship)
+	{
+		$this->dynamicRelationships[$name] = $relationship;
+	}
+
+	/**
+	 * Get the dynamic relationship method names.
+	 *
+	 * @return array
+	 */
+	public function getDynamicRelationships() : array
+	{
+		return array_keys($this->dynamicRelationships);
+	}
+
+	/**
+	 * Get the relationships that have to be eager loaded
+	 * on each request.
+	 *
+	 * @return array
+	 */
+	public function getEagerloadedRelationships() : array
+	{
+		return $this->with;
+	}
+
+	/**
+	 * Get the primary key attribute for the entity.
+	 *
+	 * @return string
+	 */
+	public function getKeyName() : string
+	{
+		return $this->primaryKey;
+	}
+
+	/**
+	 * Set the primary key for the entity.
+	 *
+	 * @param $key
+	 *
+	 * @return void
+	 */
+	public function setKeyName($key)
+	{
+		$this->primaryKey = $key;
+	}
+
+	/**
+	 * Get the table qualified key name.
+	 *
+	 * @return string
+	 */
+	public function getQualifiedKeyName() : string
+	{
+		return $this->getTable().'.'.$this->getKeyName();
+	}
+
+	/**
+	 * Get the number of models to return per page.
+	 *
+	 * @return int
+	 */
+	public function getPerPage() : int
+	{
+		return $this->perPage;
+	}
+
+	/**
+	 * Set the number of models to return per page.
+	 *
+	 * @param int $perPage
+	 *
+	 * @return void
+	 */
+	public function setPerPage($perPage)
+	{
+		$this->perPage = $perPage;
+	}
+
+	/**
+	 * Determine if the entity uses get.
+	 *
+	 * @return bool
+	 */
+	public function usesTimestamps() : bool
+	{
+		return $this->timestamps;
+	}
+
+	/**
+	 * Determine if the entity uses soft deletes.
+	 *
+	 * @return bool
+	 */
+	public function usesSoftDeletes() : bool
+	{
+		return $this->softDeletes;
+	}
+
+	/**
+	 * Get the 'created_at' column name.
+	 *
+	 * @return string
+	 */
+	public function getCreatedAtColumn() : string
+	{
+		return $this->createdAtColumn;
+	}
+
+	/**
+	 * Get the 'updated_at' column name.
+	 *
+	 * @return string
+	 */
+	public function getUpdatedAtColumn() : string
+	{
+		return $this->updatedAtColumn;
+	}
+
+	/**
+	 * Get the deleted_at column.
+	 *
+	 * @return string
+	 */
+	public function getQualifiedDeletedAtColumn() : string
+	{
+		return $this->deletedAtColumn;
+	}
+
+	/**
+	 * Get the default foreign key name for the model.
+	 *
+	 * @return string
+	 */
+	public function getForeignKey() : string
+	{
+		return snake_case(class_basename($this->getClass())).'_id';
+	}
+
+	/**
+	 * Return the inheritance type used by the entity.
+	 *
+	 * @return string|null
+	 */
+	public function getInheritanceType()
+	{
+		return $this->inheritanceType;
+	}
+
+	/**
+	 * Return the discriminator column name on the entity that's
+	 * used for table inheritance.
+	 *
+	 * @return string
+	 */
+	public function getDiscriminatorColumn() : string
+	{
+		return $this->discriminatorColumn;
+	}
+
+	/**
+	 * Return the mapping of discriminator column values to
+	 * entity class names that are used for table inheritance.
+	 *
+	 * @return array
+	 */
+	public function getDiscriminatorColumnMap() : array
+	{
+		return $this->discriminatorColumnMap;
+	}
+
+	/**
+	 * Return true if the entity should be instanciated using
+	 * the IoC Container.
+	 *
+	 * @return bool
+	 */
+	public function useDependencyInjection() : bool
+	{
+		return $this->dependencyInjection;
+	}
+
+	/**
+	 * Add a single relation method name once.
+	 *
+	 * @param string $relation
+	 */
+	protected function addSingleRelation($relation)
+	{
+		if (!in_array($relation, $this->singleRelations)) {
+			$this->singleRelations[] = $relation;
+		}
+	}
+
+	/**
+	 * Add a foreign relation method name once.
+	 *
+	 * @param string $relation
+	 */
+	protected function addForeignRelation($relation)
+	{
+		if (!in_array($relation, $this->foreignRelations)) {
+			$this->foreignRelations[] = $relation;
+		}
+	}
+
+	/**
+	 * Add a non proxy relation method name once.
+	 *
+	 * @param string $relation
+	 */
+	protected function addNonProxyRelation($relation)
+	{
+		if (!in_array($relation, $this->nonProxyRelationships)) {
+			$this->nonProxyRelationships[] = $relation;
+		}
+	}
+
+	/**
+	 * Add a local relation method name once.
+	 *
+	 * @param string $relation
+	 */
+	protected function addLocalRelation($relation)
+	{
+		if (!in_array($relation, $this->localRelations)) {
+			$this->localRelations[] = $relation;
+		}
+	}
+
+	/**
+	 * Add a many relation method name once.
+	 *
+	 * @param string $relation
+	 */
+	protected function addManyRelation($relation)
+	{
+		if (!in_array($relation, $this->manyRelations)) {
+			$this->manyRelations[] = $relation;
+		}
+	}
+
+	/**
+	 * Add a pivot relation method name once.
+	 *
+	 * @param string $relation
+	 */
+	protected function addPivotRelation($relation)
+	{
+		if (!in_array($relation, $this->pivotRelations)) {
+			$this->pivotRelations[] = $relation;
+		}
+	}
+
+	/**
+	 * Define a one-to-one relationship.
+	 *
+	 * @param mixed  $entity
+	 * @param string $related    entity class
+	 * @param string $foreignKey
+	 * @param string $localKey
+	 *
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\Relationships\HasOne
+	 */
+	public function hasOne($entity, $related, $foreignKey = null, $localKey = null)
+	{
+		$foreignKey = $foreignKey ?: $this->getForeignKey();
+
+		$relatedMapper = Manager::getInstance()->mapper($related);
+
+		$relatedMap = $relatedMapper->getEntityMap();
+
+		$localKey = $localKey ?: $this->getKeyName();
+
+		// Add the relation to the definition in map
+		list(, $caller) = debug_backtrace(false);
+		$relation = $caller['function'];
+		$this->relatedClasses[$relation] = $related;
+
+		$this->addSingleRelation($relation);
+		$this->addForeignRelation($relation);
+		$this->addNonProxyRelation($relation);
+
+		// This relationship will always be eager loaded, as proxying it would
+		// mean having an object that doesn't actually exists.
+		if (!in_array($relation, $this->with)) {
+			$this->with[] = $relation;
+		}
+
+		return new HasOne($relatedMapper, $entity, $relatedMap->getTable().'.'.$foreignKey, $localKey);
+	}
+
+	/**
+	 * Define a polymorphic one-to-one relationship.
+	 *
+	 * @param mixed       $entity
+	 * @param string      $related
+	 * @param string      $name
+	 * @param string|null $type
+	 * @param string|null $id
+	 * @param string|null $localKey
+	 *
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\Relationships\MorphOne
+	 */
+	public function morphOne($entity, $related, $name, $type = null, $id = null, $localKey = null)
+	{
+		list($type, $id) = $this->getMorphs($name, $type, $id);
+
+		$localKey = $localKey ?: $this->getKeyName();
+
+		$relatedMapper = Manager::getInstance()->mapper($related);
+
+		$table = $relatedMapper->getEntityMap()->getTable();
+
+		// Add the relation to the definition in map
+		list(, $caller) = debug_backtrace(false);
+		$relation = $caller['function'];
+		$this->relatedClasses[$relation] = $related;
+
+		$this->addSingleRelation($relation);
+		$this->addForeignRelation($relation);
+		$this->addNonProxyRelation($relation);
+
+		// This relationship will always be eager loaded, as proxying it would
+		// mean having an object that doesn't actually exists.
+		if (!in_array($relation, $this->with)) {
+			$this->with[] = $relation;
+		}
+
+		return new MorphOne($relatedMapper, $entity, $table.'.'.$type, $table.'.'.$id, $localKey);
+	}
+
+	/**
+	 * Define an inverse one-to-one or many relationship.
+	 *
+	 * @param mixed       $entity
+	 * @param string      $related
+	 * @param string|null $foreignKey
+	 * @param string|null $otherKey
+	 * @param string|null $relation
+	 *
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\Relationships\BelongsTo
+	 */
+	public function belongsTo($entity, $related, $foreignKey = null, $otherKey = null)
+	{
+		// Add the relation to the definition in map
+		list(, $caller) = debug_backtrace(false);
+		$relation = $caller['function'];
+		$this->relatedClasses[$relation] = $related;
+
+		$this->addSingleRelation($relation);
+		$this->addLocalRelation($relation);
+
+		// If no foreign key was supplied, we can use a backtrace to guess the proper
+		// foreign key name by using the name of the relationship function, which
+		// when combined with an "_id" should conventionally match the columns.
+		if (is_null($foreignKey)) {
+			$foreignKey = snake_case($relation).'_id';
+		}
+
+		$this->localForeignKeys[$relation] = $foreignKey;
+
+		$relatedMapper = Manager::getInstance()->mapper($related);
+
+		$otherKey = $otherKey ?: $relatedMapper->getEntityMap()->getKeyName();
+
+		return new BelongsTo($relatedMapper, $entity, $foreignKey, $otherKey, $relation);
+	}
+
+	/**
+	 * Define a polymorphic, inverse one-to-one or many relationship.
+	 *
+	 * @param mixed       $entity
+	 * @param string|null $name
+	 * @param string|null $type
+	 * @param string|null $id
+	 *
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\Relationships\MorphTo
+	 */
+	public function morphTo($entity, $name = null, $type = null, $id = null)
+	{
+		// If no name is provided, we will use the backtrace to get the function name
+		// since that is most likely the name of the polymorphic interface. We can
+		// use that to get both the class and foreign key that will be utilized.
+		if (is_null($name)) {
+			list(, $caller) = debug_backtrace(false);
+
+			$name = snake_case($caller['function']);
+		}
+		$this->addSingleRelations($name);
+		$this->addLocalRelation($name);
+		$this->addForeignRelations($name);
+		$this->relatedClass[$relation] = null;
+
+		list($type, $id) = $this->getMorphs($name, $type, $id);
+
+		// Store the foreign key in the entity map.
+		// We might want to store the (key, type) as we might need it
+		// to build a MorphTo proxy
+		$this->localForeignKeys[$name] = [
+			'id'   => $id,
+			'type' => $type,
+		];
+
+		$mapper = Manager::getInstance()->mapper(get_class($entity));
+
+		// If the type value is null it is probably safe to assume we're eager loading
+		// the relationship. When that is the case we will pass in a dummy query as
+		// there are multiple types in the morph and we can't use single queries.
+		$factory = new Factory();
+		$wrapper = $factory->make($entity);
+
+		if (is_null($class = $wrapper->getEntityAttribute($type))) {
+			return new MorphTo(
+				$mapper, $entity, $id, null, $type, $name
+			);
+		}
+
+		// If we are not eager loading the relationship we will essentially treat this
+		// as a belongs-to style relationship since morph-to extends that class and
+		// we will pass in the appropriate values so that it behaves as expected.
+		else {
+			$class = Manager::getInstance()->getInverseMorphMap($class);
+			$relatedMapper = Manager::getInstance()->mapper($class);
+
+			$foreignKey = $relatedMapper->getEntityMap()->getKeyName();
+
+			return new MorphTo(
+				$relatedMapper, $entity, $id, $foreignKey, $type, $name
+			);
+		}
+	}
+
+	/**
+	 * Define a one-to-many relationship.
+	 *
+	 * @param mixed       $entity
+	 * @param string      $related
+	 * @param string|null $foreignKey
+	 * @param string|null $localKey
+	 *
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\Relationships\HasMany
+	 */
+	public function hasMany($entity, $related, $foreignKey = null, $localKey = null)
+	{
+		$foreignKey = $foreignKey ?: $this->getForeignKey();
+
+		$relatedMapper = Manager::getInstance()->mapper($related);
+
+		$table = $relatedMapper->getEntityMap()->getTable().'.'.$foreignKey;
+
+		$localKey = $localKey ?: $this->getKeyName();
+
+		// Add the relation to the definition in map
+		list(, $caller) = debug_backtrace(false);
+		$relation = $caller['function'];
+		$this->relatedClasses[$relation] = $related;
+
+		$this->addManyRelation($relation);
+		$this->addForeignRelation($relation);
+
+		return new HasMany($relatedMapper, $entity, $table, $localKey);
+	}
+
+	/**
+	 * Define a has-many-through relationship.
+	 *
+	 * @param mixed       $entity
+	 * @param string      $related
+	 * @param string      $through
+	 * @param string|null $firstKey
+	 * @param string|null $secondKey
+	 *
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\Relationships\HasManyThrough
+	 */
+	public function hasManyThrough($entity, $related, $through, $firstKey = null, $secondKey = null)
+	{
+		$relatedMapper = Manager::getInstance()->mapper($related);
+
+		$throughMapper = Manager::getInstance()->mapper($through);
+
+		$firstKey = $firstKey ?: $this->getForeignKey();
+
+		$throughMap = $throughMapper->getEntityMap();
+
+		$secondKey = $secondKey ?: $throughMap->getForeignKey();
+
+		// Add the relation to the definition in map
+		list(, $caller) = debug_backtrace(false);
+		$relation = $caller['function'];
+		$this->relatedClasses[$relation] = $related;
+
+		$this->addManyRelation($relation);
+		$this->addForeignRelation($relation);
+
+		return new HasManyThrough($relatedMapper, $entity, $throughMap, $firstKey, $secondKey);
+	}
+
+	/**
+	 * Define a polymorphic one-to-many relationship.
+	 *
+	 * @param mixed       $entity
+	 * @param string      $related
+	 * @param string      $name
+	 * @param string|null $type
+	 * @param string|null $id
+	 * @param string|null $localKey
+	 *
+	 * @return \Analogue\ORM\Relationships\MorphMany
+	 */
+	public function morphMany($entity, $related, $name, $type = null, $id = null, $localKey = null)
+	{
+		// Here we will gather up the morph type and ID for the relationship so that we
+		// can properly query the intermediate table of a relation. Finally, we will
+		// get the table and create the relationship instances for the developers.
+		list($type, $id) = $this->getMorphs($name, $type, $id);
+
+		$relatedMapper = Manager::getInstance()->mapper($related);
+
+		$table = $relatedMapper->getEntityMap()->getTable();
+
+		$localKey = $localKey ?: $this->getKeyName();
+
+		// Add the relation to the definition in map
+		list(, $caller) = debug_backtrace(false);
+		$relation = $caller['function'];
+		$this->relatedClasses[$relation] = $related;
+
+		$this->addManyRelation($relation);
+		$this->addForeignRelation($relation);
+
+		return new MorphMany($relatedMapper, $entity, $table.'.'.$type, $table.'.'.$id, $localKey);
+	}
+
+	/**
+	 * Define a many-to-many relationship.
+	 *
+	 * @param mixed       $entity
+	 * @param string      $relatedClass
+	 * @param string|null $table
+	 * @param string|null $foreignKey
+	 * @param string|null $otherKey
+	 * @param string|null $relation
+	 *
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\Relationships\BelongsToMany
+	 */
+	public function belongsToMany($entity, $related, $table = null, $foreignKey = null, $otherKey = null)
+	{
+		// Add the relation to the definition in map
+		list(, $caller) = debug_backtrace(false);
+		$relation = $caller['function'];
+		$this->relatedClasses[$relation] = $related;
+
+		$this->addManyRelation($relation);
+		$this->addForeignRelation($relation);
+		$this->addPivotRelation($relation);
+
+		// First, we'll need to determine the foreign key and "other key" for the
+		// relationship. Once we have determined the keys we'll make the query
+		// instances as well as the relationship instances we need for this.
+		$foreignKey = $foreignKey ?: $this->getForeignKey();
+
+		$relatedMapper = Manager::getInstance()->mapper($related);
+
+		$relatedMap = $relatedMapper->getEntityMap();
+
+		$otherKey = $otherKey ?: $relatedMap->getForeignKey();
+
+		// If no table name was provided, we can guess it by concatenating the two
+		// models using underscores in alphabetical order. The two model names
+		// are transformed to snake case from their default CamelCase also.
+		if (is_null($table)) {
+			$table = $this->joiningTable($relatedMap);
+		}
+
+		return new BelongsToMany($relatedMapper, $entity, $table, $foreignKey, $otherKey, $relation);
+	}
+
+	/**
+	 * Define a polymorphic many-to-many relationship.
+	 *
+	 * @param mixed       $entity
+	 * @param string      $related
+	 * @param string      $name
+	 * @param string|null $table
+	 * @param string|null $foreignKey
+	 * @param string|null $otherKey
+	 * @param bool        $inverse
+	 *
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\Relationships\MorphToMany
+	 */
+	public function morphToMany($entity, $related, $name, $table = null, $foreignKey = null, $otherKey = null, $inverse = false)
+	{
+		// Add the relation to the definition in map
+		list(, $caller) = debug_backtrace(false);
+		$relation = $caller['function'];
+		$this->relatedClasses[$relation] = $related;
+
+		$this->addManyRelation($relation);
+		$this->addForeignRelation($relation);
+		$this->addPivotRelation($relation);
+
+		// First, we will need to determine the foreign key and "other key" for the
+		// relationship. Once we have determined the keys we will make the query
+		// instances, as well as the relationship instances we need for these.
+		$foreignKey = $foreignKey ?: $name.'_id';
+
+		$relatedMapper = Manager::getInstance()->mapper($related);
+
+		$otherKey = $otherKey ?: $relatedMapper->getEntityMap()->getForeignKey();
+
+		$table = $table ?: str_plural($name);
+
+		return new MorphToMany($relatedMapper, $entity, $name, $table, $foreignKey, $otherKey, $caller, $inverse);
+	}
+
+	/**
+	 * Define a polymorphic, inverse many-to-many relationship.
+	 *
+	 * @param mixed       $entity
+	 * @param string      $related
+	 * @param string      $name
+	 * @param string|null $table
+	 * @param string|null $foreignKey
+	 * @param string|null $otherKey
+	 *
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\Relationships\MorphToMany
+	 */
+	public function morphedByMany($entity, $related, $name, $table = null, $foreignKey = null, $otherKey = null)
+	{
+		// Add the relation to the definition in map
+		list(, $caller) = debug_backtrace(false);
+		$relation = $caller['function'];
+		$this->relatedClasses[$relation] = $related;
+
+		$this->addManyRelation($relation);
+		$this->addForeignRelation($relation);
+
+		$foreignKey = $foreignKey ?: $this->getForeignKey();
+
+		// For the inverse of the polymorphic many-to-many relations, we will change
+		// the way we determine the foreign and other keys, as it is the opposite
+		// of the morph-to-many method since we're figuring out these inverses.
+		$otherKey = $otherKey ?: $name.'_id';
+
+		return $this->morphToMany($entity, $related, $name, $table, $foreignKey, $otherKey, true);
+	}
+
+	/**
+	 * Get the joining table name for a many-to-many relation.
+	 *
+	 * @param EntityMap $relatedMap
+	 *
+	 * @return string
+	 */
+	public function joiningTable($relatedMap)
+	{
+		// The joining table name, by convention, is simply the snake cased models
+		// sorted alphabetically and concatenated with an underscore, so we can
+		// just sort the models and join them together to get the table name.
+		$base = $this->getTable();
+
+		$related = $relatedMap->getTable();
+
+		$tables = [$related, $base];
+
+		// Now that we have the model names in an array we can just sort them and
+		// use the implode function to join them together with an underscores,
+		// which is typically used by convention within the database system.
+		sort($tables);
+
+		return strtolower(implode('_', $tables));
+	}
+
+	/**
+	 * Get the polymorphic relationship columns.
+	 *
+	 * @param string $name
+	 * @param string $type
+	 * @param string $id
+	 *
+	 * @return string[]
+	 */
+	protected function getMorphs($name, $type, $id)
+	{
+		$type = $type ?: $name.'_type';
+
+		$id = $id ?: $name.'_id';
+
+		return [$type, $id];
+	}
+
+	/**
+	 * Get the class name for polymorphic relations.
+	 *
+	 * @return string
+	 */
+	public function getMorphClass()
+	{
+		$morphClass = Manager::getInstance()->getMorphMap($this->getClass());
+
+		return $this->morphClass ?: $morphClass;
+	}
+
+	/**
+	 * Create a new Entity Collection instance.
+	 *
+	 * @param array $entities
+	 *
+	 * @return \Analogue\ORM\EntityCollection
+	 */
+	public function newCollection(array $entities = [])
+	{
+		$collection = new EntityCollection($entities, $this);
+
+		return $collection->keyBy($this->getKeyName());
+	}
+
+	/**
+	 * Process EntityMap parsing at initialization time.
+	 *
+	 * @return void
+	 */
+	public function initialize()
+	{
+		$userMethods = $this->getCustomMethods();
+
+		// Parse EntityMap for method based relationship
+		if (count($userMethods) > 0) {
+			$this->relationships = $this->parseMethodsForRelationship($userMethods);
+		}
+
+		// Parse EntityMap for dynamic relationships
+		if (count($this->dynamicRelationships) > 0) {
+			$this->relationships = $this->relationships + $this->getDynamicRelationships();
+		}
+	}
+
+	/**
+	 * Parse every relationships on the EntityMap and sort
+	 * them by type.
+	 *
+	 * @return void
+	 */
+	public function boot()
+	{
+		if (count($this->relationships > 0)) {
+			$this->sortRelationshipsByType();
+		}
+	}
+
+	/**
+	 * Get Methods that has been added in the child class.
+	 *
+	 * @return array
+	 */
+	protected function getCustomMethods()
+	{
+		$mapMethods = get_class_methods($this);
+
+		$parentsMethods = get_class_methods('Analogue\ORM\EntityMap');
+
+		return array_diff($mapMethods, $parentsMethods);
+	}
+
+	/**
+	 * Parse user's class methods for relationships.
+	 *
+	 * @param array $customMethods
+	 *
+	 * @return array
+	 */
+	protected function parseMethodsForRelationship(array $customMethods)
+	{
+		$relationships = [];
+
+		$class = new ReflectionClass(get_class($this));
+
+		// Get the mapped Entity class, as we will detect relationships
+		// methods by testing that the first argument is type-hinted to
+		// the same class as the mapped Entity.
+		$entityClass = $this->getClass();
+
+		foreach ($customMethods as $methodName) {
+			$method = $class->getMethod($methodName);
+
+			if ($method->getNumberOfParameters() > 0) {
+				$params = $method->getParameters();
+
+				if ($params[0]->getClass() && ($params[0]->getClass()->name == $entityClass || is_subclass_of($entityClass, $params[0]->getClass()->name))) {
+					$relationships[] = $methodName;
+				}
+			}
+		}
+
+		return $relationships;
+	}
+
+	/**
+	 * Sort Relationships methods by type.
+	 *
+	 * TODO : replace this by direclty setting these value
+	 * in the corresponding methods, so we won't need
+	 * the correpondancy tabble
+	 *
+	 * @return void
+	 */
+	protected function sortRelationshipsByType()
+	{
+		$entityClass = $this->getClass();
+
+		// Instantiate a dummy entity which we will pass to relationship methods.
+		$entity = unserialize(sprintf('O:%d:"%s":0:{}', strlen($entityClass), $entityClass));
+
+		foreach ($this->relationships as $relation) {
+			$this->$relation($entity);
+		}
+	}
+
+	/**
+	 * Override this method for custom entity instantiation.
+	 *
+	 * @return null
+	 */
+	public function activator()
+	{
+	}
+
+	/**
+	 * Magic call to dynamic relationships.
+	 *
+	 * @param string $method
+	 * @param array  $parameters
+	 *
+	 * @throws Exception
+	 *
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		if (!array_key_exists($method, $this->dynamicRelationships)) {
+			throw new Exception(get_class($this)." has no method $method");
+		}
+
+		// Add $this to parameters so the closure can call relationship method on the map.
+		$parameters[] = $this;
+
+		return  call_user_func_array([$this->dynamicRelationships[$method], $parameters]);
+	}
 }

src/Plugins/SoftDeletes/SoftDeletingScope.php

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
      */

Indentation +108 added lines, -108 removed lines

@@ -7,112 +7,112 @@
 
 class SoftDeletingScope implements ScopeInterface
 {
-    /**
-     * All of the extensions to be added to the builder.
-     *
-     * @var array
-     */
-    protected $extensions = ['WithTrashed', 'OnlyTrashed'];
-
-    /**
-     * Apply the scope to a given Analogue query builder.
-     *
-     * @param \Analogue\ORM\System\Query $query
-     *
-     * @return void
-     */
-    public function apply(Query $query)
-    {
-        $entityMap = $query->getMapper()->getEntityMap();
-
-        $query->whereNull($entityMap->getQualifiedDeletedAtColumn());
-
-        $this->extend($query);
-    }
-
-    /**
-     * Remove the scope from the given Analogue query builder.
-     *
-     * @param mixed $query
-     *
-     * @return void
-     */
-    public function remove(Query $query)
-    {
-        $column = $query->getMapper()->getEntityMap()->getQualifiedDeletedAtColumn();
-
-        $query = $query->getQuery();
-
-        foreach ((array) $query->wheres as $key => $where) {
-            // If the where clause is a soft delete date constraint, we will remove it from
-            // the query and reset the keys on the wheres. This allows this developer to
-            // include deleted model in a relationship result set that is lazy loaded.
-            if ($this->isSoftDeleteConstraint($where, $column)) {
-                unset($query->wheres[$key]);
-
-                $query->wheres = array_values($query->wheres);
-            }
-        }
-    }
-
-    /**
-     * Extend the query builder with the needed functions.
-     *
-     * @param \Analogue\ORM\System\Query $query
-     *
-     * @return void
-     */
-    public function extend(Query $query)
-    {
-        foreach ($this->extensions as $extension) {
-            $this->{"add{$extension}"}($query);
-        }
-    }
-
-    /**
-     * Add the with-trashed extension to the builder.
-     *
-     * @param \Analogue\ORM\System\Query $query
-     *
-     * @return void
-     */
-    protected function addWithTrashed(Query $query)
-    {
-        $query->macro('withTrashed', function (Query $query) {
-            $this->remove($query);
-
-            return $query;
-        });
-    }
-
-    /**
-     * Add the only-trashed extension to the builder.
-     *
-     * @param \Analogue\ORM\System\Query $query
-     *
-     * @return void
-     */
-    protected function addOnlyTrashed(Query $query)
-    {
-        $query->macro('onlyTrashed', function (Query $query) {
-            $this->remove($query);
-
-            $query->getQuery()->whereNotNull($query->getMapper()->getEntityMap()->getQualifiedDeletedAtColumn());
-
-            return $query;
-        });
-    }
-
-    /**
-     * Determine if the given where clause is a soft delete constraint.
-     *
-     * @param array  $where
-     * @param string $column
-     *
-     * @return bool
-     */
-    protected function isSoftDeleteConstraint(array $where, $column)
-    {
-        return $where['type'] == 'Null' && $where['column'] == $column;
-    }
+	/**
+	 * All of the extensions to be added to the builder.
+	 *
+	 * @var array
+	 */
+	protected $extensions = ['WithTrashed', 'OnlyTrashed'];
+
+	/**
+	 * Apply the scope to a given Analogue query builder.
+	 *
+	 * @param \Analogue\ORM\System\Query $query
+	 *
+	 * @return void
+	 */
+	public function apply(Query $query)
+	{
+		$entityMap = $query->getMapper()->getEntityMap();
+
+		$query->whereNull($entityMap->getQualifiedDeletedAtColumn());
+
+		$this->extend($query);
+	}
+
+	/**
+	 * Remove the scope from the given Analogue query builder.
+	 *
+	 * @param mixed $query
+	 *
+	 * @return void
+	 */
+	public function remove(Query $query)
+	{
+		$column = $query->getMapper()->getEntityMap()->getQualifiedDeletedAtColumn();
+
+		$query = $query->getQuery();
+
+		foreach ((array) $query->wheres as $key => $where) {
+			// If the where clause is a soft delete date constraint, we will remove it from
+			// the query and reset the keys on the wheres. This allows this developer to
+			// include deleted model in a relationship result set that is lazy loaded.
+			if ($this->isSoftDeleteConstraint($where, $column)) {
+				unset($query->wheres[$key]);
+
+				$query->wheres = array_values($query->wheres);
+			}
+		}
+	}
+
+	/**
+	 * Extend the query builder with the needed functions.
+	 *
+	 * @param \Analogue\ORM\System\Query $query
+	 *
+	 * @return void
+	 */
+	public function extend(Query $query)
+	{
+		foreach ($this->extensions as $extension) {
+			$this->{"add{$extension}"}($query);
+		}
+	}
+
+	/**
+	 * Add the with-trashed extension to the builder.
+	 *
+	 * @param \Analogue\ORM\System\Query $query
+	 *
+	 * @return void
+	 */
+	protected function addWithTrashed(Query $query)
+	{
+		$query->macro('withTrashed', function (Query $query) {
+			$this->remove($query);
+
+			return $query;
+		});
+	}
+
+	/**
+	 * Add the only-trashed extension to the builder.
+	 *
+	 * @param \Analogue\ORM\System\Query $query
+	 *
+	 * @return void
+	 */
+	protected function addOnlyTrashed(Query $query)
+	{
+		$query->macro('onlyTrashed', function (Query $query) {
+			$this->remove($query);
+
+			$query->getQuery()->whereNotNull($query->getMapper()->getEntityMap()->getQualifiedDeletedAtColumn());
+
+			return $query;
+		});
+	}
+
+	/**
+	 * Determine if the given where clause is a soft delete constraint.
+	 *
+	 * @param array  $where
+	 * @param string $column
+	 *
+	 * @return bool
+	 */
+	protected function isSoftDeleteConstraint(array $where, $column)
+	{
+		return $where['type'] == 'Null' && $where['column'] == $column;
+	}
 }

src/Relationships/HasMany.php

Doc Comments +2 added lines, -2 removed lines

@@ -9,7 +9,7 @@ 
      *
      * @param  $relation
      *
-     * @return mixed
+     * @return \Analogue\ORM\EntityCollection
      */
     public function getResults($relation)
     {
@@ -23,7 +23,7 @@ 
     /**
      * Match the eagerly loaded results to their parents.
      *
-     * @param array  $$results
+     * @param array  $results
      * @param string $relation
      *
      * @return array

Indentation +25 added lines, -25 removed lines

@@ -4,32 +4,32 @@
 
 class HasMany extends HasOneOrMany
 {
-    /**
-     * Lazy-Load the results of the relationship.
-     *
-     * @param  $relation
-     *
-     * @return mixed
-     */
-    public function getResults($relation)
-    {
-        $results = $this->query->get();
+	/**
+	 * Lazy-Load the results of the relationship.
+	 *
+	 * @param  $relation
+	 *
+	 * @return mixed
+	 */
+	public function getResults($relation)
+	{
+		$results = $this->query->get();
 
-        $this->cacheRelation($results, $relation);
+		$this->cacheRelation($results, $relation);
 
-        return $results;
-    }
+		return $results;
+	}
 
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param array  $$results
-     * @param string $relation
-     *
-     * @return array
-     */
-    public function match(array $results, $relation)
-    {
-        return $this->matchMany($results, $relation);
-    }
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param array  $$results
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	public function match(array $results, $relation)
+	{
+		return $this->matchMany($results, $relation);
+	}
 }

src/Relationships/HasManyThrough.php

Doc Comments -1 removed lines

@@ -291,7 +291,6 @@
      * Run synchronization content if needed by the
      * relation type.
      *
-     * @param array $actualContent
      *
      * @return void
      */

Indentation +290 added lines, -290 removed lines

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

Spacing +1 added lines, -1 removed lines

@@ -156,7 +156,7 @@
         // Once we have the dictionary we can simply spin through the parent entities to
         // link them up with their children using the keyed dictionary to make the
         // matching very convenient and easy work. Then we'll just return them.
-        return array_map(function ($result) use ($relation, $relatedKey, $dictionary, $cache, $host) {
+        return array_map(function($result) use ($relation, $relatedKey, $dictionary, $cache, $host) {
             $key = $result[$relatedKey];
 
             if (isset($dictionary[$key])) {

src/System/Manager.php

Doc Comments +3 added lines, -3 removed lines

@@ -143,7 +143,7 @@ 
      * Create a mapper for a given entity.
      *
      * @param \Analogue\ORM\Mappable|string|array|\Traversable $entity
-     * @param mixed                                            $entityMap
+     * @param null|EntityMap                                            $entityMap
      *
      * @throws MappingException
      * @throws \InvalidArgumentException
@@ -251,7 +251,7 @@ 
     /**
      * Check if the entity is already registered.
      *
-     * @param string|Entity $entity
+     * @param string $entity
      *
      * @return bool
      */
@@ -333,7 +333,7 @@ 
     /**
      * Register an entity.
      *
-     * @param string|\Analogue\ORM\Mappable $entity    entity's class name
+     * @param string $entity    entity's class name
      * @param string|EntityMap              $entityMap map's class name
      *
      * @throws MappingException

Indentation +689 added lines, -689 removed lines

@@ -21,693 +21,693 @@
  */
 class Manager
 {
-    /**
-     * Manager instance.
-     *
-     * @var Manager
-     */
-    protected static $instance;
-
-    /**
-     * Driver Manager.
-     *
-     * @var \Analogue\ORM\Drivers\Manager
-     */
-    protected $drivers;
-
-    /**
-     * Registered entity classes and corresponding map objects.
-     *
-     * @var array
-     */
-    protected $entityClasses = [];
-
-    /**
-     * Key value store of ValueObject Classes and corresponding map classes.
-     *
-     * @var array|ValueMap[]
-     */
-    protected $valueClasses = [];
-
-    /**
-     * Morph map.
-     */
-    protected $morphMap = [];
-
-    /**
-     * Loaded Mappers.
-     *
-     * @var array
-     */
-    protected $mappers = [];
-
-    /**
-     * Loaded Repositories.
-     *
-     * @var array
-     */
-    protected $repositories = [];
-
-    /**
-     * Event dispatcher instance.
-     *
-     * @var \Illuminate\Contracts\Events\Dispatcher
-     */
-    protected $eventDispatcher;
-
-    /**
-     * Available Analogue Events.
-     *
-     * @var array
-     */
-    protected $events = [
-        'initializing',
-        'initialized',
-        'store',
-        'stored',
-        'creating',
-        'created',
-        'updating',
-        'updated',
-        'deleting',
-        'deleted',
-    ];
-
-    /**
-     * If strictMode is set to true, Manager will throw
-     * an exception if no entityMap class are registered
-     * for a given entity class.
-     *
-     * @var bool
-     */
-    protected $strictMode = true;
-
-    /**
-     * We can add namespaces in this array where the manager
-     * will look for when auto registering entityMaps.
-     *
-     * @var array
-     */
-    protected $customMapNamespaces = [];
-
-    /**
-     * @param \Analogue\ORM\Drivers\Manager $driverManager
-     * @param Dispatcher                    $event
-     */
-    public function __construct(DriverManager $driverManager, Dispatcher $event)
-    {
-        $this->drivers = $driverManager;
-
-        $this->eventDispatcher = $event;
-
-        static::$instance = $this;
-    }
-
-    /**
-     * Create a mapper for a given entity (static alias).
-     *
-     * @param \Analogue\ORM\Mappable|string $entity
-     * @param null|EntityMap                $entityMap
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return Mapper
-     */
-    public static function getMapper($entity, $entityMap = null)
-    {
-        return static::$instance->mapper($entity, $entityMap);
-    }
-
-    /**
-     * Create a mapper for a given entity.
-     *
-     * @param \Analogue\ORM\Mappable|string|array|\Traversable $entity
-     * @param mixed                                            $entityMap
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return Mapper
-     */
-    public function mapper($entity, $entityMap = null)
-    {
-        if ($entity instanceof Wrapper) {
-            throw new MappingException('Tried to instantiate mapper on wrapped Entity');
-        }
-
-        $entity = $this->resolveEntityClass($entity);
-
-        $entity = $this->getInverseMorphMap($entity);
-
-        // Return existing mapper instance if exists.
-        if (array_key_exists($entity, $this->mappers)) {
-            return $this->mappers[$entity];
-        } else {
-            return $this->buildMapper($entity, $entityMap);
-        }
-    }
-
-    /**
-     * This method resolve entity class from mappable instances or iterators.
-     *
-     * @param \Analogue\ORM\Mappable|string|array|\Traversable $entity
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return string
-     */
-    protected function resolveEntityClass($entity)
-    {
-        // We first check if the entity is traversable and we'll resolve
-        // the entity based on the first item of the object.
-        if ($this->isTraversable($entity)) {
-            if (!count($entity)) {
-                throw new \InvalidArgumentException('Length of Entity collection must be greater than 0');
-            }
-
-            $firstEntityItem = ($entity instanceof \Iterator)
-                ? $entity->current()
-                : current($entity);
-
-            return $this->resolveEntityClass($firstEntityItem);
-        }
-
-        if (is_object($entity)) {
-            return get_class($entity);
-        }
-
-        if (is_string($entity)) {
-            return $entity;
-        }
-
-        throw new \InvalidArgumentException('Invalid entity type');
-    }
-
-    /**
-     * @param string $key
-     *
-     * @return string
-     */
-    public function getInverseMorphMap($key)
-    {
-        return array_key_exists($key, $this->morphMap) ? $this->morphMap[$key] : $key;
-    }
-
-    /**
-     * Build a new Mapper instance for a given Entity.
-     *
-     * @param string $entity
-     * @param        $entityMap
-     *
-     * @throws MappingException
-     *
-     * @return Mapper
-     */
-    protected function buildMapper($entity, $entityMap)
-    {
-        // If an EntityMap hasn't been manually registered by the user
-        // register it at runtime.
-        if (!$this->isRegisteredEntity($entity)) {
-            $this->register($entity, $entityMap);
-        }
-
-        $entityMap = $this->entityClasses[$entity];
-
-        $factory = new MapperFactory($this->drivers, $this->eventDispatcher, $this);
-
-        $mapper = $factory->make($entity, $entityMap);
-
-        $this->mappers[$entity] = $mapper;
-
-        // At this point we can safely call the boot() method on the entityMap as
-        // the mapper is now instantiated & registered within the manager.
-
-        $mapper->getEntityMap()->boot();
-
-        return $mapper;
-    }
-
-    /**
-     * Check if the entity is already registered.
-     *
-     * @param string|Entity $entity
-     *
-     * @return bool
-     */
-    public function isRegisteredEntity($entity)
-    {
-        if (!is_string($entity)) {
-            $entity = get_class($entity);
-        }
-
-        return array_key_exists($entity, $this->entityClasses);
-    }
-
-    /**
-     * Return an array containing registered entities & entityMap instances.
-     *
-     * @return array
-     */
-    public function getRegisteredEntities()
-    {
-        return $this->entityClasses;
-    }
-
-    /**
-     * Check if a value class is already registered.
-     *
-     * @param string|sdtClass $object
-     *
-     * @return bool
-     */
-    public function isRegisteredValueObject($object)
-    {
-        if (!is_string($object)) {
-            $object = get_class($object);
-        }
-
-        return array_key_exists($object, $this->valueClasses);
-    }
-
-    /**
-     * Return true if an object is an array or iterator.
-     *
-     * @param mixed $argument
-     *
-     * @return bool
-     */
-    public function isTraversable($argument)
-    {
-        return $argument instanceof \Traversable || is_array($argument);
-    }
-
-    /**
-     * Set strict mode for entityMap instantiation.
-     *
-     * @param bool $mode
-     */
-    public function setStrictMode($mode)
-    {
-        $this->strictMode = $mode;
-    }
-
-    /**
-     * Register a namespace in where Analogue
-     * will scan for EntityMaps & ValueMaps.
-     *
-     * @param string $namespace
-     *
-     * @return void
-     */
-    public function registerMapNamespace($namespace)
-    {
-        // Add a trailing antislash to namespace if not present
-        if (substr('testers', -1) != '\\') {
-            $namespace = $namespace.'\\';
-        }
-
-        $this->customMapNamespaces[] = $namespace;
-    }
-
-    /**
-     * Register an entity.
-     *
-     * @param string|\Analogue\ORM\Mappable $entity    entity's class name
-     * @param string|EntityMap              $entityMap map's class name
-     *
-     * @throws MappingException
-     *
-     * @return void
-     */
-    public function register($entity, $entityMap = null)
-    {
-        // If an object is provider, get the class name from it
-        if (!is_string($entity)) {
-            $entity = get_class($entity);
-        }
-
-        if ($this->isRegisteredEntity($entity)) {
-            throw new MappingException("Entity $entity is already registered.");
-        }
-
-        if (!class_exists($entity)) {
-            throw new MappingException("Class $entity does not exists");
-        }
-
-        if ($entityMap === null) {
-            $entityMap = $this->getEntityMapInstanceFor($entity);
-        }
-
-        if (is_string($entityMap)) {
-            $entityMap = new $entityMap();
-        }
-
-        if (!$entityMap instanceof EntityMap) {
-            throw new MappingException(get_class($entityMap).' must be an instance of EntityMap.');
-        }
-
-        $entityMap->setClass($entity);
-
-        $this->entityClasses[$entity] = $entityMap;
-    }
-
-    /**
-     * Get the entity map instance for a custom entity.
-     *
-     * @param string $entity
-     *
-     * @return \Analogue\ORM\EntityMap
-     */
-    protected function getEntityMapInstanceFor($entity)
-    {
-        if (class_exists($entity.'Map')) {
-            $map = $entity.'Map';
-            $map = new $map();
-
-            return $map;
-        }
-
-        if ($map = $this->getMapFromNamespaces($entity)) {
-            return $map;
-        }
-
-        if ($this->strictMode) {
-            throw new EntityMapNotFoundException("No Map registered for $entity");
-        }
-
-        $map = $this->getNewEntityMap();
-
-        return $map;
-    }
-
-    /**
-     * Scan through registered custom namespace
-     * for an Entity/ValueMap.
-     *
-     * @param string $class
-     *
-     * @return ValueMap|EntityMap|bool
-     */
-    protected function getMapFromNamespaces($class)
-    {
-        foreach ($this->customMapNamespaces as $namespace) {
-            if ($map = $this->findMapInNamespace($class, $namespace)) {
-                return $map;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * Look in a custom namespace for an Entity/ValueMap.
-     *
-     * @param string $class
-     * @param string $namespace
-     *
-     * @return ValueMap|EntityMap|bool
-     */
-    protected function findMapInNamespace($class, $namespace)
-    {
-        $parts = explode('\\', $class);
-
-        $baseClass = $parts[count($parts) - 1];
-
-        $expectedClass = $namespace.$baseClass.'Map';
-
-        if (class_exists($expectedClass)) {
-            return new $expectedClass();
-        }
-
-        return false;
-    }
-
-    /**
-     * Dynamically create an entity map for a custom entity class.
-     *
-     * @return EntityMap
-     */
-    protected function getNewEntityMap()
-    {
-        return new EntityMap();
-    }
-
-    /**
-     * Return the Singleton instance of the manager.
-     *
-     * @return Manager
-     */
-    public static function getInstance()
-    {
-        return static::$instance;
-    }
-
-    /**
-     * Return the Driver Manager's instance.
-     *
-     * @return \Analogue\ORM\Drivers\Manager
-     */
-    public function getDriverManager()
-    {
-        return $this->drivers;
-    }
-
-    /**
-     * Get the Repository instance for the given Entity.
-     *
-     * @param \Analogue\ORM\Mappable|string $entity
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\Repository
-     */
-    public function repository($entity)
-    {
-        if (!is_string($entity)) {
-            $entity = get_class($entity);
-        }
-
-        // First we check if the repository is not already created.
-        if (array_key_exists($entity, $this->repositories)) {
-            return $this->repositories[$entity];
-        }
-
-        $this->repositories[$entity] = new Repository($this->mapper($entity));
-
-        return $this->repositories[$entity];
-    }
-
-    /**
-     * Return true is the object is registered as value object.
-     *
-     * @param mixed $object
-     *
-     * @return bool
-     */
-    public function isValueObject($object)
-    {
-        if (!is_string($object)) {
-            $object = get_class($object);
-        }
-
-        return array_key_exists($object, $this->valueClasses);
-    }
-
-    /**
-     * Get the Value Map for a given Value Object Class.
-     *
-     * @param string $valueObject
-     *
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\ValueMap
-     */
-    public function getValueMap($valueObject)
-    {
-        if (!is_string($valueObject)) {
-            $valueObject = get_class($valueObject);
-        }
-
-        if (!array_key_exists($valueObject, $this->valueClasses)) {
-            $this->registerValueObject($valueObject);
-        }
-
-        /** @var ValueMap $valueMap */
-        $valueMap = new $this->valueClasses[$valueObject]();
-
-        $valueMap->setClass($valueObject);
-
-        return $valueMap;
-    }
-
-    /**
-     * Register a Value Object.
-     *
-     * @param string $valueObject
-     * @param string $valueMap
-     *
-     * @throws MappingException
-     *
-     * @return void
-     */
-    public function registerValueObject($valueObject, $valueMap = null)
-    {
-        if (!is_string($valueObject)) {
-            $valueObject = get_class($valueObject);
-        }
-
-        if ($valueMap === null) {
-
-            // First, we'll look into registered namespaces for Entity Maps,
-            // if any. Then we'll fallback to the same namespace of the object
-            if (!$valueMap = $this->getMapFromNamespaces($valueObject)) {
-                $valueMap = $valueObject.'Map';
-            } else {
-                $valueMap = get_class($valueMap);
-            }
-        }
-
-        if (!class_exists($valueMap)) {
-            throw new MappingException("$valueMap doesn't exists");
-        }
-
-        $this->valueClasses[$valueObject] = $valueMap;
-    }
-
-    /**
-     * Instantiate a new Value Object instance.
-     *
-     * @param string $valueObject
-     *
-     * @return \Analogue\ORM\ValueObject
-     */
-    public function getValueObjectInstance($valueObject)
-    {
-        $prototype = unserialize(sprintf('O:%d:"%s":0:{}', strlen($valueObject), $valueObject));
-
-        return $prototype;
-    }
-
-    /**
-     * Register Analogue Plugin.
-     *
-     * @param string $plugin class
-     *
-     * @return void
-     */
-    public function registerPlugin($plugin)
-    {
-        /** @var AnaloguePluginInterface $plugin */
-        $plugin = new $plugin($this);
-
-        $this->events = array_merge($this->events, $plugin->getCustomEvents());
-
-        $plugin->register();
-    }
-
-    /**
-     * Register event listeners that will be fired regardless the type
-     * of the entity.
-     *
-     * @param string   $event
-     * @param \Closure $callback
-     *
-     * @throws \LogicException
-     *
-     * @return void
-     */
-    public function registerGlobalEvent($event, $callback)
-    {
-        if (!in_array($event, $this->events, false)) {
-            throw new \LogicException("Analogue : Event $event doesn't exist");
-        }
-
-        $this->eventDispatcher->listen("analogue.{$event}.*", $callback);
-    }
-
-    /**
-     * Shortcut to Mapper store.
-     *
-     * @param mixed $entity
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return mixed
-     */
-    public function store($entity)
-    {
-        return $this->mapper($entity)->store($entity);
-    }
-
-    /**
-     * Shortcut to Mapper delete.
-     *
-     * @param mixed $entity
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return \Illuminate\Support\Collection|null
-     */
-    public function delete($entity)
-    {
-        return $this->mapper($entity)->delete($entity);
-    }
-
-    /**
-     * Shortcut to Mapper query.
-     *
-     * @param mixed $entity
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return Query
-     */
-    public function query($entity)
-    {
-        return $this->mapper($entity)->query();
-    }
-
-    /**
-     * Shortcut to Mapper Global Query.
-     *
-     * @param mixed $entity
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return Query
-     */
-    public function globalQuery($entity)
-    {
-        return $this->mapper($entity)->globalQuery();
-    }
-
-    /**
-     * @param array $morphMap
-     *
-     * @return $this
-     */
-    public function morphMap(array $morphMap)
-    {
-        $this->morphMap = $morphMap;
-
-        return $this;
-    }
-
-    /**
-     * @param string $class
-     *
-     * @return mixed
-     */
-    public function getMorphMap($class)
-    {
-        $key = array_search($class, $this->morphMap, false);
-
-        return $key !== false ? $key : $class;
-    }
+	/**
+	 * Manager instance.
+	 *
+	 * @var Manager
+	 */
+	protected static $instance;
+
+	/**
+	 * Driver Manager.
+	 *
+	 * @var \Analogue\ORM\Drivers\Manager
+	 */
+	protected $drivers;
+
+	/**
+	 * Registered entity classes and corresponding map objects.
+	 *
+	 * @var array
+	 */
+	protected $entityClasses = [];
+
+	/**
+	 * Key value store of ValueObject Classes and corresponding map classes.
+	 *
+	 * @var array|ValueMap[]
+	 */
+	protected $valueClasses = [];
+
+	/**
+	 * Morph map.
+	 */
+	protected $morphMap = [];
+
+	/**
+	 * Loaded Mappers.
+	 *
+	 * @var array
+	 */
+	protected $mappers = [];
+
+	/**
+	 * Loaded Repositories.
+	 *
+	 * @var array
+	 */
+	protected $repositories = [];
+
+	/**
+	 * Event dispatcher instance.
+	 *
+	 * @var \Illuminate\Contracts\Events\Dispatcher
+	 */
+	protected $eventDispatcher;
+
+	/**
+	 * Available Analogue Events.
+	 *
+	 * @var array
+	 */
+	protected $events = [
+		'initializing',
+		'initialized',
+		'store',
+		'stored',
+		'creating',
+		'created',
+		'updating',
+		'updated',
+		'deleting',
+		'deleted',
+	];
+
+	/**
+	 * If strictMode is set to true, Manager will throw
+	 * an exception if no entityMap class are registered
+	 * for a given entity class.
+	 *
+	 * @var bool
+	 */
+	protected $strictMode = true;
+
+	/**
+	 * We can add namespaces in this array where the manager
+	 * will look for when auto registering entityMaps.
+	 *
+	 * @var array
+	 */
+	protected $customMapNamespaces = [];
+
+	/**
+	 * @param \Analogue\ORM\Drivers\Manager $driverManager
+	 * @param Dispatcher                    $event
+	 */
+	public function __construct(DriverManager $driverManager, Dispatcher $event)
+	{
+		$this->drivers = $driverManager;
+
+		$this->eventDispatcher = $event;
+
+		static::$instance = $this;
+	}
+
+	/**
+	 * Create a mapper for a given entity (static alias).
+	 *
+	 * @param \Analogue\ORM\Mappable|string $entity
+	 * @param null|EntityMap                $entityMap
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return Mapper
+	 */
+	public static function getMapper($entity, $entityMap = null)
+	{
+		return static::$instance->mapper($entity, $entityMap);
+	}
+
+	/**
+	 * Create a mapper for a given entity.
+	 *
+	 * @param \Analogue\ORM\Mappable|string|array|\Traversable $entity
+	 * @param mixed                                            $entityMap
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return Mapper
+	 */
+	public function mapper($entity, $entityMap = null)
+	{
+		if ($entity instanceof Wrapper) {
+			throw new MappingException('Tried to instantiate mapper on wrapped Entity');
+		}
+
+		$entity = $this->resolveEntityClass($entity);
+
+		$entity = $this->getInverseMorphMap($entity);
+
+		// Return existing mapper instance if exists.
+		if (array_key_exists($entity, $this->mappers)) {
+			return $this->mappers[$entity];
+		} else {
+			return $this->buildMapper($entity, $entityMap);
+		}
+	}
+
+	/**
+	 * This method resolve entity class from mappable instances or iterators.
+	 *
+	 * @param \Analogue\ORM\Mappable|string|array|\Traversable $entity
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return string
+	 */
+	protected function resolveEntityClass($entity)
+	{
+		// We first check if the entity is traversable and we'll resolve
+		// the entity based on the first item of the object.
+		if ($this->isTraversable($entity)) {
+			if (!count($entity)) {
+				throw new \InvalidArgumentException('Length of Entity collection must be greater than 0');
+			}
+
+			$firstEntityItem = ($entity instanceof \Iterator)
+				? $entity->current()
+				: current($entity);
+
+			return $this->resolveEntityClass($firstEntityItem);
+		}
+
+		if (is_object($entity)) {
+			return get_class($entity);
+		}
+
+		if (is_string($entity)) {
+			return $entity;
+		}
+
+		throw new \InvalidArgumentException('Invalid entity type');
+	}
+
+	/**
+	 * @param string $key
+	 *
+	 * @return string
+	 */
+	public function getInverseMorphMap($key)
+	{
+		return array_key_exists($key, $this->morphMap) ? $this->morphMap[$key] : $key;
+	}
+
+	/**
+	 * Build a new Mapper instance for a given Entity.
+	 *
+	 * @param string $entity
+	 * @param        $entityMap
+	 *
+	 * @throws MappingException
+	 *
+	 * @return Mapper
+	 */
+	protected function buildMapper($entity, $entityMap)
+	{
+		// If an EntityMap hasn't been manually registered by the user
+		// register it at runtime.
+		if (!$this->isRegisteredEntity($entity)) {
+			$this->register($entity, $entityMap);
+		}
+
+		$entityMap = $this->entityClasses[$entity];
+
+		$factory = new MapperFactory($this->drivers, $this->eventDispatcher, $this);
+
+		$mapper = $factory->make($entity, $entityMap);
+
+		$this->mappers[$entity] = $mapper;
+
+		// At this point we can safely call the boot() method on the entityMap as
+		// the mapper is now instantiated & registered within the manager.
+
+		$mapper->getEntityMap()->boot();
+
+		return $mapper;
+	}
+
+	/**
+	 * Check if the entity is already registered.
+	 *
+	 * @param string|Entity $entity
+	 *
+	 * @return bool
+	 */
+	public function isRegisteredEntity($entity)
+	{
+		if (!is_string($entity)) {
+			$entity = get_class($entity);
+		}
+
+		return array_key_exists($entity, $this->entityClasses);
+	}
+
+	/**
+	 * Return an array containing registered entities & entityMap instances.
+	 *
+	 * @return array
+	 */
+	public function getRegisteredEntities()
+	{
+		return $this->entityClasses;
+	}
+
+	/**
+	 * Check if a value class is already registered.
+	 *
+	 * @param string|sdtClass $object
+	 *
+	 * @return bool
+	 */
+	public function isRegisteredValueObject($object)
+	{
+		if (!is_string($object)) {
+			$object = get_class($object);
+		}
+
+		return array_key_exists($object, $this->valueClasses);
+	}
+
+	/**
+	 * Return true if an object is an array or iterator.
+	 *
+	 * @param mixed $argument
+	 *
+	 * @return bool
+	 */
+	public function isTraversable($argument)
+	{
+		return $argument instanceof \Traversable || is_array($argument);
+	}
+
+	/**
+	 * Set strict mode for entityMap instantiation.
+	 *
+	 * @param bool $mode
+	 */
+	public function setStrictMode($mode)
+	{
+		$this->strictMode = $mode;
+	}
+
+	/**
+	 * Register a namespace in where Analogue
+	 * will scan for EntityMaps & ValueMaps.
+	 *
+	 * @param string $namespace
+	 *
+	 * @return void
+	 */
+	public function registerMapNamespace($namespace)
+	{
+		// Add a trailing antislash to namespace if not present
+		if (substr('testers', -1) != '\\') {
+			$namespace = $namespace.'\\';
+		}
+
+		$this->customMapNamespaces[] = $namespace;
+	}
+
+	/**
+	 * Register an entity.
+	 *
+	 * @param string|\Analogue\ORM\Mappable $entity    entity's class name
+	 * @param string|EntityMap              $entityMap map's class name
+	 *
+	 * @throws MappingException
+	 *
+	 * @return void
+	 */
+	public function register($entity, $entityMap = null)
+	{
+		// If an object is provider, get the class name from it
+		if (!is_string($entity)) {
+			$entity = get_class($entity);
+		}
+
+		if ($this->isRegisteredEntity($entity)) {
+			throw new MappingException("Entity $entity is already registered.");
+		}
+
+		if (!class_exists($entity)) {
+			throw new MappingException("Class $entity does not exists");
+		}
+
+		if ($entityMap === null) {
+			$entityMap = $this->getEntityMapInstanceFor($entity);
+		}
+
+		if (is_string($entityMap)) {
+			$entityMap = new $entityMap();
+		}
+
+		if (!$entityMap instanceof EntityMap) {
+			throw new MappingException(get_class($entityMap).' must be an instance of EntityMap.');
+		}
+
+		$entityMap->setClass($entity);
+
+		$this->entityClasses[$entity] = $entityMap;
+	}
+
+	/**
+	 * Get the entity map instance for a custom entity.
+	 *
+	 * @param string $entity
+	 *
+	 * @return \Analogue\ORM\EntityMap
+	 */
+	protected function getEntityMapInstanceFor($entity)
+	{
+		if (class_exists($entity.'Map')) {
+			$map = $entity.'Map';
+			$map = new $map();
+
+			return $map;
+		}
+
+		if ($map = $this->getMapFromNamespaces($entity)) {
+			return $map;
+		}
+
+		if ($this->strictMode) {
+			throw new EntityMapNotFoundException("No Map registered for $entity");
+		}
+
+		$map = $this->getNewEntityMap();
+
+		return $map;
+	}
+
+	/**
+	 * Scan through registered custom namespace
+	 * for an Entity/ValueMap.
+	 *
+	 * @param string $class
+	 *
+	 * @return ValueMap|EntityMap|bool
+	 */
+	protected function getMapFromNamespaces($class)
+	{
+		foreach ($this->customMapNamespaces as $namespace) {
+			if ($map = $this->findMapInNamespace($class, $namespace)) {
+				return $map;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Look in a custom namespace for an Entity/ValueMap.
+	 *
+	 * @param string $class
+	 * @param string $namespace
+	 *
+	 * @return ValueMap|EntityMap|bool
+	 */
+	protected function findMapInNamespace($class, $namespace)
+	{
+		$parts = explode('\\', $class);
+
+		$baseClass = $parts[count($parts) - 1];
+
+		$expectedClass = $namespace.$baseClass.'Map';
+
+		if (class_exists($expectedClass)) {
+			return new $expectedClass();
+		}
+
+		return false;
+	}
+
+	/**
+	 * Dynamically create an entity map for a custom entity class.
+	 *
+	 * @return EntityMap
+	 */
+	protected function getNewEntityMap()
+	{
+		return new EntityMap();
+	}
+
+	/**
+	 * Return the Singleton instance of the manager.
+	 *
+	 * @return Manager
+	 */
+	public static function getInstance()
+	{
+		return static::$instance;
+	}
+
+	/**
+	 * Return the Driver Manager's instance.
+	 *
+	 * @return \Analogue\ORM\Drivers\Manager
+	 */
+	public function getDriverManager()
+	{
+		return $this->drivers;
+	}
+
+	/**
+	 * Get the Repository instance for the given Entity.
+	 *
+	 * @param \Analogue\ORM\Mappable|string $entity
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\Repository
+	 */
+	public function repository($entity)
+	{
+		if (!is_string($entity)) {
+			$entity = get_class($entity);
+		}
+
+		// First we check if the repository is not already created.
+		if (array_key_exists($entity, $this->repositories)) {
+			return $this->repositories[$entity];
+		}
+
+		$this->repositories[$entity] = new Repository($this->mapper($entity));
+
+		return $this->repositories[$entity];
+	}
+
+	/**
+	 * Return true is the object is registered as value object.
+	 *
+	 * @param mixed $object
+	 *
+	 * @return bool
+	 */
+	public function isValueObject($object)
+	{
+		if (!is_string($object)) {
+			$object = get_class($object);
+		}
+
+		return array_key_exists($object, $this->valueClasses);
+	}
+
+	/**
+	 * Get the Value Map for a given Value Object Class.
+	 *
+	 * @param string $valueObject
+	 *
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\ValueMap
+	 */
+	public function getValueMap($valueObject)
+	{
+		if (!is_string($valueObject)) {
+			$valueObject = get_class($valueObject);
+		}
+
+		if (!array_key_exists($valueObject, $this->valueClasses)) {
+			$this->registerValueObject($valueObject);
+		}
+
+		/** @var ValueMap $valueMap */
+		$valueMap = new $this->valueClasses[$valueObject]();
+
+		$valueMap->setClass($valueObject);
+
+		return $valueMap;
+	}
+
+	/**
+	 * Register a Value Object.
+	 *
+	 * @param string $valueObject
+	 * @param string $valueMap
+	 *
+	 * @throws MappingException
+	 *
+	 * @return void
+	 */
+	public function registerValueObject($valueObject, $valueMap = null)
+	{
+		if (!is_string($valueObject)) {
+			$valueObject = get_class($valueObject);
+		}
+
+		if ($valueMap === null) {
+
+			// First, we'll look into registered namespaces for Entity Maps,
+			// if any. Then we'll fallback to the same namespace of the object
+			if (!$valueMap = $this->getMapFromNamespaces($valueObject)) {
+				$valueMap = $valueObject.'Map';
+			} else {
+				$valueMap = get_class($valueMap);
+			}
+		}
+
+		if (!class_exists($valueMap)) {
+			throw new MappingException("$valueMap doesn't exists");
+		}
+
+		$this->valueClasses[$valueObject] = $valueMap;
+	}
+
+	/**
+	 * Instantiate a new Value Object instance.
+	 *
+	 * @param string $valueObject
+	 *
+	 * @return \Analogue\ORM\ValueObject
+	 */
+	public function getValueObjectInstance($valueObject)
+	{
+		$prototype = unserialize(sprintf('O:%d:"%s":0:{}', strlen($valueObject), $valueObject));
+
+		return $prototype;
+	}
+
+	/**
+	 * Register Analogue Plugin.
+	 *
+	 * @param string $plugin class
+	 *
+	 * @return void
+	 */
+	public function registerPlugin($plugin)
+	{
+		/** @var AnaloguePluginInterface $plugin */
+		$plugin = new $plugin($this);
+
+		$this->events = array_merge($this->events, $plugin->getCustomEvents());
+
+		$plugin->register();
+	}
+
+	/**
+	 * Register event listeners that will be fired regardless the type
+	 * of the entity.
+	 *
+	 * @param string   $event
+	 * @param \Closure $callback
+	 *
+	 * @throws \LogicException
+	 *
+	 * @return void
+	 */
+	public function registerGlobalEvent($event, $callback)
+	{
+		if (!in_array($event, $this->events, false)) {
+			throw new \LogicException("Analogue : Event $event doesn't exist");
+		}
+
+		$this->eventDispatcher->listen("analogue.{$event}.*", $callback);
+	}
+
+	/**
+	 * Shortcut to Mapper store.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return mixed
+	 */
+	public function store($entity)
+	{
+		return $this->mapper($entity)->store($entity);
+	}
+
+	/**
+	 * Shortcut to Mapper delete.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return \Illuminate\Support\Collection|null
+	 */
+	public function delete($entity)
+	{
+		return $this->mapper($entity)->delete($entity);
+	}
+
+	/**
+	 * Shortcut to Mapper query.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return Query
+	 */
+	public function query($entity)
+	{
+		return $this->mapper($entity)->query();
+	}
+
+	/**
+	 * Shortcut to Mapper Global Query.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return Query
+	 */
+	public function globalQuery($entity)
+	{
+		return $this->mapper($entity)->globalQuery();
+	}
+
+	/**
+	 * @param array $morphMap
+	 *
+	 * @return $this
+	 */
+	public function morphMap(array $morphMap)
+	{
+		$this->morphMap = $morphMap;
+
+		return $this;
+	}
+
+	/**
+	 * @param string $class
+	 *
+	 * @return mixed
+	 */
+	public function getMorphMap($class)
+	{
+		$key = array_search($class, $this->morphMap, false);
+
+		return $key !== false ? $key : $class;
+	}
 }

src/System/ResultBuilder.php

Doc Comments -1 removed lines

@@ -38,7 +38,6 @@
 
     /**
      * @param Mapper $defaultMapper
-     * @param array  $eagerLoads
      */
     public function __construct(Mapper $defaultMapper)
     {

Indentation +330 added lines, -330 removed lines

@@ -7,334 +7,334 @@
 
 class ResultBuilder
 {
-    /**
-     * The default mapper used to build entities with.
-     *
-     * @var \Analogue\ORM\System\Mapper
-     */
-    protected $defaultMapper;
-
-    /**
-     * Relations that will be eager loaded on this query.
-     *
-     * @var array
-     */
-    protected $eagerLoads;
-
-    /**
-     * The Entity Map for the entity to build.
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * An array of builders used by this class to build necessary
-     * entities for each result type.
-     *
-     * @var array
-     */
-    protected $builders = [];
-
-    /**
-     * @param Mapper $defaultMapper
-     * @param array  $eagerLoads
-     */
-    public function __construct(Mapper $defaultMapper)
-    {
-        $this->defaultMapper = $defaultMapper;
-        $this->entityMap = $defaultMapper->getEntityMap();
-    }
-
-    /**
-     * Convert a result set into an array of entities.
-     *
-     * @param array $results
-     * @param array $eagerLoads name of the relation to be eager loaded on the Entities
-     *
-     * @return \Illuminate\Support\Collection
-     */
-    public function build(array $results, array $eagerLoads)
-    {
-        // First, we'll cast every single result to array
-        $results = array_map(function ($item) {
-            return (array) $item;
-        }, $results);
-
-        // Then, we'll cache every single results as raw attributes, before
-        // adding relationships, which will be cached when the relationship's
-        // query takes place.
-        $this->defaultMapper->getEntityCache()->add($results);
-
-        // Launch the queries related to eager loads, and match the
-        // current result set to these loaded relationships.
-        $results = $this->queryEagerLoadedRelationships($results, $eagerLoads);
-
-        // Note : Maybe we could use a PolymorphicResultBuilder, which would
-        // be shared by both STI and polymorphic relations, as they share the
-        // same process.
-
-        switch ($this->entityMap->getInheritanceType()) {
-            case 'single_table':
-                return $this->buildUsingSingleTableInheritance($results);
-                break;
-
-            default:
-                return $this->buildWithDefaultMapper($results);
-                break;
-        }
-    }
-
-    /**
-     * Launch queries on eager loaded relationships.
-     *
-     * @return array
-     */
-    protected function queryEagerLoadedRelationships(array $results, array $eagerLoads)
-    {
-        $this->eagerLoads = $this->parseRelations($eagerLoads);
-
-        return $this->eagerLoadRelations($results);
-    }
-
-    /**
-     * Parse a list of relations into individuals.
-     *
-     * @param array $relations
-     *
-     * @return array
-     */
-    protected function parseRelations(array $relations)
-    {
-        $results = [];
-
-        foreach ($relations as $name => $constraints) {
-            // If the "relation" value is actually a numeric key, we can assume that no
-            // constraints have been specified for the eager load and we'll just put
-            // an empty Closure with the loader so that we can treat all the same.
-            if (is_numeric($name)) {
-                $f = function () {
-                };
-
-                list($name, $constraints) = [$constraints, $f];
-            }
-
-            // We need to separate out any nested includes. Which allows the developers
-            // to load deep relationships using "dots" without stating each level of
-            // the relationship with its own key in the array of eager load names.
-            $results = $this->parseNested($name, $results);
-
-            $results[$name] = $constraints;
-        }
-
-        return $results;
-    }
-
-    /**
-     * Parse the nested relationships in a relation.
-     *
-     * @param string $name
-     * @param array  $results
-     *
-     * @return array
-     */
-    protected function parseNested($name, $results)
-    {
-        $progress = [];
-
-        // If the relation has already been set on the result array, we will not set it
-        // again, since that would override any constraints that were already placed
-        // on the relationships. We will only set the ones that are not specified.
-        foreach (explode('.', $name) as $segment) {
-            $progress[] = $segment;
-
-            if (!isset($results[$last = implode('.', $progress)])) {
-                $results[$last] = function () {
-                };
-            }
-        }
-
-        return $results;
-    }
-
-    /**
-     * Eager load the relationships on a result set.
-     *
-     * @param array $results
-     *
-     * @return array
-     */
-    public function eagerLoadRelations(array $results)
-    {
-        foreach ($this->eagerLoads as $name => $constraints) {
-
-            // For nested eager loads we'll skip loading them here and they will be set as an
-            // eager load on the query to retrieve the relation so that they will be eager
-            // loaded on that query, because that is where they get hydrated as models.
-            if (strpos($name, '.') === false) {
-                $results = $this->loadRelation($results, $name, $constraints);
-            }
-        }
-
-        return $results;
-    }
-
-    /**
-     * Eagerly load the relationship on a set of entities.
-     *
-     * @param array    $results
-     * @param string   $name
-     * @param \Closure $constraints
-     *
-     * @return array
-     */
-    protected function loadRelation(array $results, $name, Closure $constraints) : array
-    {
-        // First we will "back up" the existing where conditions on the query so we can
-        // add our eager constraints. Then we will merge the wheres that were on the
-        // query back to it in order that any where conditions might be specified.
-        $relation = $this->getRelation($name);
-
-        $relation->addEagerConstraints($results);
-
-        call_user_func($constraints, $relation);
-
-        // Once we have the results, we just match those back up to their parent models
-        // using the relationship instance. Then we just return the finished arrays
-        // of models which have been eagerly hydrated and are readied for return.
-
-        // Same, this step isn't necessary, as we take the inverse approach than Eloquent :
-        // filling the attributes before hydration, for more efficiency
-        //$relationshipResults = $relation->getEager();
-
-        return $relation->match($results, $name);
-    }
-
-    /**
-     * Get the relation instance for the given relation name.
-     *
-     * @param string $relation
-     *
-     * @return \Analogue\ORM\Relationships\Relationship
-     */
-    public function getRelation($relation)
-    {
-        // We want to run a relationship query without any constrains so that we will
-        // not have to remove these where clauses manually which gets really hacky
-        // and is error prone while we remove the developer's own where clauses.
-        $query = Relationship::noConstraints(function () use ($relation) {
-            return $this->entityMap->$relation($this->defaultMapper->newInstance());
-        });
-
-        $nested = $this->nestedRelations($relation);
-
-        // If there are nested relationships set on the query, we will put those onto
-        // the query instances so that they can be handled after this relationship
-        // is loaded. In this way they will all trickle down as they are loaded.
-        if (count($nested) > 0) {
-            $query->getQuery()->with($nested);
-        }
-
-        return $query;
-    }
-
-    /**
-     * Get the deeply nested relations for a given top-level relation.
-     *
-     * @param string $relation
-     *
-     * @return array
-     */
-    protected function nestedRelations($relation)
-    {
-        $nested = [];
-
-        // We are basically looking for any relationships that are nested deeper than
-        // the given top-level relationship. We will just check for any relations
-        // that start with the given top relations and adds them to our arrays.
-        foreach ($this->eagerLoads as $name => $constraints) {
-            if ($this->isNested($name, $relation)) {
-                $nested[substr($name, strlen($relation.'.'))] = $constraints;
-            }
-        }
-
-        return $nested;
-    }
-
-    /**
-     * Determine if the relationship is nested.
-     *
-     * @param string $name
-     * @param string $relation
-     *
-     * @return bool
-     */
-    protected function isNested($name, $relation)
-    {
-        $dots = str_contains($name, '.');
-
-        return $dots && starts_with($name, $relation.'.');
-    }
-
-    /**
-     * Build an entity from results, using the default mapper on this builder.
-     * This is the default build plan when no table inheritance is being used.
-     *
-     * @param array $results
-     *
-     * @return Collection
-     */
-    protected function buildWithDefaultMapper(array $results)
-    {
-        $builder = new EntityBuilder($this->defaultMapper, array_keys($this->eagerLoads));
-
-        return collect($results)->map(function ($item, $key) use ($builder) {
-            return $builder->build($item);
-        })->all();
-    }
-
-    /**
-     * Build an entity from results, using single table inheritance.
-     *
-     * @param array $results
-     *
-     * @return Collection
-     */
-    protected function buildUsingSingleTableInheritance(array $results)
-    {
-        return collect($results)->map(function ($item, $key) {
-            $builder = $this->builderForResult($item);
-
-            return $builder->build($item);
-        })->all();
-    }
-
-    /**
-     * Given a result array, return the entity builder needed to correctly
-     * build the result into an entity. If no getDiscriminatorColumnMap property
-     * has been defined on the EntityMap, we'll assume that the value stored in
-     * the $type column is the fully qualified class name of the entity and
-     * we'll use it instead.
-     *
-     * @param array $result
-     *
-     * @return EntityBuilder
-     */
-    protected function builderForResult(array $result)
-    {
-        $type = $result[$this->entityMap->getDiscriminatorColumn()];
-
-        $columnMap = $this->entityMap->getDiscriminatorColumnMap();
-
-        $class = isset($columnMap[$type]) ? $columnMap[$type] : $type;
-
-        if (!isset($this->builders[$type])) {
-            $this->builders[$type] = new EntityBuilder(
-                Manager::getInstance()->mapper($class),
-                array_keys($this->eagerLoads)
-            );
-        }
-
-        return $this->builders[$type];
-    }
+	/**
+	 * The default mapper used to build entities with.
+	 *
+	 * @var \Analogue\ORM\System\Mapper
+	 */
+	protected $defaultMapper;
+
+	/**
+	 * Relations that will be eager loaded on this query.
+	 *
+	 * @var array
+	 */
+	protected $eagerLoads;
+
+	/**
+	 * The Entity Map for the entity to build.
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * An array of builders used by this class to build necessary
+	 * entities for each result type.
+	 *
+	 * @var array
+	 */
+	protected $builders = [];
+
+	/**
+	 * @param Mapper $defaultMapper
+	 * @param array  $eagerLoads
+	 */
+	public function __construct(Mapper $defaultMapper)
+	{
+		$this->defaultMapper = $defaultMapper;
+		$this->entityMap = $defaultMapper->getEntityMap();
+	}
+
+	/**
+	 * Convert a result set into an array of entities.
+	 *
+	 * @param array $results
+	 * @param array $eagerLoads name of the relation to be eager loaded on the Entities
+	 *
+	 * @return \Illuminate\Support\Collection
+	 */
+	public function build(array $results, array $eagerLoads)
+	{
+		// First, we'll cast every single result to array
+		$results = array_map(function ($item) {
+			return (array) $item;
+		}, $results);
+
+		// Then, we'll cache every single results as raw attributes, before
+		// adding relationships, which will be cached when the relationship's
+		// query takes place.
+		$this->defaultMapper->getEntityCache()->add($results);
+
+		// Launch the queries related to eager loads, and match the
+		// current result set to these loaded relationships.
+		$results = $this->queryEagerLoadedRelationships($results, $eagerLoads);
+
+		// Note : Maybe we could use a PolymorphicResultBuilder, which would
+		// be shared by both STI and polymorphic relations, as they share the
+		// same process.
+
+		switch ($this->entityMap->getInheritanceType()) {
+			case 'single_table':
+				return $this->buildUsingSingleTableInheritance($results);
+				break;
+
+			default:
+				return $this->buildWithDefaultMapper($results);
+				break;
+		}
+	}
+
+	/**
+	 * Launch queries on eager loaded relationships.
+	 *
+	 * @return array
+	 */
+	protected function queryEagerLoadedRelationships(array $results, array $eagerLoads)
+	{
+		$this->eagerLoads = $this->parseRelations($eagerLoads);
+
+		return $this->eagerLoadRelations($results);
+	}
+
+	/**
+	 * Parse a list of relations into individuals.
+	 *
+	 * @param array $relations
+	 *
+	 * @return array
+	 */
+	protected function parseRelations(array $relations)
+	{
+		$results = [];
+
+		foreach ($relations as $name => $constraints) {
+			// If the "relation" value is actually a numeric key, we can assume that no
+			// constraints have been specified for the eager load and we'll just put
+			// an empty Closure with the loader so that we can treat all the same.
+			if (is_numeric($name)) {
+				$f = function () {
+				};
+
+				list($name, $constraints) = [$constraints, $f];
+			}
+
+			// We need to separate out any nested includes. Which allows the developers
+			// to load deep relationships using "dots" without stating each level of
+			// the relationship with its own key in the array of eager load names.
+			$results = $this->parseNested($name, $results);
+
+			$results[$name] = $constraints;
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Parse the nested relationships in a relation.
+	 *
+	 * @param string $name
+	 * @param array  $results
+	 *
+	 * @return array
+	 */
+	protected function parseNested($name, $results)
+	{
+		$progress = [];
+
+		// If the relation has already been set on the result array, we will not set it
+		// again, since that would override any constraints that were already placed
+		// on the relationships. We will only set the ones that are not specified.
+		foreach (explode('.', $name) as $segment) {
+			$progress[] = $segment;
+
+			if (!isset($results[$last = implode('.', $progress)])) {
+				$results[$last] = function () {
+				};
+			}
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Eager load the relationships on a result set.
+	 *
+	 * @param array $results
+	 *
+	 * @return array
+	 */
+	public function eagerLoadRelations(array $results)
+	{
+		foreach ($this->eagerLoads as $name => $constraints) {
+
+			// For nested eager loads we'll skip loading them here and they will be set as an
+			// eager load on the query to retrieve the relation so that they will be eager
+			// loaded on that query, because that is where they get hydrated as models.
+			if (strpos($name, '.') === false) {
+				$results = $this->loadRelation($results, $name, $constraints);
+			}
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Eagerly load the relationship on a set of entities.
+	 *
+	 * @param array    $results
+	 * @param string   $name
+	 * @param \Closure $constraints
+	 *
+	 * @return array
+	 */
+	protected function loadRelation(array $results, $name, Closure $constraints) : array
+	{
+		// First we will "back up" the existing where conditions on the query so we can
+		// add our eager constraints. Then we will merge the wheres that were on the
+		// query back to it in order that any where conditions might be specified.
+		$relation = $this->getRelation($name);
+
+		$relation->addEagerConstraints($results);
+
+		call_user_func($constraints, $relation);
+
+		// Once we have the results, we just match those back up to their parent models
+		// using the relationship instance. Then we just return the finished arrays
+		// of models which have been eagerly hydrated and are readied for return.
+
+		// Same, this step isn't necessary, as we take the inverse approach than Eloquent :
+		// filling the attributes before hydration, for more efficiency
+		//$relationshipResults = $relation->getEager();
+
+		return $relation->match($results, $name);
+	}
+
+	/**
+	 * Get the relation instance for the given relation name.
+	 *
+	 * @param string $relation
+	 *
+	 * @return \Analogue\ORM\Relationships\Relationship
+	 */
+	public function getRelation($relation)
+	{
+		// We want to run a relationship query without any constrains so that we will
+		// not have to remove these where clauses manually which gets really hacky
+		// and is error prone while we remove the developer's own where clauses.
+		$query = Relationship::noConstraints(function () use ($relation) {
+			return $this->entityMap->$relation($this->defaultMapper->newInstance());
+		});
+
+		$nested = $this->nestedRelations($relation);
+
+		// If there are nested relationships set on the query, we will put those onto
+		// the query instances so that they can be handled after this relationship
+		// is loaded. In this way they will all trickle down as they are loaded.
+		if (count($nested) > 0) {
+			$query->getQuery()->with($nested);
+		}
+
+		return $query;
+	}
+
+	/**
+	 * Get the deeply nested relations for a given top-level relation.
+	 *
+	 * @param string $relation
+	 *
+	 * @return array
+	 */
+	protected function nestedRelations($relation)
+	{
+		$nested = [];
+
+		// We are basically looking for any relationships that are nested deeper than
+		// the given top-level relationship. We will just check for any relations
+		// that start with the given top relations and adds them to our arrays.
+		foreach ($this->eagerLoads as $name => $constraints) {
+			if ($this->isNested($name, $relation)) {
+				$nested[substr($name, strlen($relation.'.'))] = $constraints;
+			}
+		}
+
+		return $nested;
+	}
+
+	/**
+	 * Determine if the relationship is nested.
+	 *
+	 * @param string $name
+	 * @param string $relation
+	 *
+	 * @return bool
+	 */
+	protected function isNested($name, $relation)
+	{
+		$dots = str_contains($name, '.');
+
+		return $dots && starts_with($name, $relation.'.');
+	}
+
+	/**
+	 * Build an entity from results, using the default mapper on this builder.
+	 * This is the default build plan when no table inheritance is being used.
+	 *
+	 * @param array $results
+	 *
+	 * @return Collection
+	 */
+	protected function buildWithDefaultMapper(array $results)
+	{
+		$builder = new EntityBuilder($this->defaultMapper, array_keys($this->eagerLoads));
+
+		return collect($results)->map(function ($item, $key) use ($builder) {
+			return $builder->build($item);
+		})->all();
+	}
+
+	/**
+	 * Build an entity from results, using single table inheritance.
+	 *
+	 * @param array $results
+	 *
+	 * @return Collection
+	 */
+	protected function buildUsingSingleTableInheritance(array $results)
+	{
+		return collect($results)->map(function ($item, $key) {
+			$builder = $this->builderForResult($item);
+
+			return $builder->build($item);
+		})->all();
+	}
+
+	/**
+	 * Given a result array, return the entity builder needed to correctly
+	 * build the result into an entity. If no getDiscriminatorColumnMap property
+	 * has been defined on the EntityMap, we'll assume that the value stored in
+	 * the $type column is the fully qualified class name of the entity and
+	 * we'll use it instead.
+	 *
+	 * @param array $result
+	 *
+	 * @return EntityBuilder
+	 */
+	protected function builderForResult(array $result)
+	{
+		$type = $result[$this->entityMap->getDiscriminatorColumn()];
+
+		$columnMap = $this->entityMap->getDiscriminatorColumnMap();
+
+		$class = isset($columnMap[$type]) ? $columnMap[$type] : $type;
+
+		if (!isset($this->builders[$type])) {
+			$this->builders[$type] = new EntityBuilder(
+				Manager::getInstance()->mapper($class),
+				array_keys($this->eagerLoads)
+			);
+		}
+
+		return $this->builders[$type];
+	}
 }

Spacing +6 added lines, -6 removed lines

@@ -57,7 +57,7 @@ 
     public function build(array $results, array $eagerLoads)
     {
         // First, we'll cast every single result to array
-        $results = array_map(function ($item) {
+        $results = array_map(function($item) {
             return (array) $item;
         }, $results);
 
@@ -113,7 +113,7 @@ 
             // constraints have been specified for the eager load and we'll just put
             // an empty Closure with the loader so that we can treat all the same.
             if (is_numeric($name)) {
-                $f = function () {
+                $f = function() {
                 };
 
                 list($name, $constraints) = [$constraints, $f];
@@ -149,7 +149,7 @@ 
             $progress[] = $segment;
 
             if (!isset($results[$last = implode('.', $progress)])) {
-                $results[$last] = function () {
+                $results[$last] = function() {
                 };
             }
         }
@@ -222,7 +222,7 @@ 
         // We want to run a relationship query without any constrains so that we will
         // not have to remove these where clauses manually which gets really hacky
         // and is error prone while we remove the developer's own where clauses.
-        $query = Relationship::noConstraints(function () use ($relation) {
+        $query = Relationship::noConstraints(function() use ($relation) {
             return $this->entityMap->$relation($this->defaultMapper->newInstance());
         });
 
@@ -288,7 +288,7 @@ 
     {
         $builder = new EntityBuilder($this->defaultMapper, array_keys($this->eagerLoads));
 
-        return collect($results)->map(function ($item, $key) use ($builder) {
+        return collect($results)->map(function($item, $key) use ($builder) {
             return $builder->build($item);
         })->all();
     }
@@ -302,7 +302,7 @@ 
      */
     protected function buildUsingSingleTableInheritance(array $results)
     {
-        return collect($results)->map(function ($item, $key) {
+        return collect($results)->map(function($item, $key) {
             $builder = $this->builderForResult($item);
 
             return $builder->build($item);

src/System/SingleTableInheritanceScope.php

Doc Comments +1 added lines, -1 removed lines

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

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;
+	}
 }

src/System/Wrappers/ObjectWrapper.php

Doc Comments -1 removed lines

@@ -35,7 +35,6 @@
     /**
      * Object Wrapper constructor.
      *
-     * @param mixed                  $object
      * @param Analogue\ORM\EntityMap $entityMap
      *
      * @return void

Indentation +221 added lines, -221 removed lines

@@ -10,225 +10,225 @@
  */
 class ObjectWrapper extends Wrapper
 {
-    /**
-     * Internal Representation of analogue's entity attributes.
-     *
-     * @var array
-     */
-    protected $attributes = [];
-
-    /**
-     * Object properties that are not a part of the entity attributes,
-     * but which are needed to correctly hydrate the Object.
-     *
-     * @var array
-     */
-    protected $unmanagedProperties = [];
-
-    /**
-     * The hydrator for the wrapped object.
-     *
-     * @var HydratorInterface
-     */
-    protected $hydrator;
-
-    /**
-     * Object Wrapper constructor.
-     *
-     * @param mixed                  $object
-     * @param Analogue\ORM\EntityMap $entityMap
-     *
-     * @return void
-     */
-    public function __construct($entity, $entityMap, HydratorInterface $hydrator)
-    {
-        $this->hydrator = $hydrator;
-        parent::__construct($entity, $entityMap);
-        $this->attributes = $this->dehydrate($entity);
-    }
-
-    /**
-     * Returns the wrapped entity.
-     *
-     * @return mixed
-     */
-    public function getObject()
-    {
-        $this->hydrate();
-
-        return $this->entity;
-    }
-
-    /**
-     * Extract entity attributes / properties to an array of attributes.
-     *
-     * @param mixed $entity
-     *
-     * @return array
-     */
-    protected function dehydrate($entity) : array
-    {
-        $properties = $this->hydrator->extract($entity);
-
-        $this->unmanagedProperties = array_except($properties, $this->getManagedProperties());
-
-        return $this->attributesFromProperties($properties);
-    }
-
-    /**
-     * Hydrate object's properties/attribute from the internal array representation.
-     *
-     * @return mixed
-     */
-    public function hydrate()
-    {
-        $properties = $this->propertiesFromAttributes($this->attributes) + $this->unmanagedProperties;
-        $this->hydrator->hydrate($properties, $this->entity);
-    }
-
-    /**
-     * Return properties that will be extracted from the entity.
-     *
-     * @return array
-     */
-    protected function getManagedProperties() : array
-    {
-        $properties = $this->entityMap->getProperties();
-
-        $attributesName = $this->entityMap->getAttributesArrayName();
-
-        return $attributesName == null ? $properties : array_merge($properties, [$attributesName]);
-    }
-
-    /**
-     * Convert object's properties to analogue's internal attributes representation.
-     *
-     * @param array $properties
-     *
-     * @return array
-     */
-    protected function attributesFromProperties(array $properties) : array
-    {
-        // First, we'll only keep the entities that are part of the Entity's
-        // attributes
-        $managedProperties = $this->getManagedProperties();
-
-        $properties = array_only($properties, $managedProperties);
-
-        // If the entity does not uses the attributes array to store
-        // part of its attributes, we'll directly return the properties
-        if (!$this->entityMap->usesAttributesArray()) {
-            return $properties;
-        }
-
-        $arrayName = $this->entityMap->getAttributesArrayName();
-
-        if (!array_key_exists($arrayName, $properties)) {
-            throw new MappingException("Property $arrayName not set on object of type ".$this->getEntityClass());
-        }
-
-        if (!is_array($properties[$arrayName])) {
-            throw new MappingException("Property $arrayName should be an array.");
-        }
-
-        $attributes = $properties[$arrayName];
-
-        unset($properties[$arrayName]);
-
-        return $properties + $attributes;
-    }
-
-    /**
-     * Convert internal representation of attributes to an array of properties
-     * that can hydrate the actual object.
-     *
-     * @param array $attributes
-     *
-     * @return array
-     */
-    protected function propertiesFromAttributes(array $attributes) : array
-    {
-        $attributes = $this->attributes;
-
-        // Get all managed properties
-        $propertyNames = $this->entityMap->getProperties();
-
-        $propertyAttributes = array_only($attributes, $propertyNames);
-        $attributesArray = array_except($attributes, $propertyNames);
-
-        $attributesArrayName = $this->entityMap->getAttributesArrayName();
-
-        if ($attributesArrayName) {
-            $propertyAttributes[$attributesArrayName] = $attributesArray;
-        }
-
-        return $propertyAttributes;
-    }
-
-    /**
-     * 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() : array
-    {
-        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 get single
-     * key-value pair.
-     *
-     * @param string $key
-     *
-     * @return mixed|null
-     */
-    public function getEntityAttribute($key)
-    {
-        if ($this->hasAttribute($key)) {
-            return $this->attributes[$key];
-        } else {
-            return;
-        }
-    }
-
-    /**
-     * Test if a given attribute exists.
-     *
-     * @param string $key
-     *
-     * @return bool
-     */
-    public function hasAttribute($key) : bool
-    {
-        return array_key_exists($key, $this->attributes) ? true : false;
-    }
+	/**
+	 * Internal Representation of analogue's entity attributes.
+	 *
+	 * @var array
+	 */
+	protected $attributes = [];
+
+	/**
+	 * Object properties that are not a part of the entity attributes,
+	 * but which are needed to correctly hydrate the Object.
+	 *
+	 * @var array
+	 */
+	protected $unmanagedProperties = [];
+
+	/**
+	 * The hydrator for the wrapped object.
+	 *
+	 * @var HydratorInterface
+	 */
+	protected $hydrator;
+
+	/**
+	 * Object Wrapper constructor.
+	 *
+	 * @param mixed                  $object
+	 * @param Analogue\ORM\EntityMap $entityMap
+	 *
+	 * @return void
+	 */
+	public function __construct($entity, $entityMap, HydratorInterface $hydrator)
+	{
+		$this->hydrator = $hydrator;
+		parent::__construct($entity, $entityMap);
+		$this->attributes = $this->dehydrate($entity);
+	}
+
+	/**
+	 * Returns the wrapped entity.
+	 *
+	 * @return mixed
+	 */
+	public function getObject()
+	{
+		$this->hydrate();
+
+		return $this->entity;
+	}
+
+	/**
+	 * Extract entity attributes / properties to an array of attributes.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @return array
+	 */
+	protected function dehydrate($entity) : array
+	{
+		$properties = $this->hydrator->extract($entity);
+
+		$this->unmanagedProperties = array_except($properties, $this->getManagedProperties());
+
+		return $this->attributesFromProperties($properties);
+	}
+
+	/**
+	 * Hydrate object's properties/attribute from the internal array representation.
+	 *
+	 * @return mixed
+	 */
+	public function hydrate()
+	{
+		$properties = $this->propertiesFromAttributes($this->attributes) + $this->unmanagedProperties;
+		$this->hydrator->hydrate($properties, $this->entity);
+	}
+
+	/**
+	 * Return properties that will be extracted from the entity.
+	 *
+	 * @return array
+	 */
+	protected function getManagedProperties() : array
+	{
+		$properties = $this->entityMap->getProperties();
+
+		$attributesName = $this->entityMap->getAttributesArrayName();
+
+		return $attributesName == null ? $properties : array_merge($properties, [$attributesName]);
+	}
+
+	/**
+	 * Convert object's properties to analogue's internal attributes representation.
+	 *
+	 * @param array $properties
+	 *
+	 * @return array
+	 */
+	protected function attributesFromProperties(array $properties) : array
+	{
+		// First, we'll only keep the entities that are part of the Entity's
+		// attributes
+		$managedProperties = $this->getManagedProperties();
+
+		$properties = array_only($properties, $managedProperties);
+
+		// If the entity does not uses the attributes array to store
+		// part of its attributes, we'll directly return the properties
+		if (!$this->entityMap->usesAttributesArray()) {
+			return $properties;
+		}
+
+		$arrayName = $this->entityMap->getAttributesArrayName();
+
+		if (!array_key_exists($arrayName, $properties)) {
+			throw new MappingException("Property $arrayName not set on object of type ".$this->getEntityClass());
+		}
+
+		if (!is_array($properties[$arrayName])) {
+			throw new MappingException("Property $arrayName should be an array.");
+		}
+
+		$attributes = $properties[$arrayName];
+
+		unset($properties[$arrayName]);
+
+		return $properties + $attributes;
+	}
+
+	/**
+	 * Convert internal representation of attributes to an array of properties
+	 * that can hydrate the actual object.
+	 *
+	 * @param array $attributes
+	 *
+	 * @return array
+	 */
+	protected function propertiesFromAttributes(array $attributes) : array
+	{
+		$attributes = $this->attributes;
+
+		// Get all managed properties
+		$propertyNames = $this->entityMap->getProperties();
+
+		$propertyAttributes = array_only($attributes, $propertyNames);
+		$attributesArray = array_except($attributes, $propertyNames);
+
+		$attributesArrayName = $this->entityMap->getAttributesArrayName();
+
+		if ($attributesArrayName) {
+			$propertyAttributes[$attributesArrayName] = $attributesArray;
+		}
+
+		return $propertyAttributes;
+	}
+
+	/**
+	 * 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() : array
+	{
+		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 get single
+	 * key-value pair.
+	 *
+	 * @param string $key
+	 *
+	 * @return mixed|null
+	 */
+	public function getEntityAttribute($key)
+	{
+		if ($this->hasAttribute($key)) {
+			return $this->attributes[$key];
+		} else {
+			return;
+		}
+	}
+
+	/**
+	 * Test if a given attribute exists.
+	 *
+	 * @param string $key
+	 *
+	 * @return bool
+	 */
+	public function hasAttribute($key) : bool
+	{
+		return array_key_exists($key, $this->attributes) ? true : false;
+	}
 }