analogueorm / analogue

src/System/EntityCache.php

Doc Comments +2 added lines, -2 removed lines

@@ -198,7 +198,7 @@ 
     /**
      * Cache a many relationship.
      *
-     * @param                  $parentKey
+     * @param                  string $parentKey
      * @param string           $relation
      * @param EntityCollection $results
      * @param Relationship     $relationship
@@ -221,7 +221,7 @@ 
     /**
      * Cache a single relationship.
      *
-     * @param              $parentKey
+     * @param              string $parentKey
      * @param string       $relation
      * @param Mappable     $result
      * @param Relationship $relationship

Indentation +338 added lines, -338 removed lines

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

src/System/Proxies/CollectionProxy.php

Doc Comments +1 added lines, -3 removed lines

@@ -217,10 +217,8 @@
     /**
      * Create a new collection consisting of every n-th element.
      *
-     * @param int $step
-     * @param int $offset
      *
-     * @return static
+     * @return boolean
      */
     public function every($key, $operator = null, $value = null)
     {

Indentation +1282 added lines, -1282 removed lines

@@ -9,1286 +9,1286 @@
 
 class CollectionProxy extends EntityCollection implements ProxyInterface
 {
-    /**
-     * Indicate if the relationship has been lazy loaded.
-     *
-     * @var bool
-     */
-    protected $relationshipLoaded = false;
-
-    protected $addedItems = [];
-
-    /**
-     * Create a new collection.
-     *
-     * @param mixed  $entity
-     * @param string $relation
-     *
-     * @return void
-     */
-    public function __construct($entity, $relation)
-    {
-        $this->parentEntity = $entity;
-        $this->relationshipMethod = $relation;
-    }
-
-    /**
-     * Return Items that has been added without lady loading
-     * the underlying collection.
-     *
-     * @return array
-     */
-    public function getAddedItems()
-    {
-        return $this->addedItems;
-    }
-
-    /**
-     * Force initialization of the proxy.
-     *
-     * @return bool true if the proxy could be initialized
-     */
-    public function initializeProxy() : bool
-    {
-        if ($this->isProxyInitialized()) {
-            return true;
-        }
-
-        $relation = $this->relationshipMethod;
-        $entity = $this->parentEntity;
-
-        $entityMap = Manager::getMapper($entity)->getEntityMap();
-
-        $this->items = $entityMap->$relation($entity)->getResults($relation)->all() + $this->addedItems;
-
-        $this->relationshipLoaded = true;
-
-        return true;
-    }
-
-    /**
-     * Retrieves current initialization status of the proxy.
-     *
-     * @return bool
-     */
-    public function isProxyInitialized() : bool
-    {
-        return $this->relationshipLoaded;
-    }
-
-    /**
-     * Get all of the items in the collection.
-     *
-     * @return array
-     */
-    public function all()
-    {
-        $this->initializeProxy();
-
-        return parent::all();
-    }
-
-    /**
-     * Get the average value of a given key.
-     *
-     * @param callable|string|null $callback
-     *
-     * @return mixed
-     */
-    public function avg($callback = null)
-    {
-        $this->initializeProxy();
-
-        return parent::avg($callback);
-    }
-
-    /**
-     * Get the median of a given key.
-     *
-     * @param null $key
-     *
-     * @return mixed|null
-     */
-    public function median($key = null)
-    {
-        $this->initializeProxy();
-
-        return parent::median($key);
-    }
-
-    /**
-     * Get the mode of a given key.
-     *
-     * @param mixed $key
-     *
-     * @return array
-     */
-    public function mode($key = null)
-    {
-        $this->initializeProxy();
-
-        return parent::mode($key);
-    }
-
-    /**
-     * Collapse the collection of items into a single array.
-     *
-     * @return static
-     */
-    public function collapse()
-    {
-        $this->initializeProxy();
-
-        return parent::collapse();
-    }
-
-    /**
-     * Determine if an item exists in the collection.
-     *
-     * @param mixed $key
-     * @param mixed $value
-     *
-     * @return bool
-     */
-    public function contains($key, $operator = null, $value = null)
-    {
-        $this->initializeProxy();
-
-        return parent::contains($key, $operator, $value);
-    }
-
-    /**
-     * Determine if an item exists in the collection using strict comparison.
-     *
-     * @param mixed $key
-     * @param mixed $value
-     *
-     * @return bool
-     */
-    public function containsStrict($key, $value = null)
-    {
-        $this->initializeProxy();
-
-        return parent::containsStrict($key, $value);
-    }
-
-    /**
-     * Get the items in the collection that are not present in the given items.
-     *
-     * @param mixed $items
-     *
-     * @return static
-     */
-    public function diff($items)
-    {
-        $this->initializeProxy();
-
-        return parent::diff($items);
-    }
-
-    /**
-     * Get the items in the collection whose keys are not present in the given items.
-     *
-     * @param mixed $items
-     *
-     * @return static
-     */
-    public function diffKeys($items)
-    {
-        $this->initializeProxy();
-
-        return parent::diffKeys($items);
-    }
-
-    /**
-     * Execute a callback over each item.
-     *
-     * @param callable $callback
-     *
-     * @return $this
-     */
-    public function each(callable $callback)
-    {
-        $this->initializeProxy();
-
-        return parent::each($callback);
-    }
-
-    /**
-     * Create a new collection consisting of every n-th element.
-     *
-     * @param int $step
-     * @param int $offset
-     *
-     * @return static
-     */
-    public function every($key, $operator = null, $value = null)
-    {
-        $this->initializeProxy();
-
-        return parent::every($key, $operator, $value);
-    }
-
-    /**
-     * Get all items except for those with the specified keys.
-     *
-     * @param mixed $keys
-     *
-     * @return static
-     */
-    public function except($keys)
-    {
-        $this->initializeProxy();
-
-        return parent::except($keys);
-    }
-
-    /**
-     * Run a filter over each of the items.
-     *
-     * @param callable|null $callback
-     *
-     * @return static
-     */
-    public function filter(callable $callback = null)
-    {
-        $this->initializeProxy();
-
-        return parent::filter($callback);
-    }
-
-    /**
-     * Filter items by the given key value pair.
-     *
-     * @param string $key
-     * @param mixed  $operator
-     * @param mixed  $value
-     *
-     * @return static
-     */
-    public function where($key, $operator, $value = null)
-    {
-        $this->initializeProxy();
-
-        return parent::where($key, $operator, $value);
-    }
-
-    /**
-     * Filter items by the given key value pair using strict comparison.
-     *
-     * @param string $key
-     * @param mixed  $value
-     *
-     * @return static
-     */
-    public function whereStrict($key, $value)
-    {
-        $this->initializeProxy();
-
-        return parent::whereStrict($key, $value);
-    }
-
-    /**
-     * Filter items by the given key value pair.
-     *
-     * @param string $key
-     * @param mixed  $values
-     * @param bool   $strict
-     *
-     * @return static
-     */
-    public function whereIn($key, $values, $strict = false)
-    {
-        $this->initializeProxy();
-
-        return parent::whereIn($key, $values, $strict);
-    }
-
-    /**
-     * Filter items by the given key value pair using strict comparison.
-     *
-     * @param string $key
-     * @param mixed  $values
-     *
-     * @return static
-     */
-    public function whereInStrict($key, $values)
-    {
-        $this->initializeProxy();
-
-        return parent::whereInStrict($key, $values);
-    }
-
-    /**
-     * Get the first item from the collection.
-     *
-     * @param callable|null $callback
-     * @param mixed         $default
-     *
-     * @return mixed
-     */
-    public function first(callable $callback = null, $default = null)
-    {
-        // TODO Consider partial loading
-        $this->initializeProxy();
-
-        return parent::first($callback, $default);
-    }
-
-    /**
-     * Get a flattened array of the items in the collection.
-     *
-     * @param int $depth
-     *
-     * @return static
-     */
-    public function flatten($depth = INF)
-    {
-        $this->initializeProxy();
-
-        return parent::flatten($depth);
-    }
-
-    /**
-     * Flip the items in the collection.
-     *
-     * @return static
-     */
-    public function flip()
-    {
-        $this->initializeProxy();
-
-        return parent::flip();
-    }
-
-    /**
-     * Remove an item from the collection by key.
-     *
-     * @param string|array $keys
-     *
-     * @return $this
-     */
-    public function forget($keys)
-    {
-        // TODO, we could consider these as
-        // 'pending deletion', the same way that
-        // we treat added items
-        $this->initializeProxy();
-
-        return parent::forget($keys);
-    }
-
-    /**
-     * Get an item from the collection by key.
-     *
-     * @param mixed $key
-     * @param mixed $default
-     *
-     * @return mixed
-     */
-    public function get($key, $default = null)
-    {
-        // TODO : We could also consider partial loading
-        // here
-        $this->initializeProxy();
-
-        return parent::get($key, $default);
-    }
-
-    /**
-     * Group an associative array by a field or using a callback.
-     *
-     * @param callable|string $groupBy
-     * @param bool            $preserveKeys
-     *
-     * @return static
-     */
-    public function groupBy($groupBy, $preserveKeys = false)
-    {
-        $this->initializeProxy();
-
-        return parent::groupBy($groupBy, $preserveKeys);
-    }
-
-    /**
-     * Key an associative array by a field or using a callback.
-     *
-     * @param callable|string $keyBy
-     *
-     * @return static
-     */
-    public function keyBy($keyBy)
-    {
-        $this->initializeProxy();
-
-        return parent::keyBy($keyBy);
-    }
-
-    /**
-     * Determine if an item exists in the collection by key.
-     *
-     * @param mixed $key
-     *
-     * @return bool
-     */
-    public function has($key)
-    {
-        // TODO : we could do automagic here by directly
-        // calling the database if the collection hasn't
-        // been initialized yet.
-        // Potential issue is that several calls to this
-        // could cause a lot queries vs a single get query.
-        $this->initializeProxy();
-
-        return parent::has($key);
-    }
-
-    /**
-     * Concatenate values of a given key as a string.
-     *
-     * @param string $value
-     * @param string $glue
-     *
-     * @return string
-     */
-    public function implode($value, $glue = null)
-    {
-        $this->initializeProxy();
-
-        return parent::implode($value, $glue);
-    }
-
-    /**
-     * Intersect the collection with the given items.
-     *
-     * @param mixed $items
-     *
-     * @return static
-     */
-    public function intersect($items)
-    {
-        $this->initializeProxy();
-
-        return parent::intersect($items);
-    }
-
-    /**
-     * Determine if the collection is empty or not.
-     *
-     * @return bool
-     */
-    public function isEmpty()
-    {
-        $this->initializeProxy();
-
-        return parent::isEmpty();
-    }
-
-    /**
-     * Get the keys of the collection items.
-     *
-     * @return static
-     */
-    public function keys()
-    {
-        $this->initializeProxy();
-
-        return parent::keys();
-    }
-
-    /**
-     * Get the last item from the collection.
-     *
-     * @param callable|null $callback
-     * @param mixed         $default
-     *
-     * @return mixed
-     */
-    public function last(callable $callback = null, $default = null)
-    {
-        // TODO : we could do partial loading there as well
-        $this->initializeProxy();
-
-        return parent::last($callback, $default);
-    }
-
-    /**
-     * Get the values of a given key.
-     *
-     * @param string      $value
-     * @param string|null $key
-     *
-     * @return static
-     */
-    public function pluck($value, $key = null)
-    {
-        // TODO : automagic call to QB if not initialized
-        $this->initializeProxy();
-
-        return parent::pluck($value, $key);
-    }
-
-    /**
-     * Run a map over each of the items.
-     *
-     * @param callable $callback
-     *
-     * @return static
-     */
-    public function map(callable $callback)
-    {
-        $this->initializeProxy();
-
-        return parent::map($callback);
-    }
-
-    /**
-     * Run an associative map over each of the items.
-     *
-     * The callback should return an associative array with a single key/value pair.
-     *
-     * @param callable $callback
-     *
-     * @return static
-     */
-    public function mapWithKeys(callable $callback)
-    {
-        $this->initializeProxy();
-
-        return parent::mapWithKeys($callback);
-    }
-
-    /**
-     * Map a collection and flatten the result by a single level.
-     *
-     * @param callable $callback
-     *
-     * @return static
-     */
-    public function flatMap(callable $callback)
-    {
-        $this->initializeProxy();
-
-        return parent::flatMap($callback);
-    }
-
-    /**
-     * Get the max value of a given key.
-     *
-     * @param callable|string|null $callback
-     *
-     * @return mixed
-     */
-    public function max($callback = null)
-    {
-        $this->initializeProxy();
-
-        return parent::max($callback);
-    }
-
-    /**
-     * Merge the collection with the given items.
-     *
-     * @param mixed $items
-     *
-     * @return static
-     */
-    public function merge($items)
-    {
-        // TODO : Check if the EntityCollection
-        // returns a native Collection, as it
-        // is what we want here
-        $this->initializeProxy();
-
-        return parent::merge($items);
-    }
-
-    /**
-     * Create a collection by using this collection for keys and another for its values.
-     *
-     * @param mixed $values
-     *
-     * @return static
-     */
-    public function combine($values)
-    {
-        // TODO : Check if the EntityCollection
-        // returns a native Collection, as it
-        // is what we want here
-        $this->initializeProxy();
-
-        return parent::combine($values);
-    }
-
-    /**
-     * Union the collection with the given items.
-     *
-     * @param mixed $items
-     *
-     * @return static
-     */
-    public function union($items)
-    {
-        // TODO : Check if the EntityCollection
-        // returns a native Collection, as it
-        // is what we want here
-        $this->initializeProxy();
-
-        return parent::union($items);
-    }
-
-    /**
-     * Get the min value of a given key.
-     *
-     * @param callable|string|null $callback
-     *
-     * @return mixed
-     */
-    public function min($callback = null)
-    {
-        // TODO : we could rely on the QB
-        // for thos, if initialization has not
-        // take place yet
-        $this->initializeProxy();
-
-        return parent::min($callback);
-    }
-
-    /**
-     * Create a new collection consisting of every n-th element.
-     *
-     * @param int $step
-     * @param int $offset
-     *
-     * @return static
-     */
-    public function nth($step, $offset = 0)
-    {
-        $this->initializeProxy();
-
-        return parent::nth($step, $offset);
-    }
-
-    /**
-     * Get the items with the specified keys.
-     *
-     * @param mixed $keys
-     *
-     * @return static
-     */
-    public function only($keys)
-    {
-        // TODO : we could rely on the QB if
-        // the collection hasn't been initialized yet
-        $this->initializeProxy();
-
-        return parent::only($keys);
-    }
-
-    /**
-     * "Paginate" the collection by slicing it into a smaller collection.
-     *
-     * @param int $page
-     * @param int $perPage
-     *
-     * @return static
-     */
-    public function forPage($page, $perPage)
-    {
-        // TODO : check possibility of partial loading
-        // if not initialized
-        $this->initializeProxy();
-
-        return parent::forPage($page, $perPage);
-    }
-
-    /**
-     * Partition the collection into two arrays using the given callback or key.
-     *
-     * @param callable|string $callback
-     *
-     * @return static
-     */
-    public function partition($callback)
-    {
-        $this->initializeProxy();
-
-        return parent::partition($callback);
-    }
-
-    /**
-     * Pass the collection to the given callback and return the result.
-     *
-     * @param callable $callback
-     *
-     * @return mixed
-     */
-    public function pipe(callable $callback)
-    {
-        $this->initializeProxy();
-
-        return parent::pipe($callback);
-    }
-
-    /**
-     * Get and remove the last item from the collection.
-     *
-     * @return mixed
-     */
-    public function pop()
-    {
-        $this->initializeProxy();
-
-        return parent::pop();
-    }
-
-    /**
-     * Push an item onto the beginning of the collection.
-     *
-     * @param mixed $value
-     * @param mixed $key
-     *
-     * @return $this
-     */
-    public function prepend($value, $key = null)
-    {
-        // TODO : partial adding of values.
-        // we could have a $prepended , and $pushed arrays
-        // which we would combine at full initialization
-
-        $this->initializeProxy();
-
-        return parent::prepend($value, $key);
-    }
-
-    /**
-     * Push an item onto the end of the collection.
-     *
-     * @param mixed $value
-     *
-     * @return $this
-     */
-    public function push($value)
-    {
-        // TODO : partial adding of values.
-        // we could have a $prepended , and $pushed arrays
-        // which we would combine at full initialization
-
-        $this->initializeProxy();
-
-        return parent::push($value);
-    }
-
-    /**
-     * Get and remove an item from the collection.
-     *
-     * @param mixed $key
-     * @param mixed $default
-     *
-     * @return mixed
-     */
-    public function pull($key, $default = null)
-    {
-        // TODO : QB query if the collection
-        // hasn't been initialized yet
-
-        $this->initializeProxy();
-
-        return parent::pull($key, $default);
-    }
-
-    /**
-     * Put an item in the collection by key.
-     *
-     * @param mixed $key
-     * @param mixed $value
-     *
-     * @return $this
-     */
-    public function put($key, $value)
-    {
-        // TODO : Partial loading ?
-
-        $this->initializeProxy();
-
-        return parent::put($key, $value);
-    }
-
-    /**
-     * Get one or more items randomly from the collection.
-     *
-     * @param int $amount
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return mixed
-     */
-    public function random($amount = 1)
-    {
-        // TODO : we could optimize this by only
-        // fetching the keys from the database
-        // and performing partial loading
-
-        $this->initializeProxy();
-
-        return parent::random($amount);
-    }
-
-    /**
-     * Reduce the collection to a single value.
-     *
-     * @param callable $callback
-     * @param mixed    $initial
-     *
-     * @return mixed
-     */
-    public function reduce(callable $callback, $initial = null)
-    {
-        $this->initializeProxy();
-
-        return parent::reduce($callback, $initial);
-    }
-
-    /**
-     * Create a collection of all elements that do not pass a given truth test.
-     *
-     * @param callable|mixed $callback
-     *
-     * @return static
-     */
-    public function reject($callback)
-    {
-        $this->initializeProxy();
-
-        return parent::reject($callback);
-    }
-
-    /**
-     * Reverse items order.
-     *
-     * @return static
-     */
-    public function reverse()
-    {
-        $this->initializeProxy();
-
-        return parent::reverse();
-    }
-
-    /**
-     * Search the collection for a given value and return the corresponding key if successful.
-     *
-     * @param mixed $value
-     * @param bool  $strict
-     *
-     * @return mixed
-     */
-    public function search($value, $strict = false)
-    {
-        $this->initializeProxy();
-
-        return parent::search($value, $strict);
-    }
-
-    /**
-     * Get and remove the first item from the collection.
-     *
-     * @return mixed
-     */
-    public function shift()
-    {
-        // Todo : Partial Removing
-        // we could have a pending removal array
-        $this->initializeProxy();
-
-        return parent::shift();
-    }
-
-    /**
-     * Shuffle the items in the collection.
-     *
-     * @param int $seed
-     *
-     * @return static
-     */
-    public function shuffle($seed = null)
-    {
-        $this->initializeProxy();
-
-        return parent::shuffle($seed);
-    }
-
-    /**
-     * Slice the underlying collection array.
-     *
-     * @param int $offset
-     * @param int $length
-     *
-     * @return static
-     */
-    public function slice($offset, $length = null)
-    {
-        $this->initializeProxy();
-
-        return parent::slice($offset, $length);
-    }
-
-    /**
-     * Split a collection into a certain number of groups.
-     *
-     * @param int $numberOfGroups
-     *
-     * @return static
-     */
-    public function split($numberOfGroups)
-    {
-        $this->initializeProxy();
-
-        return parent::split($numberOfGroups);
-    }
-
-    /**
-     * Chunk the underlying collection array.
-     *
-     * @param int $size
-     *
-     * @return static
-     */
-    public function chunk($size)
-    {
-        // TODO : partial loading ?
-        $this->initializeProxy();
-
-        return parent::chunk($size);
-    }
-
-    /**
-     * Sort through each item with a callback.
-     *
-     * @param callable|null $callback
-     *
-     * @return static
-     */
-    public function sort(callable $callback = null)
-    {
-        $this->initializeProxy();
-
-        return parent::sort($callback);
-    }
-
-    /**
-     * Sort the collection using the given callback.
-     *
-     * @param callable|string $callback
-     * @param int             $options
-     * @param bool            $descending
-     *
-     * @return static
-     */
-    public function sortBy($callback, $options = SORT_REGULAR, $descending = false)
-    {
-        $this->initializeProxy();
-
-        return parent::sort($callback, $options, $descending);
-    }
-
-    /**
-     * Splice a portion of the underlying collection array.
-     *
-     * @param int      $offset
-     * @param int|null $length
-     * @param mixed    $replacement
-     *
-     * @return static
-     */
-    public function splice($offset, $length = null, $replacement = [])
-    {
-        $this->initializeProxy();
-
-        return parent::splice($offset, $length, $replacement);
-    }
-
-    /**
-     * Get the sum of the given values.
-     *
-     * @param callable|string|null $callback
-     *
-     * @return mixed
-     */
-    public function sum($callback = null)
-    {
-        $this->initializeProxy();
-
-        return parent::sum($callback);
-    }
-
-    /**
-     * Take the first or last {$limit} items.
-     *
-     * @param int $limit
-     *
-     * @return static
-     */
-    public function take($limit)
-    {
-        // TODO: partial loading
-        $this->initializeProxy();
-
-        return parent::take($limit);
-    }
-
-    /**
-     * Transform each item in the collection using a callback.
-     *
-     * @param callable $callback
-     *
-     * @return $this
-     */
-    public function transform(callable $callback)
-    {
-        $this->initializeProxy();
-
-        return parent::transform($callback);
-    }
-
-    /**
-     * Return only unique items from the collection array.
-     *
-     * @param string|callable|null $key
-     * @param bool                 $strict
-     *
-     * @return static
-     */
-    public function unique($key = null, $strict = false)
-    {
-        $this->initializeProxy();
-
-        return parent::unique($key, $strict);
-    }
-
-    /**
-     * Reset the keys on the underlying array.
-     *
-     * @return static
-     */
-    public function values()
-    {
-        $this->initializeProxy();
-
-        return parent::values();
-    }
-
-    /**
-     * Zip the collection together with one or more arrays.
-     *
-     * e.g. new Collection([1, 2, 3])->zip([4, 5, 6]);
-     *      => [[1, 4], [2, 5], [3, 6]]
-     *
-     * @param mixed ...$items
-     *
-     * @return static
-     */
-    public function zip($items)
-    {
-        $this->initializeProxy();
-
-        return parent::zip($items);
-    }
-
-    /**
-     * Get the collection of items as a plain array.
-     *
-     * @return array
-     */
-    public function toArray()
-    {
-        // If this is called on all subsequent proxy,
-        // this would eventually trigger all lazy loading,
-        // which is NOT what we would expect...
-        // TODO : must think of this.
-        $this->initializeProxy();
-
-        return parent::toArray();
-    }
-
-    /**
-     * Convert the object into something JSON serializable.
-     *
-     * @return array
-     */
-    public function jsonSerialize()
-    {
-        // If this is called on all subsequent proxy,
-        // this would eventually trigger all lazy loading,
-        // which is NOT what we would expect...
-        // TODO : must think of this.
-        $this->initializeProxy();
-
-        return parent::jsonSerialize();
-    }
-
-    /**
-     * Get the collection of items as JSON.
-     *
-     * @param int $options
-     *
-     * @return string
-     */
-    public function toJson($options = 0)
-    {
-        // If this is called on all subsequent proxy,
-        // this would eventually trigger all lazy loading,
-        // which is NOT what we would expect...
-        // TODO : must think of this.
-        $this->initializeProxy();
-
-        return parent::toJson($options);
-    }
-
-    /**
-     * Get an iterator for the items.
-     *
-     * @return \ArrayIterator
-     */
-    public function getIterator()
-    {
-        $this->initializeProxy();
-
-        return parent::getIterator();
-    }
-
-    /**
-     * Get a CachingIterator instance.
-     *
-     * @param int $flags
-     *
-     * @return \CachingIterator
-     */
-    public function getCachingIterator($flags = CachingIterator::CALL_TOSTRING)
-    {
-        $this->initializeProxy();
-
-        return parent::getCachingIterator($flags);
-    }
-
-    /**
-     * Count the number of items in the collection.
-     *
-     * @return int
-     */
-    public function count()
-    {
-        // TODO rely on QB if not initialized
-        $this->initializeProxy();
-
-        return parent::count();
-    }
-
-    /**
-     * Get a base Support collection instance from this collection.
-     *
-     * @return \Illuminate\Support\Collection
-     */
-    public function toBase()
-    {
-        $this->initializeProxy();
-
-        return parent::toBase();
-    }
-
-    /**
-     * Determine if an item exists at an offset.
-     *
-     * @param mixed $key
-     *
-     * @return bool
-     */
-    public function offsetExists($key)
-    {
-        // TODO rely on QB if no collection
-        // initialized
-        $this->initializeProxy();
-
-        return parent::offsetExists($key);
-    }
-
-    /**
-     * Get an item at a given offset.
-     *
-     * @param mixed $key
-     *
-     * @return mixed
-     */
-    public function offsetGet($key)
-    {
-        // TODO rely on partial init if no collection
-        // initialized
-        $this->initializeProxy();
-
-        return parent::offsetGet($key);
-    }
-
-    /**
-     * Set the item at a given offset.
-     *
-     * @param mixed $key
-     * @param mixed $value
-     *
-     * @return void
-     */
-    public function offsetSet($key, $value)
-    {
-        // TODO : think of the use of it into a ProxyCollection
-        // context
-        $this->initializeProxy();
-
-        return parent::offsetSet($key, $value);
-    }
-
-    /**
-     * Unset the item at a given offset.
-     *
-     * @param string $key
-     *
-     * @return void
-     */
-    public function offsetUnset($key)
-    {
-        // TODO : think of the use of it into a ProxyCollection
-        // context
-        $this->initializeProxy();
-
-        return parent::offsetUnset($key);
-    }
-
-    /**
-     * Dynamically access collection proxies.
-     *
-     * @param string $key
-     *
-     * @throws \Exception
-     *
-     * @return mixed
-     */
-    public function __get($key)
-    {
-        parent::__get($key);
-    }
-
-    /**
-     * Dynamically handle calls to the class.
-     *
-     * @param string $method
-     * @param array  $parameters
-     *
-     * @throws \BadMethodCallException
-     *
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        $this->initializeProxy();
-
-        return parent::__call($method, $parameters);
-    }
+	/**
+	 * Indicate if the relationship has been lazy loaded.
+	 *
+	 * @var bool
+	 */
+	protected $relationshipLoaded = false;
+
+	protected $addedItems = [];
+
+	/**
+	 * Create a new collection.
+	 *
+	 * @param mixed  $entity
+	 * @param string $relation
+	 *
+	 * @return void
+	 */
+	public function __construct($entity, $relation)
+	{
+		$this->parentEntity = $entity;
+		$this->relationshipMethod = $relation;
+	}
+
+	/**
+	 * Return Items that has been added without lady loading
+	 * the underlying collection.
+	 *
+	 * @return array
+	 */
+	public function getAddedItems()
+	{
+		return $this->addedItems;
+	}
+
+	/**
+	 * Force initialization of the proxy.
+	 *
+	 * @return bool true if the proxy could be initialized
+	 */
+	public function initializeProxy() : bool
+	{
+		if ($this->isProxyInitialized()) {
+			return true;
+		}
+
+		$relation = $this->relationshipMethod;
+		$entity = $this->parentEntity;
+
+		$entityMap = Manager::getMapper($entity)->getEntityMap();
+
+		$this->items = $entityMap->$relation($entity)->getResults($relation)->all() + $this->addedItems;
+
+		$this->relationshipLoaded = true;
+
+		return true;
+	}
+
+	/**
+	 * Retrieves current initialization status of the proxy.
+	 *
+	 * @return bool
+	 */
+	public function isProxyInitialized() : bool
+	{
+		return $this->relationshipLoaded;
+	}
+
+	/**
+	 * Get all of the items in the collection.
+	 *
+	 * @return array
+	 */
+	public function all()
+	{
+		$this->initializeProxy();
+
+		return parent::all();
+	}
+
+	/**
+	 * Get the average value of a given key.
+	 *
+	 * @param callable|string|null $callback
+	 *
+	 * @return mixed
+	 */
+	public function avg($callback = null)
+	{
+		$this->initializeProxy();
+
+		return parent::avg($callback);
+	}
+
+	/**
+	 * Get the median of a given key.
+	 *
+	 * @param null $key
+	 *
+	 * @return mixed|null
+	 */
+	public function median($key = null)
+	{
+		$this->initializeProxy();
+
+		return parent::median($key);
+	}
+
+	/**
+	 * Get the mode of a given key.
+	 *
+	 * @param mixed $key
+	 *
+	 * @return array
+	 */
+	public function mode($key = null)
+	{
+		$this->initializeProxy();
+
+		return parent::mode($key);
+	}
+
+	/**
+	 * Collapse the collection of items into a single array.
+	 *
+	 * @return static
+	 */
+	public function collapse()
+	{
+		$this->initializeProxy();
+
+		return parent::collapse();
+	}
+
+	/**
+	 * Determine if an item exists in the collection.
+	 *
+	 * @param mixed $key
+	 * @param mixed $value
+	 *
+	 * @return bool
+	 */
+	public function contains($key, $operator = null, $value = null)
+	{
+		$this->initializeProxy();
+
+		return parent::contains($key, $operator, $value);
+	}
+
+	/**
+	 * Determine if an item exists in the collection using strict comparison.
+	 *
+	 * @param mixed $key
+	 * @param mixed $value
+	 *
+	 * @return bool
+	 */
+	public function containsStrict($key, $value = null)
+	{
+		$this->initializeProxy();
+
+		return parent::containsStrict($key, $value);
+	}
+
+	/**
+	 * Get the items in the collection that are not present in the given items.
+	 *
+	 * @param mixed $items
+	 *
+	 * @return static
+	 */
+	public function diff($items)
+	{
+		$this->initializeProxy();
+
+		return parent::diff($items);
+	}
+
+	/**
+	 * Get the items in the collection whose keys are not present in the given items.
+	 *
+	 * @param mixed $items
+	 *
+	 * @return static
+	 */
+	public function diffKeys($items)
+	{
+		$this->initializeProxy();
+
+		return parent::diffKeys($items);
+	}
+
+	/**
+	 * Execute a callback over each item.
+	 *
+	 * @param callable $callback
+	 *
+	 * @return $this
+	 */
+	public function each(callable $callback)
+	{
+		$this->initializeProxy();
+
+		return parent::each($callback);
+	}
+
+	/**
+	 * Create a new collection consisting of every n-th element.
+	 *
+	 * @param int $step
+	 * @param int $offset
+	 *
+	 * @return static
+	 */
+	public function every($key, $operator = null, $value = null)
+	{
+		$this->initializeProxy();
+
+		return parent::every($key, $operator, $value);
+	}
+
+	/**
+	 * Get all items except for those with the specified keys.
+	 *
+	 * @param mixed $keys
+	 *
+	 * @return static
+	 */
+	public function except($keys)
+	{
+		$this->initializeProxy();
+
+		return parent::except($keys);
+	}
+
+	/**
+	 * Run a filter over each of the items.
+	 *
+	 * @param callable|null $callback
+	 *
+	 * @return static
+	 */
+	public function filter(callable $callback = null)
+	{
+		$this->initializeProxy();
+
+		return parent::filter($callback);
+	}
+
+	/**
+	 * Filter items by the given key value pair.
+	 *
+	 * @param string $key
+	 * @param mixed  $operator
+	 * @param mixed  $value
+	 *
+	 * @return static
+	 */
+	public function where($key, $operator, $value = null)
+	{
+		$this->initializeProxy();
+
+		return parent::where($key, $operator, $value);
+	}
+
+	/**
+	 * Filter items by the given key value pair using strict comparison.
+	 *
+	 * @param string $key
+	 * @param mixed  $value
+	 *
+	 * @return static
+	 */
+	public function whereStrict($key, $value)
+	{
+		$this->initializeProxy();
+
+		return parent::whereStrict($key, $value);
+	}
+
+	/**
+	 * Filter items by the given key value pair.
+	 *
+	 * @param string $key
+	 * @param mixed  $values
+	 * @param bool   $strict
+	 *
+	 * @return static
+	 */
+	public function whereIn($key, $values, $strict = false)
+	{
+		$this->initializeProxy();
+
+		return parent::whereIn($key, $values, $strict);
+	}
+
+	/**
+	 * Filter items by the given key value pair using strict comparison.
+	 *
+	 * @param string $key
+	 * @param mixed  $values
+	 *
+	 * @return static
+	 */
+	public function whereInStrict($key, $values)
+	{
+		$this->initializeProxy();
+
+		return parent::whereInStrict($key, $values);
+	}
+
+	/**
+	 * Get the first item from the collection.
+	 *
+	 * @param callable|null $callback
+	 * @param mixed         $default
+	 *
+	 * @return mixed
+	 */
+	public function first(callable $callback = null, $default = null)
+	{
+		// TODO Consider partial loading
+		$this->initializeProxy();
+
+		return parent::first($callback, $default);
+	}
+
+	/**
+	 * Get a flattened array of the items in the collection.
+	 *
+	 * @param int $depth
+	 *
+	 * @return static
+	 */
+	public function flatten($depth = INF)
+	{
+		$this->initializeProxy();
+
+		return parent::flatten($depth);
+	}
+
+	/**
+	 * Flip the items in the collection.
+	 *
+	 * @return static
+	 */
+	public function flip()
+	{
+		$this->initializeProxy();
+
+		return parent::flip();
+	}
+
+	/**
+	 * Remove an item from the collection by key.
+	 *
+	 * @param string|array $keys
+	 *
+	 * @return $this
+	 */
+	public function forget($keys)
+	{
+		// TODO, we could consider these as
+		// 'pending deletion', the same way that
+		// we treat added items
+		$this->initializeProxy();
+
+		return parent::forget($keys);
+	}
+
+	/**
+	 * Get an item from the collection by key.
+	 *
+	 * @param mixed $key
+	 * @param mixed $default
+	 *
+	 * @return mixed
+	 */
+	public function get($key, $default = null)
+	{
+		// TODO : We could also consider partial loading
+		// here
+		$this->initializeProxy();
+
+		return parent::get($key, $default);
+	}
+
+	/**
+	 * Group an associative array by a field or using a callback.
+	 *
+	 * @param callable|string $groupBy
+	 * @param bool            $preserveKeys
+	 *
+	 * @return static
+	 */
+	public function groupBy($groupBy, $preserveKeys = false)
+	{
+		$this->initializeProxy();
+
+		return parent::groupBy($groupBy, $preserveKeys);
+	}
+
+	/**
+	 * Key an associative array by a field or using a callback.
+	 *
+	 * @param callable|string $keyBy
+	 *
+	 * @return static
+	 */
+	public function keyBy($keyBy)
+	{
+		$this->initializeProxy();
+
+		return parent::keyBy($keyBy);
+	}
+
+	/**
+	 * Determine if an item exists in the collection by key.
+	 *
+	 * @param mixed $key
+	 *
+	 * @return bool
+	 */
+	public function has($key)
+	{
+		// TODO : we could do automagic here by directly
+		// calling the database if the collection hasn't
+		// been initialized yet.
+		// Potential issue is that several calls to this
+		// could cause a lot queries vs a single get query.
+		$this->initializeProxy();
+
+		return parent::has($key);
+	}
+
+	/**
+	 * Concatenate values of a given key as a string.
+	 *
+	 * @param string $value
+	 * @param string $glue
+	 *
+	 * @return string
+	 */
+	public function implode($value, $glue = null)
+	{
+		$this->initializeProxy();
+
+		return parent::implode($value, $glue);
+	}
+
+	/**
+	 * Intersect the collection with the given items.
+	 *
+	 * @param mixed $items
+	 *
+	 * @return static
+	 */
+	public function intersect($items)
+	{
+		$this->initializeProxy();
+
+		return parent::intersect($items);
+	}
+
+	/**
+	 * Determine if the collection is empty or not.
+	 *
+	 * @return bool
+	 */
+	public function isEmpty()
+	{
+		$this->initializeProxy();
+
+		return parent::isEmpty();
+	}
+
+	/**
+	 * Get the keys of the collection items.
+	 *
+	 * @return static
+	 */
+	public function keys()
+	{
+		$this->initializeProxy();
+
+		return parent::keys();
+	}
+
+	/**
+	 * Get the last item from the collection.
+	 *
+	 * @param callable|null $callback
+	 * @param mixed         $default
+	 *
+	 * @return mixed
+	 */
+	public function last(callable $callback = null, $default = null)
+	{
+		// TODO : we could do partial loading there as well
+		$this->initializeProxy();
+
+		return parent::last($callback, $default);
+	}
+
+	/**
+	 * Get the values of a given key.
+	 *
+	 * @param string      $value
+	 * @param string|null $key
+	 *
+	 * @return static
+	 */
+	public function pluck($value, $key = null)
+	{
+		// TODO : automagic call to QB if not initialized
+		$this->initializeProxy();
+
+		return parent::pluck($value, $key);
+	}
+
+	/**
+	 * Run a map over each of the items.
+	 *
+	 * @param callable $callback
+	 *
+	 * @return static
+	 */
+	public function map(callable $callback)
+	{
+		$this->initializeProxy();
+
+		return parent::map($callback);
+	}
+
+	/**
+	 * Run an associative map over each of the items.
+	 *
+	 * The callback should return an associative array with a single key/value pair.
+	 *
+	 * @param callable $callback
+	 *
+	 * @return static
+	 */
+	public function mapWithKeys(callable $callback)
+	{
+		$this->initializeProxy();
+
+		return parent::mapWithKeys($callback);
+	}
+
+	/**
+	 * Map a collection and flatten the result by a single level.
+	 *
+	 * @param callable $callback
+	 *
+	 * @return static
+	 */
+	public function flatMap(callable $callback)
+	{
+		$this->initializeProxy();
+
+		return parent::flatMap($callback);
+	}
+
+	/**
+	 * Get the max value of a given key.
+	 *
+	 * @param callable|string|null $callback
+	 *
+	 * @return mixed
+	 */
+	public function max($callback = null)
+	{
+		$this->initializeProxy();
+
+		return parent::max($callback);
+	}
+
+	/**
+	 * Merge the collection with the given items.
+	 *
+	 * @param mixed $items
+	 *
+	 * @return static
+	 */
+	public function merge($items)
+	{
+		// TODO : Check if the EntityCollection
+		// returns a native Collection, as it
+		// is what we want here
+		$this->initializeProxy();
+
+		return parent::merge($items);
+	}
+
+	/**
+	 * Create a collection by using this collection for keys and another for its values.
+	 *
+	 * @param mixed $values
+	 *
+	 * @return static
+	 */
+	public function combine($values)
+	{
+		// TODO : Check if the EntityCollection
+		// returns a native Collection, as it
+		// is what we want here
+		$this->initializeProxy();
+
+		return parent::combine($values);
+	}
+
+	/**
+	 * Union the collection with the given items.
+	 *
+	 * @param mixed $items
+	 *
+	 * @return static
+	 */
+	public function union($items)
+	{
+		// TODO : Check if the EntityCollection
+		// returns a native Collection, as it
+		// is what we want here
+		$this->initializeProxy();
+
+		return parent::union($items);
+	}
+
+	/**
+	 * Get the min value of a given key.
+	 *
+	 * @param callable|string|null $callback
+	 *
+	 * @return mixed
+	 */
+	public function min($callback = null)
+	{
+		// TODO : we could rely on the QB
+		// for thos, if initialization has not
+		// take place yet
+		$this->initializeProxy();
+
+		return parent::min($callback);
+	}
+
+	/**
+	 * Create a new collection consisting of every n-th element.
+	 *
+	 * @param int $step
+	 * @param int $offset
+	 *
+	 * @return static
+	 */
+	public function nth($step, $offset = 0)
+	{
+		$this->initializeProxy();
+
+		return parent::nth($step, $offset);
+	}
+
+	/**
+	 * Get the items with the specified keys.
+	 *
+	 * @param mixed $keys
+	 *
+	 * @return static
+	 */
+	public function only($keys)
+	{
+		// TODO : we could rely on the QB if
+		// the collection hasn't been initialized yet
+		$this->initializeProxy();
+
+		return parent::only($keys);
+	}
+
+	/**
+	 * "Paginate" the collection by slicing it into a smaller collection.
+	 *
+	 * @param int $page
+	 * @param int $perPage
+	 *
+	 * @return static
+	 */
+	public function forPage($page, $perPage)
+	{
+		// TODO : check possibility of partial loading
+		// if not initialized
+		$this->initializeProxy();
+
+		return parent::forPage($page, $perPage);
+	}
+
+	/**
+	 * Partition the collection into two arrays using the given callback or key.
+	 *
+	 * @param callable|string $callback
+	 *
+	 * @return static
+	 */
+	public function partition($callback)
+	{
+		$this->initializeProxy();
+
+		return parent::partition($callback);
+	}
+
+	/**
+	 * Pass the collection to the given callback and return the result.
+	 *
+	 * @param callable $callback
+	 *
+	 * @return mixed
+	 */
+	public function pipe(callable $callback)
+	{
+		$this->initializeProxy();
+
+		return parent::pipe($callback);
+	}
+
+	/**
+	 * Get and remove the last item from the collection.
+	 *
+	 * @return mixed
+	 */
+	public function pop()
+	{
+		$this->initializeProxy();
+
+		return parent::pop();
+	}
+
+	/**
+	 * Push an item onto the beginning of the collection.
+	 *
+	 * @param mixed $value
+	 * @param mixed $key
+	 *
+	 * @return $this
+	 */
+	public function prepend($value, $key = null)
+	{
+		// TODO : partial adding of values.
+		// we could have a $prepended , and $pushed arrays
+		// which we would combine at full initialization
+
+		$this->initializeProxy();
+
+		return parent::prepend($value, $key);
+	}
+
+	/**
+	 * Push an item onto the end of the collection.
+	 *
+	 * @param mixed $value
+	 *
+	 * @return $this
+	 */
+	public function push($value)
+	{
+		// TODO : partial adding of values.
+		// we could have a $prepended , and $pushed arrays
+		// which we would combine at full initialization
+
+		$this->initializeProxy();
+
+		return parent::push($value);
+	}
+
+	/**
+	 * Get and remove an item from the collection.
+	 *
+	 * @param mixed $key
+	 * @param mixed $default
+	 *
+	 * @return mixed
+	 */
+	public function pull($key, $default = null)
+	{
+		// TODO : QB query if the collection
+		// hasn't been initialized yet
+
+		$this->initializeProxy();
+
+		return parent::pull($key, $default);
+	}
+
+	/**
+	 * Put an item in the collection by key.
+	 *
+	 * @param mixed $key
+	 * @param mixed $value
+	 *
+	 * @return $this
+	 */
+	public function put($key, $value)
+	{
+		// TODO : Partial loading ?
+
+		$this->initializeProxy();
+
+		return parent::put($key, $value);
+	}
+
+	/**
+	 * Get one or more items randomly from the collection.
+	 *
+	 * @param int $amount
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return mixed
+	 */
+	public function random($amount = 1)
+	{
+		// TODO : we could optimize this by only
+		// fetching the keys from the database
+		// and performing partial loading
+
+		$this->initializeProxy();
+
+		return parent::random($amount);
+	}
+
+	/**
+	 * Reduce the collection to a single value.
+	 *
+	 * @param callable $callback
+	 * @param mixed    $initial
+	 *
+	 * @return mixed
+	 */
+	public function reduce(callable $callback, $initial = null)
+	{
+		$this->initializeProxy();
+
+		return parent::reduce($callback, $initial);
+	}
+
+	/**
+	 * Create a collection of all elements that do not pass a given truth test.
+	 *
+	 * @param callable|mixed $callback
+	 *
+	 * @return static
+	 */
+	public function reject($callback)
+	{
+		$this->initializeProxy();
+
+		return parent::reject($callback);
+	}
+
+	/**
+	 * Reverse items order.
+	 *
+	 * @return static
+	 */
+	public function reverse()
+	{
+		$this->initializeProxy();
+
+		return parent::reverse();
+	}
+
+	/**
+	 * Search the collection for a given value and return the corresponding key if successful.
+	 *
+	 * @param mixed $value
+	 * @param bool  $strict
+	 *
+	 * @return mixed
+	 */
+	public function search($value, $strict = false)
+	{
+		$this->initializeProxy();
+
+		return parent::search($value, $strict);
+	}
+
+	/**
+	 * Get and remove the first item from the collection.
+	 *
+	 * @return mixed
+	 */
+	public function shift()
+	{
+		// Todo : Partial Removing
+		// we could have a pending removal array
+		$this->initializeProxy();
+
+		return parent::shift();
+	}
+
+	/**
+	 * Shuffle the items in the collection.
+	 *
+	 * @param int $seed
+	 *
+	 * @return static
+	 */
+	public function shuffle($seed = null)
+	{
+		$this->initializeProxy();
+
+		return parent::shuffle($seed);
+	}
+
+	/**
+	 * Slice the underlying collection array.
+	 *
+	 * @param int $offset
+	 * @param int $length
+	 *
+	 * @return static
+	 */
+	public function slice($offset, $length = null)
+	{
+		$this->initializeProxy();
+
+		return parent::slice($offset, $length);
+	}
+
+	/**
+	 * Split a collection into a certain number of groups.
+	 *
+	 * @param int $numberOfGroups
+	 *
+	 * @return static
+	 */
+	public function split($numberOfGroups)
+	{
+		$this->initializeProxy();
+
+		return parent::split($numberOfGroups);
+	}
+
+	/**
+	 * Chunk the underlying collection array.
+	 *
+	 * @param int $size
+	 *
+	 * @return static
+	 */
+	public function chunk($size)
+	{
+		// TODO : partial loading ?
+		$this->initializeProxy();
+
+		return parent::chunk($size);
+	}
+
+	/**
+	 * Sort through each item with a callback.
+	 *
+	 * @param callable|null $callback
+	 *
+	 * @return static
+	 */
+	public function sort(callable $callback = null)
+	{
+		$this->initializeProxy();
+
+		return parent::sort($callback);
+	}
+
+	/**
+	 * Sort the collection using the given callback.
+	 *
+	 * @param callable|string $callback
+	 * @param int             $options
+	 * @param bool            $descending
+	 *
+	 * @return static
+	 */
+	public function sortBy($callback, $options = SORT_REGULAR, $descending = false)
+	{
+		$this->initializeProxy();
+
+		return parent::sort($callback, $options, $descending);
+	}
+
+	/**
+	 * Splice a portion of the underlying collection array.
+	 *
+	 * @param int      $offset
+	 * @param int|null $length
+	 * @param mixed    $replacement
+	 *
+	 * @return static
+	 */
+	public function splice($offset, $length = null, $replacement = [])
+	{
+		$this->initializeProxy();
+
+		return parent::splice($offset, $length, $replacement);
+	}
+
+	/**
+	 * Get the sum of the given values.
+	 *
+	 * @param callable|string|null $callback
+	 *
+	 * @return mixed
+	 */
+	public function sum($callback = null)
+	{
+		$this->initializeProxy();
+
+		return parent::sum($callback);
+	}
+
+	/**
+	 * Take the first or last {$limit} items.
+	 *
+	 * @param int $limit
+	 *
+	 * @return static
+	 */
+	public function take($limit)
+	{
+		// TODO: partial loading
+		$this->initializeProxy();
+
+		return parent::take($limit);
+	}
+
+	/**
+	 * Transform each item in the collection using a callback.
+	 *
+	 * @param callable $callback
+	 *
+	 * @return $this
+	 */
+	public function transform(callable $callback)
+	{
+		$this->initializeProxy();
+
+		return parent::transform($callback);
+	}
+
+	/**
+	 * Return only unique items from the collection array.
+	 *
+	 * @param string|callable|null $key
+	 * @param bool                 $strict
+	 *
+	 * @return static
+	 */
+	public function unique($key = null, $strict = false)
+	{
+		$this->initializeProxy();
+
+		return parent::unique($key, $strict);
+	}
+
+	/**
+	 * Reset the keys on the underlying array.
+	 *
+	 * @return static
+	 */
+	public function values()
+	{
+		$this->initializeProxy();
+
+		return parent::values();
+	}
+
+	/**
+	 * Zip the collection together with one or more arrays.
+	 *
+	 * e.g. new Collection([1, 2, 3])->zip([4, 5, 6]);
+	 *      => [[1, 4], [2, 5], [3, 6]]
+	 *
+	 * @param mixed ...$items
+	 *
+	 * @return static
+	 */
+	public function zip($items)
+	{
+		$this->initializeProxy();
+
+		return parent::zip($items);
+	}
+
+	/**
+	 * Get the collection of items as a plain array.
+	 *
+	 * @return array
+	 */
+	public function toArray()
+	{
+		// If this is called on all subsequent proxy,
+		// this would eventually trigger all lazy loading,
+		// which is NOT what we would expect...
+		// TODO : must think of this.
+		$this->initializeProxy();
+
+		return parent::toArray();
+	}
+
+	/**
+	 * Convert the object into something JSON serializable.
+	 *
+	 * @return array
+	 */
+	public function jsonSerialize()
+	{
+		// If this is called on all subsequent proxy,
+		// this would eventually trigger all lazy loading,
+		// which is NOT what we would expect...
+		// TODO : must think of this.
+		$this->initializeProxy();
+
+		return parent::jsonSerialize();
+	}
+
+	/**
+	 * Get the collection of items as JSON.
+	 *
+	 * @param int $options
+	 *
+	 * @return string
+	 */
+	public function toJson($options = 0)
+	{
+		// If this is called on all subsequent proxy,
+		// this would eventually trigger all lazy loading,
+		// which is NOT what we would expect...
+		// TODO : must think of this.
+		$this->initializeProxy();
+
+		return parent::toJson($options);
+	}
+
+	/**
+	 * Get an iterator for the items.
+	 *
+	 * @return \ArrayIterator
+	 */
+	public function getIterator()
+	{
+		$this->initializeProxy();
+
+		return parent::getIterator();
+	}
+
+	/**
+	 * Get a CachingIterator instance.
+	 *
+	 * @param int $flags
+	 *
+	 * @return \CachingIterator
+	 */
+	public function getCachingIterator($flags = CachingIterator::CALL_TOSTRING)
+	{
+		$this->initializeProxy();
+
+		return parent::getCachingIterator($flags);
+	}
+
+	/**
+	 * Count the number of items in the collection.
+	 *
+	 * @return int
+	 */
+	public function count()
+	{
+		// TODO rely on QB if not initialized
+		$this->initializeProxy();
+
+		return parent::count();
+	}
+
+	/**
+	 * Get a base Support collection instance from this collection.
+	 *
+	 * @return \Illuminate\Support\Collection
+	 */
+	public function toBase()
+	{
+		$this->initializeProxy();
+
+		return parent::toBase();
+	}
+
+	/**
+	 * Determine if an item exists at an offset.
+	 *
+	 * @param mixed $key
+	 *
+	 * @return bool
+	 */
+	public function offsetExists($key)
+	{
+		// TODO rely on QB if no collection
+		// initialized
+		$this->initializeProxy();
+
+		return parent::offsetExists($key);
+	}
+
+	/**
+	 * Get an item at a given offset.
+	 *
+	 * @param mixed $key
+	 *
+	 * @return mixed
+	 */
+	public function offsetGet($key)
+	{
+		// TODO rely on partial init if no collection
+		// initialized
+		$this->initializeProxy();
+
+		return parent::offsetGet($key);
+	}
+
+	/**
+	 * Set the item at a given offset.
+	 *
+	 * @param mixed $key
+	 * @param mixed $value
+	 *
+	 * @return void
+	 */
+	public function offsetSet($key, $value)
+	{
+		// TODO : think of the use of it into a ProxyCollection
+		// context
+		$this->initializeProxy();
+
+		return parent::offsetSet($key, $value);
+	}
+
+	/**
+	 * Unset the item at a given offset.
+	 *
+	 * @param string $key
+	 *
+	 * @return void
+	 */
+	public function offsetUnset($key)
+	{
+		// TODO : think of the use of it into a ProxyCollection
+		// context
+		$this->initializeProxy();
+
+		return parent::offsetUnset($key);
+	}
+
+	/**
+	 * Dynamically access collection proxies.
+	 *
+	 * @param string $key
+	 *
+	 * @throws \Exception
+	 *
+	 * @return mixed
+	 */
+	public function __get($key)
+	{
+		parent::__get($key);
+	}
+
+	/**
+	 * Dynamically handle calls to the class.
+	 *
+	 * @param string $method
+	 * @param array  $parameters
+	 *
+	 * @throws \BadMethodCallException
+	 *
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		$this->initializeProxy();
+
+		return parent::__call($method, $parameters);
+	}
 }

src/EntityCollection.php

Indentation +445 added lines, -445 removed lines

@@ -10,449 +10,449 @@
 
 class EntityCollection extends Collection
 {
-    /**
-     * Wrapper Factory.
-     *
-     * @var \Analogue\ORM\System\Wrappers\Factory
-     */
-    protected $factory;
-
-    /**
-     * EntityCollection constructor.
-     *
-     * @param array|null $entities
-     */
-    public function __construct(array $entities = null)
-    {
-        $this->factory = new Factory();
-
-        parent::__construct($entities);
-    }
-
-    /**
-     * Find an entity in the collection by key.
-     *
-     * @param mixed $key
-     * @param mixed $default
-     *
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\Entity
-     */
-    public function find($key, $default = null)
-    {
-        if ($key instanceof Mappable) {
-            $key = $this->getEntityKey($key);
-        }
-
-        return array_first($this->items, function ($entity, $itemKey) use ($key) {
-            return $this->getEntityKey($entity) == $key;
-        }, $default);
-    }
-
-    /**
-     * Add an entity to the collection.
-     *
-     * @param Mappable $entity
-     *
-     * @return $this
-     */
-    public function add($entity)
-    {
-        $this->push($entity);
-
-        return $this;
-    }
-
-    /**
-     * Remove an entity from the collection.
-     *
-     * @param $entity
-     *
-     * @throws MappingException
-     *
-     * @return mixed
-     */
-    public function remove($entity)
-    {
-        $key = $this->getEntityKey($entity);
-
-        return $this->pull($key);
-    }
-
-    /**
-     * Push an item onto the end of the collection.
-     *
-     * @param mixed $value
-     *
-     * @return void
-     */
-    public function push($value)
-    {
-        $this->offsetSet(null, $value);
-    }
-
-    /**
-     * Put an item in the collection by key.
-     *
-     * @param mixed $key
-     * @param mixed $value
-     *
-     * @return void
-     */
-    public function put($key, $value)
-    {
-        $this->offsetSet($key, $value);
-    }
-
-    /**
-     * Set the item at a given offset.
-     *
-     * @param mixed $key
-     * @param mixed $value
-     *
-     * @return void
-     */
-    public function offsetSet($key, $value)
-    {
-        if (is_null($key)) {
-            $this->items[] = $value;
-        } else {
-            $this->items[$key] = $value;
-        }
-    }
-
-    /**
-     * Determine if a key exists in the collection.
-     *
-     * @param mixed      $key
-     * @param mixed|null $value
-     *
-     * @return bool
-     */
-    // public function contains($key, $value = null)
-    // {
-    //     if (func_num_args() == 2) {
-    //         return !$this->where($key, $value)->isEmpty();
-    //     }
-
-    //     if ($this->useAsCallable($key)) {
-    //         return !is_null($this->first($key));
-    //     }
-
-    //     return !is_null($this->find($key));
-    // }
-
-    /**
-     * Fetch a nested element of the collection.
-     *
-     * @param string $key
-     *
-     * @return self
-     */
-    public function fetch($key)
-    {
-        return new static(array_fetch($this->toArray(), $key));
-    }
-
-    /**
-     * Generic function for returning class.key value pairs.
-     *
-     * @throws MappingException
-     *
-     * @return string
-     */
-    public function getEntityHashes()
-    {
-        return array_map(function ($entity) {
-            $class = get_class($entity);
-
-            $mapper = Manager::getMapper($class);
-
-            $keyName = $mapper->getEntityMap()->getKeyName();
-
-            return $class.'.'.$entity->getEntityAttribute($keyName);
-        },
-        $this->items);
-    }
-
-    /**
-     * Get a subset of the collection from entity hashes.
-     *
-     * @param array $hashes
-     *
-     * @throws MappingException
-     *
-     * @return array
-     */
-    public function getSubsetByHashes(array $hashes)
-    {
-        $subset = [];
-
-        foreach ($this->items as $item) {
-            $class = get_class($item);
-
-            $mapper = Manager::getMapper($class);
-
-            $keyName = $mapper->getEntityMap()->getKeyName();
-
-            if (in_array($class.'.'.$item->$keyName, $hashes)) {
-                $subset[] = $item;
-            }
-        }
-
-        return $subset;
-    }
-
-    /**
-     * Merge the collection with the given items.
-     *
-     * @param array $items
-     *
-     * @throws MappingException
-     *
-     * @return self
-     */
-    public function merge($items)
-    {
-        $dictionary = $this->getDictionary();
-
-        foreach ($items as $item) {
-            $dictionary[$this->getEntityKey($item)] = $item;
-        }
-
-        return new static(array_values($dictionary));
-    }
-
-    /**
-     * Diff the collection with the given items.
-     *
-     * @param \ArrayAccess|array $items
-     *
-     * @return self
-     */
-    public function diff($items)
-    {
-        $diff = new static();
-
-        $dictionary = $this->getDictionary($items);
-
-        foreach ($this->items as $item) {
-            if (!isset($dictionary[$this->getEntityKey($item)])) {
-                $diff->add($item);
-            }
-        }
-
-        return $diff;
-    }
-
-    /**
-     * Intersect the collection with the given items.
-     *
-     * @param \ArrayAccess|array $items
-     *
-     * @throws MappingException
-     *
-     * @return self
-     */
-    public function intersect($items)
-    {
-        $intersect = new static();
-
-        $dictionary = $this->getDictionary($items);
-
-        foreach ($this->items as $item) {
-            if (isset($dictionary[$this->getEntityKey($item)])) {
-                $intersect->add($item);
-            }
-        }
-
-        return $intersect;
-    }
-
-    /**
-     * Returns only the models from the collection with the specified keys.
-     *
-     * @param mixed $keys
-     *
-     * @return self
-     */
-    public function only($keys)
-    {
-        $dictionary = array_only($this->getDictionary(), $keys);
-
-        return new static(array_values($dictionary));
-    }
-
-    /**
-     * Returns all models in the collection except the models with specified keys.
-     *
-     * @param mixed $keys
-     *
-     * @return self
-     */
-    public function except($keys)
-    {
-        $dictionary = array_except($this->getDictionary(), $keys);
-
-        return new static(array_values($dictionary));
-    }
-
-    /**
-     * Get a dictionary keyed by primary keys.
-     *
-     * @param \ArrayAccess|array $items
-     *
-     * @throws MappingException
-     *
-     * @return array
-     */
-    public function getDictionary($items = null)
-    {
-        $items = is_null($items) ? $this->items : $items;
-
-        $dictionary = [];
-
-        foreach ($items as $value) {
-            $dictionary[$this->getEntityKey($value)] = $value;
-        }
-
-        return $dictionary;
-    }
-
-    /**
-     * @throws MappingException
-     *
-     * @return array
-     */
-    public function getEntityKeys()
-    {
-        return array_keys($this->getDictionary());
-    }
-
-    /**
-     * @param $entity
-     *
-     * @throws MappingException
-     *
-     * @return mixed
-     */
-    protected function getEntityKey($entity)
-    {
-        $keyName = Manager::getMapper($entity)->getEntityMap()->getKeyName();
-
-        $wrapper = $this->factory->make($entity);
-
-        return $wrapper->getEntityAttribute($keyName);
-    }
-
-    /**
-     * Get the max value of a given key.
-     *
-     * @param string|null $key
-     *
-     * @throws MappingException
-     *
-     * @return mixed
-     */
-    public function max($key = null)
-    {
-        return $this->reduce(function ($result, $item) use ($key) {
-            $wrapper = $this->factory->make($item);
-
-            return (is_null($result) || $wrapper->getEntityAttribute($key) > $result) ?
-                $wrapper->getEntityAttribute($key) : $result;
-        });
-    }
-
-    /**
-     * Get the min value of a given key.
-     *
-     * @param string|null $key
-     *
-     * @throws MappingException
-     *
-     * @return mixed
-     */
-    public function min($key = null)
-    {
-        return $this->reduce(function ($result, $item) use ($key) {
-            $wrapper = $this->factory->make($item);
-
-            return (is_null($result) || $wrapper->getEntityAttribute($key) < $result)
-                ? $wrapper->getEntityAttribute($key) : $result;
-        });
-    }
-
-    /**
-     * Get an array with the values of a given key.
-     *
-     * @param string      $value
-     * @param string|null $key
-     *
-     * @return self
-     */
-    public function pluck($value, $key = null)
-    {
-        return new Collection(Arr::pluck($this->items, $value, $key));
-    }
-
-    /**
-     * Alias for the "pluck" method.
-     *
-     * @param string      $value
-     * @param string|null $key
-     *
-     * @return self
-     */
-    public function lists($value, $key = null)
-    {
-        return $this->pluck($value, $key);
-    }
-
-    /**
-     * Return only unique items from the collection.
-     *
-     * @param string|null $key
-     * @param bool        $strict
-     *
-     * @throws MappingException
-     *
-     * @return self
-     */
-    public function unique($key = null, $strict = false)
-    {
-        $dictionary = $this->getDictionary();
-
-        return new static(array_values($dictionary));
-    }
-
-    /**
-     * Get a base Support collection instance from this collection.
-     *
-     * @return \Illuminate\Support\Collection
-     */
-    public function toBase()
-    {
-        return new Collection($this->items);
-    }
-
-    public function toArray()
-    {
-        return array_values(parent::toArray());
-    }
-
-    /**
-     * Get the collection of items as JSON.
-     *
-     * @param int $options
-     *
-     * @return string
-     */
-    public function toJson($options = 0)
-    {
-        $collection = new Collection(array_values($this->items));
-
-        return $collection->toJson($options);
-    }
+	/**
+	 * Wrapper Factory.
+	 *
+	 * @var \Analogue\ORM\System\Wrappers\Factory
+	 */
+	protected $factory;
+
+	/**
+	 * EntityCollection constructor.
+	 *
+	 * @param array|null $entities
+	 */
+	public function __construct(array $entities = null)
+	{
+		$this->factory = new Factory();
+
+		parent::__construct($entities);
+	}
+
+	/**
+	 * Find an entity in the collection by key.
+	 *
+	 * @param mixed $key
+	 * @param mixed $default
+	 *
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\Entity
+	 */
+	public function find($key, $default = null)
+	{
+		if ($key instanceof Mappable) {
+			$key = $this->getEntityKey($key);
+		}
+
+		return array_first($this->items, function ($entity, $itemKey) use ($key) {
+			return $this->getEntityKey($entity) == $key;
+		}, $default);
+	}
+
+	/**
+	 * Add an entity to the collection.
+	 *
+	 * @param Mappable $entity
+	 *
+	 * @return $this
+	 */
+	public function add($entity)
+	{
+		$this->push($entity);
+
+		return $this;
+	}
+
+	/**
+	 * Remove an entity from the collection.
+	 *
+	 * @param $entity
+	 *
+	 * @throws MappingException
+	 *
+	 * @return mixed
+	 */
+	public function remove($entity)
+	{
+		$key = $this->getEntityKey($entity);
+
+		return $this->pull($key);
+	}
+
+	/**
+	 * Push an item onto the end of the collection.
+	 *
+	 * @param mixed $value
+	 *
+	 * @return void
+	 */
+	public function push($value)
+	{
+		$this->offsetSet(null, $value);
+	}
+
+	/**
+	 * Put an item in the collection by key.
+	 *
+	 * @param mixed $key
+	 * @param mixed $value
+	 *
+	 * @return void
+	 */
+	public function put($key, $value)
+	{
+		$this->offsetSet($key, $value);
+	}
+
+	/**
+	 * Set the item at a given offset.
+	 *
+	 * @param mixed $key
+	 * @param mixed $value
+	 *
+	 * @return void
+	 */
+	public function offsetSet($key, $value)
+	{
+		if (is_null($key)) {
+			$this->items[] = $value;
+		} else {
+			$this->items[$key] = $value;
+		}
+	}
+
+	/**
+	 * Determine if a key exists in the collection.
+	 *
+	 * @param mixed      $key
+	 * @param mixed|null $value
+	 *
+	 * @return bool
+	 */
+	// public function contains($key, $value = null)
+	// {
+	//     if (func_num_args() == 2) {
+	//         return !$this->where($key, $value)->isEmpty();
+	//     }
+
+	//     if ($this->useAsCallable($key)) {
+	//         return !is_null($this->first($key));
+	//     }
+
+	//     return !is_null($this->find($key));
+	// }
+
+	/**
+	 * Fetch a nested element of the collection.
+	 *
+	 * @param string $key
+	 *
+	 * @return self
+	 */
+	public function fetch($key)
+	{
+		return new static(array_fetch($this->toArray(), $key));
+	}
+
+	/**
+	 * Generic function for returning class.key value pairs.
+	 *
+	 * @throws MappingException
+	 *
+	 * @return string
+	 */
+	public function getEntityHashes()
+	{
+		return array_map(function ($entity) {
+			$class = get_class($entity);
+
+			$mapper = Manager::getMapper($class);
+
+			$keyName = $mapper->getEntityMap()->getKeyName();
+
+			return $class.'.'.$entity->getEntityAttribute($keyName);
+		},
+		$this->items);
+	}
+
+	/**
+	 * Get a subset of the collection from entity hashes.
+	 *
+	 * @param array $hashes
+	 *
+	 * @throws MappingException
+	 *
+	 * @return array
+	 */
+	public function getSubsetByHashes(array $hashes)
+	{
+		$subset = [];
+
+		foreach ($this->items as $item) {
+			$class = get_class($item);
+
+			$mapper = Manager::getMapper($class);
+
+			$keyName = $mapper->getEntityMap()->getKeyName();
+
+			if (in_array($class.'.'.$item->$keyName, $hashes)) {
+				$subset[] = $item;
+			}
+		}
+
+		return $subset;
+	}
+
+	/**
+	 * Merge the collection with the given items.
+	 *
+	 * @param array $items
+	 *
+	 * @throws MappingException
+	 *
+	 * @return self
+	 */
+	public function merge($items)
+	{
+		$dictionary = $this->getDictionary();
+
+		foreach ($items as $item) {
+			$dictionary[$this->getEntityKey($item)] = $item;
+		}
+
+		return new static(array_values($dictionary));
+	}
+
+	/**
+	 * Diff the collection with the given items.
+	 *
+	 * @param \ArrayAccess|array $items
+	 *
+	 * @return self
+	 */
+	public function diff($items)
+	{
+		$diff = new static();
+
+		$dictionary = $this->getDictionary($items);
+
+		foreach ($this->items as $item) {
+			if (!isset($dictionary[$this->getEntityKey($item)])) {
+				$diff->add($item);
+			}
+		}
+
+		return $diff;
+	}
+
+	/**
+	 * Intersect the collection with the given items.
+	 *
+	 * @param \ArrayAccess|array $items
+	 *
+	 * @throws MappingException
+	 *
+	 * @return self
+	 */
+	public function intersect($items)
+	{
+		$intersect = new static();
+
+		$dictionary = $this->getDictionary($items);
+
+		foreach ($this->items as $item) {
+			if (isset($dictionary[$this->getEntityKey($item)])) {
+				$intersect->add($item);
+			}
+		}
+
+		return $intersect;
+	}
+
+	/**
+	 * Returns only the models from the collection with the specified keys.
+	 *
+	 * @param mixed $keys
+	 *
+	 * @return self
+	 */
+	public function only($keys)
+	{
+		$dictionary = array_only($this->getDictionary(), $keys);
+
+		return new static(array_values($dictionary));
+	}
+
+	/**
+	 * Returns all models in the collection except the models with specified keys.
+	 *
+	 * @param mixed $keys
+	 *
+	 * @return self
+	 */
+	public function except($keys)
+	{
+		$dictionary = array_except($this->getDictionary(), $keys);
+
+		return new static(array_values($dictionary));
+	}
+
+	/**
+	 * Get a dictionary keyed by primary keys.
+	 *
+	 * @param \ArrayAccess|array $items
+	 *
+	 * @throws MappingException
+	 *
+	 * @return array
+	 */
+	public function getDictionary($items = null)
+	{
+		$items = is_null($items) ? $this->items : $items;
+
+		$dictionary = [];
+
+		foreach ($items as $value) {
+			$dictionary[$this->getEntityKey($value)] = $value;
+		}
+
+		return $dictionary;
+	}
+
+	/**
+	 * @throws MappingException
+	 *
+	 * @return array
+	 */
+	public function getEntityKeys()
+	{
+		return array_keys($this->getDictionary());
+	}
+
+	/**
+	 * @param $entity
+	 *
+	 * @throws MappingException
+	 *
+	 * @return mixed
+	 */
+	protected function getEntityKey($entity)
+	{
+		$keyName = Manager::getMapper($entity)->getEntityMap()->getKeyName();
+
+		$wrapper = $this->factory->make($entity);
+
+		return $wrapper->getEntityAttribute($keyName);
+	}
+
+	/**
+	 * Get the max value of a given key.
+	 *
+	 * @param string|null $key
+	 *
+	 * @throws MappingException
+	 *
+	 * @return mixed
+	 */
+	public function max($key = null)
+	{
+		return $this->reduce(function ($result, $item) use ($key) {
+			$wrapper = $this->factory->make($item);
+
+			return (is_null($result) || $wrapper->getEntityAttribute($key) > $result) ?
+				$wrapper->getEntityAttribute($key) : $result;
+		});
+	}
+
+	/**
+	 * Get the min value of a given key.
+	 *
+	 * @param string|null $key
+	 *
+	 * @throws MappingException
+	 *
+	 * @return mixed
+	 */
+	public function min($key = null)
+	{
+		return $this->reduce(function ($result, $item) use ($key) {
+			$wrapper = $this->factory->make($item);
+
+			return (is_null($result) || $wrapper->getEntityAttribute($key) < $result)
+				? $wrapper->getEntityAttribute($key) : $result;
+		});
+	}
+
+	/**
+	 * Get an array with the values of a given key.
+	 *
+	 * @param string      $value
+	 * @param string|null $key
+	 *
+	 * @return self
+	 */
+	public function pluck($value, $key = null)
+	{
+		return new Collection(Arr::pluck($this->items, $value, $key));
+	}
+
+	/**
+	 * Alias for the "pluck" method.
+	 *
+	 * @param string      $value
+	 * @param string|null $key
+	 *
+	 * @return self
+	 */
+	public function lists($value, $key = null)
+	{
+		return $this->pluck($value, $key);
+	}
+
+	/**
+	 * Return only unique items from the collection.
+	 *
+	 * @param string|null $key
+	 * @param bool        $strict
+	 *
+	 * @throws MappingException
+	 *
+	 * @return self
+	 */
+	public function unique($key = null, $strict = false)
+	{
+		$dictionary = $this->getDictionary();
+
+		return new static(array_values($dictionary));
+	}
+
+	/**
+	 * Get a base Support collection instance from this collection.
+	 *
+	 * @return \Illuminate\Support\Collection
+	 */
+	public function toBase()
+	{
+		return new Collection($this->items);
+	}
+
+	public function toArray()
+	{
+		return array_values(parent::toArray());
+	}
+
+	/**
+	 * Get the collection of items as JSON.
+	 *
+	 * @param int $options
+	 *
+	 * @return string
+	 */
+	public function toJson($options = 0)
+	{
+		$collection = new Collection(array_values($this->items));
+
+		return $collection->toJson($options);
+	}
 }

src/Plugins/Timestamps/TimestampsPlugin.php

Indentation +41 added lines, -41 removed lines

@@ -11,54 +11,54 @@
  */
 class TimestampsPlugin extends AnaloguePlugin
 {
-    /**
-     * Register the plugin.
-     *
-     * @throws \Exception
-     *
-     * @return void
-     */
-    public function register()
-    {
-        $this->manager->registerGlobalEvent('initialized', function ($event, $payload) {
-            $mapper = $payload[0];
-            $entityMap = $mapper->getEntityMap();
+	/**
+	 * Register the plugin.
+	 *
+	 * @throws \Exception
+	 *
+	 * @return void
+	 */
+	public function register()
+	{
+		$this->manager->registerGlobalEvent('initialized', function ($event, $payload) {
+			$mapper = $payload[0];
+			$entityMap = $mapper->getEntityMap();
 
-            if ($entityMap->usesTimestamps()) {
-                $mapper->registerEvent('creating', function ($entity) use ($entityMap) {
-                    $factory = new Factory();
-                    $wrappedEntity = $factory->make($entity);
+			if ($entityMap->usesTimestamps()) {
+				$mapper->registerEvent('creating', function ($entity) use ($entityMap) {
+					$factory = new Factory();
+					$wrappedEntity = $factory->make($entity);
 
-                    $createdAtField = $entityMap->getCreatedAtColumn();
-                    $updatedAtField = $entityMap->getUpdatedAtColumn();
+					$createdAtField = $entityMap->getCreatedAtColumn();
+					$updatedAtField = $entityMap->getUpdatedAtColumn();
 
-                    $time = new Carbon();
+					$time = new Carbon();
 
-                    $wrappedEntity->setEntityAttribute($createdAtField, $time);
-                    $wrappedEntity->setEntityAttribute($updatedAtField, $time);
-                });
+					$wrappedEntity->setEntityAttribute($createdAtField, $time);
+					$wrappedEntity->setEntityAttribute($updatedAtField, $time);
+				});
 
-                $mapper->registerEvent('updating', function ($entity) use ($entityMap) {
-                    $factory = new Factory();
-                    $wrappedEntity = $factory->make($entity);
+				$mapper->registerEvent('updating', function ($entity) use ($entityMap) {
+					$factory = new Factory();
+					$wrappedEntity = $factory->make($entity);
 
-                    $updatedAtField = $entityMap->getUpdatedAtColumn();
+					$updatedAtField = $entityMap->getUpdatedAtColumn();
 
-                    $time = new Carbon();
+					$time = new Carbon();
 
-                    $wrappedEntity->setEntityAttribute($updatedAtField, $time);
-                });
-            }
-        });
-    }
+					$wrappedEntity->setEntityAttribute($updatedAtField, $time);
+				});
+			}
+		});
+	}
 
-    /**
-     * Get custom events provided by the plugin.
-     *
-     * @return array
-     */
-    public function getCustomEvents()
-    {
-        return [];
-    }
+	/**
+	 * Get custom events provided by the plugin.
+	 *
+	 * @return array
+	 */
+	public function getCustomEvents()
+	{
+		return [];
+	}
 }

Spacing +3 added lines, -3 removed lines

@@ -20,12 +20,12 @@ 
      */
     public function register()
     {
-        $this->manager->registerGlobalEvent('initialized', function ($event, $payload) {
+        $this->manager->registerGlobalEvent('initialized', function($event, $payload) {
             $mapper = $payload[0];
             $entityMap = $mapper->getEntityMap();
 
             if ($entityMap->usesTimestamps()) {
-                $mapper->registerEvent('creating', function ($entity) use ($entityMap) {
+                $mapper->registerEvent('creating', function($entity) use ($entityMap) {
                     $factory = new Factory();
                     $wrappedEntity = $factory->make($entity);
 
@@ -38,7 +38,7 @@ 
                     $wrappedEntity->setEntityAttribute($updatedAtField, $time);
                 });
 
-                $mapper->registerEvent('updating', function ($entity) use ($entityMap) {
+                $mapper->registerEvent('updating', function($entity) use ($entityMap) {
                     $factory = new Factory();
                     $wrappedEntity = $factory->make($entity);
 

src/Plugins/SoftDeletes/SoftDeletesPlugin.php

Indentation +78 added lines, -78 removed lines

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

Spacing +2 added lines, -2 removed lines

@@ -25,7 +25,7 @@ 
         $host = $this;
 
         // Hook any mapper init and check the mapping include soft deletes.
-        $this->manager->registerGlobalEvent('initialized', function ($event, $payload) use ($host) {
+        $this->manager->registerGlobalEvent('initialized', function($event, $payload) use ($host) {
             $mapper = $payload[0];
             $entityMap = $mapper->getEntityMap();
 
@@ -55,7 +55,7 @@ 
         $host = $this;
 
         // Register 'deleting' events
-        $mapper->registerEvent('deleting', function ($entity) use ($entityMap, $host) {
+        $mapper->registerEvent('deleting', function($entity) use ($entityMap, $host) {
 
             // Convert Entity into an EntityWrapper
             $factory = new Factory();

src/EntityMap.php

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()
-    {
-        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()
+	{
+		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]);
+	}
 }