analogueorm / analogue

src/MagicSetters.php

Indentation +21 added lines, -21 removed lines

@@ -7,28 +7,28 @@
  */
 trait MagicSetters
 {
-    /**
-     * Dynamically set attributes on the entity.
-     *
-     * @param  string $key
-     * @param  mixed  $value
-     * @return void
-     */
-    public function __set($key, $value)
-    {
-        $this->attributes[$key] = $value;
-    }
+	/**
+	 * Dynamically set attributes on the entity.
+	 *
+	 * @param  string $key
+	 * @param  mixed  $value
+	 * @return void
+	 */
+	public function __set($key, $value)
+	{
+		$this->attributes[$key] = $value;
+	}
 
-    /**
-     * Unset an attribute on the entity.
-     *
-     * @param  string $key
-     * @return void
-     */
-    public function __unset($key)
-    {
-        unset($this->attributes[$key]);
-    }
+	/**
+	 * Unset an attribute on the entity.
+	 *
+	 * @param  string $key
+	 * @return void
+	 */
+	public function __unset($key)
+	{
+		unset($this->attributes[$key]);
+	}
 
 
 }
\ No newline at end of file

src/Commands/Store.php

Indentation +221 added lines, -221 removed lines

@@ -14,238 +14,238 @@
  */
 class Store extends Command
 {
-    /**
-     * Persist the entity in the database
-     *
-     * @throws \InvalidArgumentException
-     * @return false|mixed
-     */
-    public function execute()
-    {
-        $entity = $this->aggregate->getEntityObject();
-
-        $mapper = $this->aggregate->getMapper();
-
-        if ($mapper->fireEvent('storing', $entity) === false) {
-            return false;
-        }
-
-        $this->preStoreProcess();
-
-        /**
-         * We will test the entity for existence
-         * and run a creation if it doesn't exists
-         */
-        if (!$this->aggregate->exists()) {
-            if ($mapper->fireEvent('creating', $entity) === false) {
-                return false;
-            }
-
-            $this->insert();
-
-            $mapper->fireEvent('created', $entity, false);
-        }
-        else if ($this->aggregate->isDirty()) {
-            if ($mapper->fireEvent('updating', $entity) === false) {
-                return false;
-            }
-            $this->update();
-
-            $mapper->fireEvent('updated', $entity, false);
-        }
-
-        $this->postStoreProcess();
-
-        $mapper->fireEvent('stored', $entity, false);
-
-        return $entity;
-    }
-
-    /**
-     * Run all operations that have to occur before actually
-     * storing the entity
-     *
-     * @throws \InvalidArgumentException
-     * @return void
-     */
-    protected function preStoreProcess()
-    {
-        // Create any related object that doesn't exist in the database.
-        $localRelationships = $this->aggregate->getEntityMap()->getLocalRelationships();
-
-        $this->createRelatedEntities($localRelationships);
-
-        // Now we can sync the related collections
-        $this->aggregate->syncRelationships($localRelationships);
-    }
-
-    /**
-     * Check for existence and create non-existing related entities
-     *
-     * @param  array
-     * @throws \InvalidArgumentException
-     * @return void
-     */
-    protected function createRelatedEntities($relations)
-    {
-        $entitiesToCreate = $this->aggregate->getNonExistingRelated($relations);
-
-        foreach ($entitiesToCreate as $aggregate) {
-            $this->createStoreCommand($aggregate)->execute();
-        }
+	/**
+	 * Persist the entity in the database
+	 *
+	 * @throws \InvalidArgumentException
+	 * @return false|mixed
+	 */
+	public function execute()
+	{
+		$entity = $this->aggregate->getEntityObject();
+
+		$mapper = $this->aggregate->getMapper();
+
+		if ($mapper->fireEvent('storing', $entity) === false) {
+			return false;
+		}
+
+		$this->preStoreProcess();
+
+		/**
+		 * We will test the entity for existence
+		 * and run a creation if it doesn't exists
+		 */
+		if (!$this->aggregate->exists()) {
+			if ($mapper->fireEvent('creating', $entity) === false) {
+				return false;
+			}
+
+			$this->insert();
+
+			$mapper->fireEvent('created', $entity, false);
+		}
+		else if ($this->aggregate->isDirty()) {
+			if ($mapper->fireEvent('updating', $entity) === false) {
+				return false;
+			}
+			$this->update();
+
+			$mapper->fireEvent('updated', $entity, false);
+		}
+
+		$this->postStoreProcess();
+
+		$mapper->fireEvent('stored', $entity, false);
+
+		return $entity;
+	}
+
+	/**
+	 * Run all operations that have to occur before actually
+	 * storing the entity
+	 *
+	 * @throws \InvalidArgumentException
+	 * @return void
+	 */
+	protected function preStoreProcess()
+	{
+		// Create any related object that doesn't exist in the database.
+		$localRelationships = $this->aggregate->getEntityMap()->getLocalRelationships();
+
+		$this->createRelatedEntities($localRelationships);
+
+		// Now we can sync the related collections
+		$this->aggregate->syncRelationships($localRelationships);
+	}
+
+	/**
+	 * Check for existence and create non-existing related entities
+	 *
+	 * @param  array
+	 * @throws \InvalidArgumentException
+	 * @return void
+	 */
+	protected function createRelatedEntities($relations)
+	{
+		$entitiesToCreate = $this->aggregate->getNonExistingRelated($relations);
+
+		foreach ($entitiesToCreate as $aggregate) {
+			$this->createStoreCommand($aggregate)->execute();
+		}
         
-    }
-
-    /**
-     * Create a new store command
-     *
-     * @param  Aggregate $aggregate
-     * @return Store
-     */
-    protected function createStoreCommand(Aggregate $aggregate)
-    {
-        // We gotta retrieve the corresponding query adapter to use.
-        $mapper = $aggregate->getMapper();
-
-        return new Store($aggregate, $mapper->newQueryBuilder());
-    }
-
-    /**
-     * Run all operations that have to occur after the entity
-     * is stored.
-     *
-     * @throws \InvalidArgumentException
-     * @return void
-     */
-    protected function postStoreProcess()
-    {
-        $aggregate = $this->aggregate;
-
-        // Create any related object that doesn't exist in the database.
-        $foreignRelationships = $aggregate->getEntityMap()->getForeignRelationships();
-
-        $this->createRelatedEntities($foreignRelationships);
-
-        // Update any pivot tables that has been modified.
-        $aggregate->updatePivotRecords();
-
-        // Update any dirty relationship. This include relationships that already exists, have
-        // dirty attributes / newly created related entities / dirty related entities.
-        $dirtyRelatedAggregates = $aggregate->getDirtyRelationships();
+	}
+
+	/**
+	 * Create a new store command
+	 *
+	 * @param  Aggregate $aggregate
+	 * @return Store
+	 */
+	protected function createStoreCommand(Aggregate $aggregate)
+	{
+		// We gotta retrieve the corresponding query adapter to use.
+		$mapper = $aggregate->getMapper();
+
+		return new Store($aggregate, $mapper->newQueryBuilder());
+	}
+
+	/**
+	 * Run all operations that have to occur after the entity
+	 * is stored.
+	 *
+	 * @throws \InvalidArgumentException
+	 * @return void
+	 */
+	protected function postStoreProcess()
+	{
+		$aggregate = $this->aggregate;
+
+		// Create any related object that doesn't exist in the database.
+		$foreignRelationships = $aggregate->getEntityMap()->getForeignRelationships();
+
+		$this->createRelatedEntities($foreignRelationships);
+
+		// Update any pivot tables that has been modified.
+		$aggregate->updatePivotRecords();
+
+		// Update any dirty relationship. This include relationships that already exists, have
+		// dirty attributes / newly created related entities / dirty related entities.
+		$dirtyRelatedAggregates = $aggregate->getDirtyRelationships();
         
-        foreach ($dirtyRelatedAggregates as $related) {
-            $this->createStoreCommand($related)->execute();
-        }
-
-        // Now we can sync the related collections
-        if ($this->aggregate->exists()) {
-            $this->aggregate->syncRelationships($foreignRelationships);
-        }
+		foreach ($dirtyRelatedAggregates as $related) {
+			$this->createStoreCommand($related)->execute();
+		}
+
+		// Now we can sync the related collections
+		if ($this->aggregate->exists()) {
+			$this->aggregate->syncRelationships($foreignRelationships);
+		}
         
-        // TODO be move it to the wrapper class
-        // so it's the same code for the entity builder
-        $aggregate->setProxies();
-
-        // Update Entity Cache
-        $aggregate->getMapper()->getEntityCache()->refresh($aggregate);
-    }
-
-    /**
-     * Update Related Entities which attributes have
-     * been modified.
-     *
-     * @return void
-     */
-    protected function updateDirtyRelated()
-    {
-        $relations = $this->entityMap->getRelationships();
-        $attributes = $this->getAttributes();
-
-        foreach ($relations as $relation) {
-            if (!array_key_exists($relation, $attributes)) {
-                continue;
-            }
-
-            $value = $attributes[$relation];
-
-            if ($value == null) {
-                continue;
-            }
-
-            if ($value instanceof EntityProxy) {
-                continue;
-            }
-
-            if ($value instanceof CollectionProxy && $value->isLoaded()) {
-                $value = $value->getUnderlyingCollection();
-            }
-            if ($value instanceof CollectionProxy && !$value->isLoaded()) {
-                foreach ($value->getAddedItems() as $entity) {
-                    $this->updateEntityIfDirty($entity);
-                }
-                continue;
-            }
-
-            if ($value instanceof EntityCollection) {
-                foreach ($value as $entity) {
-                    if (!$this->createEntityIfNotExists($entity)) {
-                        $this->updateEntityIfDirty($entity);
-                    }
-                }
-                continue;
-            }
-            if ($value instanceof Mappable) {
-                $this->updateEntityIfDirty($value);
-                continue;
-            }
-        }
-    }
-
-    /**
-     * Execute an insert statement on the database
-     *
-     * @return void
-     */
-    protected function insert()
-    {
-        $aggregate = $this->aggregate;
-
-        $attributes = $aggregate->getRawAttributes();
+		// TODO be move it to the wrapper class
+		// so it's the same code for the entity builder
+		$aggregate->setProxies();
+
+		// Update Entity Cache
+		$aggregate->getMapper()->getEntityCache()->refresh($aggregate);
+	}
+
+	/**
+	 * Update Related Entities which attributes have
+	 * been modified.
+	 *
+	 * @return void
+	 */
+	protected function updateDirtyRelated()
+	{
+		$relations = $this->entityMap->getRelationships();
+		$attributes = $this->getAttributes();
+
+		foreach ($relations as $relation) {
+			if (!array_key_exists($relation, $attributes)) {
+				continue;
+			}
+
+			$value = $attributes[$relation];
+
+			if ($value == null) {
+				continue;
+			}
+
+			if ($value instanceof EntityProxy) {
+				continue;
+			}
+
+			if ($value instanceof CollectionProxy && $value->isLoaded()) {
+				$value = $value->getUnderlyingCollection();
+			}
+			if ($value instanceof CollectionProxy && !$value->isLoaded()) {
+				foreach ($value->getAddedItems() as $entity) {
+					$this->updateEntityIfDirty($entity);
+				}
+				continue;
+			}
+
+			if ($value instanceof EntityCollection) {
+				foreach ($value as $entity) {
+					if (!$this->createEntityIfNotExists($entity)) {
+						$this->updateEntityIfDirty($entity);
+					}
+				}
+				continue;
+			}
+			if ($value instanceof Mappable) {
+				$this->updateEntityIfDirty($value);
+				continue;
+			}
+		}
+	}
+
+	/**
+	 * Execute an insert statement on the database
+	 *
+	 * @return void
+	 */
+	protected function insert()
+	{
+		$aggregate = $this->aggregate;
+
+		$attributes = $aggregate->getRawAttributes();
         
-        $keyName = $aggregate->getEntityMap()->getKeyName();
+		$keyName = $aggregate->getEntityMap()->getKeyName();
 
-        // Check if the primary key is defined in the attributes
-        if (array_key_exists($keyName, $attributes) && $attributes[$keyName] != null) {
-            $this->query->insert($attributes);
-        } else {
-            $sequence = $aggregate->getEntityMap()->getSequence();
+		// Check if the primary key is defined in the attributes
+		if (array_key_exists($keyName, $attributes) && $attributes[$keyName] != null) {
+			$this->query->insert($attributes);
+		} else {
+			$sequence = $aggregate->getEntityMap()->getSequence();
 
-            $id = $this->query->insertGetId($attributes, $sequence);
+			$id = $this->query->insertGetId($attributes, $sequence);
 
-            $aggregate->setEntityAttribute($keyName, $id);
-        }
+			$aggregate->setEntityAttribute($keyName, $id);
+		}
 
-    }
+	}
 
-    /**
-     * Run an update statement on the entity
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    protected function update()
-    {
-        $query = $this->query;
+	/**
+	 * Run an update statement on the entity
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return void
+	 */
+	protected function update()
+	{
+		$query = $this->query;
 
-        $keyName = $this->aggregate->getEntityKey();
+		$keyName = $this->aggregate->getEntityKey();
 
-        $query = $query->where($keyName, '=', $this->aggregate->getEntityId());
+		$query = $query->where($keyName, '=', $this->aggregate->getEntityId());
 
-        $dirtyAttributes = $this->aggregate->getDirtyRawAttributes();
+		$dirtyAttributes = $this->aggregate->getDirtyRawAttributes();
 
-        if (count($dirtyAttributes) > 0) {
-            $query->update($dirtyAttributes);
-        }
-    }
+		if (count($dirtyAttributes) > 0) {
+			$query->update($dirtyAttributes);
+		}
+	}
 }

src/MagicGetters.php

Indentation +39 added lines, -39 removed lines

@@ -12,48 +12,48 @@
 	protected $attributes = [];
 
 	/**
-     * Dynamically retrieve attributes on the entity.
-     *
-     * @param  string $key
-     * @return mixed
-     */
-    public function __get($key)
-    {
-    	// When using mixed mapping, we will check
-    	// for a class property corresponding to 
-    	// the attribute's key first. 
-    	// 
-    	// Note : this may raise issues as we may grant
-    	// access to unwanted properties, like class dependencies. 
-    	// 
-    	// -> Solution would be to access the entityMap's $attributes, but we
-    	// have to do this in a very efficient way.
-    	// 
-    	// Manager::getEntityMap(get_class($this))->hasProperty()
-    	// 
-    	// We could do the casting to array / json the same way, and it would 
+	 * Dynamically retrieve attributes on the entity.
+	 *
+	 * @param  string $key
+	 * @return mixed
+	 */
+	public function __get($key)
+	{
+		// When using mixed mapping, we will check
+		// for a class property corresponding to 
+		// the attribute's key first. 
+		// 
+		// Note : this may raise issues as we may grant
+		// access to unwanted properties, like class dependencies. 
+		// 
+		// -> Solution would be to access the entityMap's $attributes, but we
+		// have to do this in a very efficient way.
+		// 
+		// Manager::getEntityMap(get_class($this))->hasProperty()
+		// 
+		// We could do the casting to array / json the same way, and it would 
     	
 
-    	if(property_exists($this, $key)) {
-    		return $this->$key;
-    	}
+		if(property_exists($this, $key)) {
+			return $this->$key;
+		}
 
-    	if(array_key_exists($key, $this->attributes))
-    	{
-        	return $this->attributes[$key];
-        }
+		if(array_key_exists($key, $this->attributes))
+		{
+			return $this->attributes[$key];
+		}
 
-        return null;
-    }
+		return null;
+	}
 
-    /**
-     * Determine if an attribute exists on the entity.
-     *
-     * @param  string $key
-     * @return bool
-     */
-    public function __isset($key)
-    {
-        return array_key_exists($key, $this->attributes) || property_exists($this, $key);
-    }
+	/**
+	 * Determine if an attribute exists on the entity.
+	 *
+	 * @param  string $key
+	 * @return bool
+	 */
+	public function __isset($key)
+	{
+		return array_key_exists($key, $this->attributes) || property_exists($this, $key);
+	}
 }
\ No newline at end of file

src/EntityMap.php

Indentation +1279 added lines, -1279 removed lines

@@ -23,1286 +23,1286 @@
  */
 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
-     * 
-     * @var string
-     */
-    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 boolean
-     */
-    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 boolean
-     */
-    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()
-    {
-        return $this->attributes;
-    }
-
-    /**
-     * Set the domain class attributes
-     *
-     * @param array $attributeNames
-     */
-    public function setAttributes(array $attributeNames)
-    {
-        $this->attributes = $attributeNames;
-    }
-
-    /**
-     * Get all the attribute names for the class, including relationships, embeddables and primary key.
-     *
-     * @return array
-     */
-    public function getCompiledAttributes()
-    {
-        $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()
-    {
-        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()
-    {
-        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
-     */
-    public function getConnection()
-    {
-        return $this->connection;
-    }
-
-    /**
-     * Get the table associated with the entity.
-     *
-     * @return string
-     */
-    public function getTable()
-    {
-        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()
-    {
-        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()
-    {
-        return $this->embeddables;
-    }
-
-    /**
-     * 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()
-    {
-        return $this->relationships;
-    }
-
-    /**  
-     * Get the relationships that will not have a proxy
-     * set on them
-     * 
-     * @return array
-     */
-    public function getRelationshipsWithoutProxy()
-    {
-        return $this->nonProxyRelationships;
-    }
-
-    /**
-     * Relationships of the Entity type
-     *
-     * @return array
-     */
-    public function getSingleRelationships()
-    {
-        return $this->singleRelations;
-    }
-
-    /**
-     * Relationships of type Collection
-     *
-     * @return array
-     */
-    public function getManyRelationships()
-    {
-        return $this->manyRelations;
-    }
-
-    /**
-     * Relationships with foreign key in the mapped entity record.
-     *
-     * @return array
-     */
-    public function getLocalRelationships()
-    {
-        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()
-    {
-        return $this->foreignRelations;
-    }
-
-    /**
-     * Relationships which keys are stored in a pivot record
-     *
-     * @return array
-     */
-    public function getPivotRelationships()
-    {
-        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()
-    {
-        return array_keys($this->dynamicRelationships);
-    }
-
-    /**
-     * Get the relationships that have to be eager loaded
-     * on each request.
-     *
-     * @return array
-     */
-    public function getEagerloadedRelationships()
-    {
-        return $this->with;
-    }
-
-    /**
-     * Get the primary key for the entity.
-     *
-     * @return string
-     */
-    public function getKeyName()
-    {
-        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()
-    {
-        return $this->getTable() . '.' . $this->getKeyName();
-    }
-
-    /**
-     * Get the number of models to return per page.
-     *
-     * @return int
-     */
-    public function getPerPage()
-    {
-        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()
-    {
-        return $this->timestamps;
-    }
-
-    /**
-     * Determine if the entity uses soft deletes
-     *
-     * @return bool
-     */
-    public function usesSoftDeletes()
-    {
-        return $this->softDeletes;
-    }
-
-    /**
-     * Get the 'created_at' column name
-     *
-     * @return string
-     */
-    public function getCreatedAtColumn()
-    {
-        return $this->createdAtColumn;
-    }
-
-    /**
-     * Get the 'updated_at' column name
-     *
-     * @return string
-     */
-    public function getUpdatedAtColumn()
-    {
-        return $this->updatedAtColumn;
-    }
-
-    /**
-     * Get the deleted_at column
-     *
-     * @return string
-     */
-    public function getQualifiedDeletedAtColumn()
-    {
-        return $this->deletedAtColumn;
-    }
-
-    /**
-     * Get the default foreign key name for the model.
-     *
-     * @return string
-     */
-    public function getForeignKey()
-    {
-        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()
-    {
-        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()
-    {
-        return $this->discriminatorColumnMap;
-    }
-
-    /**
-     * Return true if the entity should be instanciated using
-     * the IoC Container
-     * 
-     * @return boolean
-     */
-    public function useDependencyInjection()
-    {
-        return $this->dependencyInjection;
-    }
-
-    /**
-     * 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->singleRelations[] = $relation;
-        $this->foreignRelations[] = $relation;
-        $this->nonProxyRelationships[] = $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->singleRelations[] = $relation;
-        $this->foreignRelations[] = $relation;
-        $this->nonProxyRelationships[] = $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;
-        }
+	/**
+	 * 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
+	 * 
+	 * @var string
+	 */
+	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 boolean
+	 */
+	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 boolean
+	 */
+	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()
+	{
+		return $this->attributes;
+	}
+
+	/**
+	 * Set the domain class attributes
+	 *
+	 * @param array $attributeNames
+	 */
+	public function setAttributes(array $attributeNames)
+	{
+		$this->attributes = $attributeNames;
+	}
+
+	/**
+	 * Get all the attribute names for the class, including relationships, embeddables and primary key.
+	 *
+	 * @return array
+	 */
+	public function getCompiledAttributes()
+	{
+		$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()
+	{
+		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()
+	{
+		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
+	 */
+	public function getConnection()
+	{
+		return $this->connection;
+	}
+
+	/**
+	 * Get the table associated with the entity.
+	 *
+	 * @return string
+	 */
+	public function getTable()
+	{
+		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()
+	{
+		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()
+	{
+		return $this->embeddables;
+	}
+
+	/**
+	 * 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()
+	{
+		return $this->relationships;
+	}
+
+	/**  
+	 * Get the relationships that will not have a proxy
+	 * set on them
+	 * 
+	 * @return array
+	 */
+	public function getRelationshipsWithoutProxy()
+	{
+		return $this->nonProxyRelationships;
+	}
+
+	/**
+	 * Relationships of the Entity type
+	 *
+	 * @return array
+	 */
+	public function getSingleRelationships()
+	{
+		return $this->singleRelations;
+	}
+
+	/**
+	 * Relationships of type Collection
+	 *
+	 * @return array
+	 */
+	public function getManyRelationships()
+	{
+		return $this->manyRelations;
+	}
+
+	/**
+	 * Relationships with foreign key in the mapped entity record.
+	 *
+	 * @return array
+	 */
+	public function getLocalRelationships()
+	{
+		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()
+	{
+		return $this->foreignRelations;
+	}
+
+	/**
+	 * Relationships which keys are stored in a pivot record
+	 *
+	 * @return array
+	 */
+	public function getPivotRelationships()
+	{
+		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()
+	{
+		return array_keys($this->dynamicRelationships);
+	}
+
+	/**
+	 * Get the relationships that have to be eager loaded
+	 * on each request.
+	 *
+	 * @return array
+	 */
+	public function getEagerloadedRelationships()
+	{
+		return $this->with;
+	}
+
+	/**
+	 * Get the primary key for the entity.
+	 *
+	 * @return string
+	 */
+	public function getKeyName()
+	{
+		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()
+	{
+		return $this->getTable() . '.' . $this->getKeyName();
+	}
+
+	/**
+	 * Get the number of models to return per page.
+	 *
+	 * @return int
+	 */
+	public function getPerPage()
+	{
+		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()
+	{
+		return $this->timestamps;
+	}
+
+	/**
+	 * Determine if the entity uses soft deletes
+	 *
+	 * @return bool
+	 */
+	public function usesSoftDeletes()
+	{
+		return $this->softDeletes;
+	}
+
+	/**
+	 * Get the 'created_at' column name
+	 *
+	 * @return string
+	 */
+	public function getCreatedAtColumn()
+	{
+		return $this->createdAtColumn;
+	}
+
+	/**
+	 * Get the 'updated_at' column name
+	 *
+	 * @return string
+	 */
+	public function getUpdatedAtColumn()
+	{
+		return $this->updatedAtColumn;
+	}
+
+	/**
+	 * Get the deleted_at column
+	 *
+	 * @return string
+	 */
+	public function getQualifiedDeletedAtColumn()
+	{
+		return $this->deletedAtColumn;
+	}
+
+	/**
+	 * Get the default foreign key name for the model.
+	 *
+	 * @return string
+	 */
+	public function getForeignKey()
+	{
+		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()
+	{
+		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()
+	{
+		return $this->discriminatorColumnMap;
+	}
+
+	/**
+	 * Return true if the entity should be instanciated using
+	 * the IoC Container
+	 * 
+	 * @return boolean
+	 */
+	public function useDependencyInjection()
+	{
+		return $this->dependencyInjection;
+	}
+
+	/**
+	 * 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->singleRelations[] = $relation;
+		$this->foreignRelations[] = $relation;
+		$this->nonProxyRelationships[] = $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->singleRelations[] = $relation;
+		$this->foreignRelations[] = $relation;
+		$this->nonProxyRelationships[] = $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->singleRelations[] = $relation;
-        $this->localRelations[] = $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->singleRelations[] = $name;
-        $this->localRelations[] = $relation;
-        $this->foreignRelations[] = $relation;
-        $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
-        ];
+		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->singleRelations[] = $relation;
+		$this->localRelations[] = $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->singleRelations[] = $name;
+		$this->localRelations[] = $relation;
+		$this->foreignRelations[] = $relation;
+		$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->manyRelations[] = $relation;
-        $this->foreignRelations[] = $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->manyRelations[] = $relation;
-        $this->foreignRelations[] = $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->manyRelations[] = $relation;
-        $this->foreignRelations[] = $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->manyRelations[] = $relation;
-        $this->foreignRelations[] = $relation;
-        $this->pivotRelations[] = $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->manyRelations[] = $relation;
-        $this->foreignRelations[] = $relation;
-        $this->pivotRelations[] = $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->manyRelations[] = $relation;
-        $this->foreignRelations[] = $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()
-    {
-        return null;
-    }
-
-    /**
-     * Call dynamic relationship, if it exists
-     *
-     * @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]);
-    }
+		$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->manyRelations[] = $relation;
+		$this->foreignRelations[] = $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->manyRelations[] = $relation;
+		$this->foreignRelations[] = $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->manyRelations[] = $relation;
+		$this->foreignRelations[] = $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->manyRelations[] = $relation;
+		$this->foreignRelations[] = $relation;
+		$this->pivotRelations[] = $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->manyRelations[] = $relation;
+		$this->foreignRelations[] = $relation;
+		$this->pivotRelations[] = $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->manyRelations[] = $relation;
+		$this->foreignRelations[] = $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()
+	{
+		return null;
+	}
+
+	/**
+	 * Call dynamic relationship, if it exists
+	 *
+	 * @param  string $method
+	 * @param  array  $parameters
+	 * @throws Exception
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		if (!array_key_exists($method, $this->dynamicRelationships)) {
+			throw new Exception(get_class($this) . " has no method $method");
+		}
+
+		// Add $this to parameters so the closure can call relationship method on the map.
+		$parameters[] = $this;
+
+		return  call_user_func_array([$this->dynamicRelationships[$method], $parameters]);
+	}
 }

src/MagicCasting.php

Indentation +95 added lines, -95 removed lines

@@ -10,109 +10,109 @@
 {
 
  	/**
-     * Determine if the given attribute exists.
-     *
-     * @param  mixed $offset
-     * @return bool
-     */
-    public function offsetExists($offset)
-    {
-        return isset($this->$offset);
-    }
+ 	 * Determine if the given attribute exists.
+ 	 *
+ 	 * @param  mixed $offset
+ 	 * @return bool
+ 	 */
+	public function offsetExists($offset)
+	{
+		return isset($this->$offset);
+	}
 
-    /**
-     * Get the value for a given offset.
-     *
-     * @param  mixed $offset
-     * @return mixed
-     */
-    public function offsetGet($offset)
-    {
-        return $this->$offset;
-    }
+	/**
+	 * Get the value for a given offset.
+	 *
+	 * @param  mixed $offset
+	 * @return mixed
+	 */
+	public function offsetGet($offset)
+	{
+		return $this->$offset;
+	}
 
-    /**
-     * Set the value for a given offset.
-     *
-     * @param  mixed $offset
-     * @param  mixed $value
-     * @return void
-     */
-    public function offsetSet($offset, $value)
-    {
-        $this->$offset = $value;
-    }
+	/**
+	 * Set the value for a given offset.
+	 *
+	 * @param  mixed $offset
+	 * @param  mixed $value
+	 * @return void
+	 */
+	public function offsetSet($offset, $value)
+	{
+		$this->$offset = $value;
+	}
 
-    /**
-     * Unset the value for a given offset.
-     *
-     * @param  mixed $offset
-     * @return void
-     */
-    public function offsetUnset($offset)
-    {
-        unset($this->$offset);
-    }
+	/**
+	 * Unset the value for a given offset.
+	 *
+	 * @param  mixed $offset
+	 * @return void
+	 */
+	public function offsetUnset($offset)
+	{
+		unset($this->$offset);
+	}
 
-    /**
-     * Convert the object into something JSON serializable.
-     *
-     * @return array
-     */
-    public function jsonSerialize()
-    {
-        return $this->toArray();
-    }
+	/**
+	 * Convert the object into something JSON serializable.
+	 *
+	 * @return array
+	 */
+	public function jsonSerialize()
+	{
+		return $this->toArray();
+	}
 
-    /**
-     * Convert the entity instance to JSON.
-     *
-     * @param  int $options
-     * @return string
-     */
-    public function toJson($options = 0)
-    {
-        return json_encode($this->toArray(), $options);
-    }
+	/**
+	 * Convert the entity instance to JSON.
+	 *
+	 * @param  int $options
+	 * @return string
+	 */
+	public function toJson($options = 0)
+	{
+		return json_encode($this->toArray(), $options);
+	}
 
-    /**
-     * Convert Mappable object to array;
-     *
-     * @return array
-     */
-    public function toArray()
-    {
-        return $this->attributesToArray($this->attributes);
-    }
+	/**
+	 * Convert Mappable object to array;
+	 *
+	 * @return array
+	 */
+	public function toArray()
+	{
+		return $this->attributesToArray($this->attributes);
+	}
 
-    /**
-     * Transform the Object to array/json,
-     *
-     * @param  array $sourceAttributes
-     * @return array
-     */
-    protected function attributesToArray(array $sourceAttributes)
-    {
-        $attributes = [];
+	/**
+	 * Transform the Object to array/json,
+	 *
+	 * @param  array $sourceAttributes
+	 * @return array
+	 */
+	protected function attributesToArray(array $sourceAttributes)
+	{
+		$attributes = [];
 
-        foreach ($sourceAttributes as $key => $attribute) {
-            // If the attribute is a proxy, and hasn't be loaded, we discard
-            // it from the returned set.
-            if ($attribute instanceof ProxyInterface && !$attribute->isProxyInitialized()) {
-                continue;
-            }
+		foreach ($sourceAttributes as $key => $attribute) {
+			// If the attribute is a proxy, and hasn't be loaded, we discard
+			// it from the returned set.
+			if ($attribute instanceof ProxyInterface && !$attribute->isProxyInitialized()) {
+				continue;
+			}
 
-            if ($attribute instanceof Carbon) {
-                $attributes[$key] = $attribute->__toString();
-                continue;
-            }
+			if ($attribute instanceof Carbon) {
+				$attributes[$key] = $attribute->__toString();
+				continue;
+			}
 
-            if ($attribute instanceof Arrayable) {
-                $attributes[$key] = $attribute->toArray();
-            } else {
-                $attributes[$key] = $attribute;
-            }
-        }
-        return $attributes;
-    }
+			if ($attribute instanceof Arrayable) {
+				$attributes[$key] = $attribute->toArray();
+			} else {
+				$attributes[$key] = $attribute;
+			}
+		}
+		return $attributes;
+	}
 }

src/ValueObject.php

Indentation +4 added lines, -4 removed lines

@@ -9,9 +9,9 @@
 
 class ValueObject implements Mappable, ArrayAccess, Jsonable, JsonSerializable, Arrayable
 {
-    use MappableTrait;
-    use MagicGetters;
-    use MagicSetters;
-    use MagicCasting;
+	use MappableTrait;
+	use MagicGetters;
+	use MagicSetters;
+	use MagicCasting;
 }
 

src/System/EntityBuilder.php

Indentation +185 added lines, -185 removed lines

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

src/System/Wrappers/Wrapper.php

Indentation +175 added lines, -175 removed lines

@@ -11,180 +11,180 @@
  */
 abstract class Wrapper implements InternallyMappable
 {
-    /**
-     * Original Entity Object
-     *
-     * @var mixed
-     */
-    protected $entity;
-
-    /**
-     * Corresponding EntityMap
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * @var \Analogue\ORM\System\Proxirs\ProxyFactory
-     */
-    protected $proxyFactory;
-
-    /**
-     * Wrapper constructor.
-     * @param $entity
-     * @param $entityMap
-     */
-    public function __construct($entity, $entityMap)
-    {
-        $this->entity = $entity;
-        $this->entityMap = $entityMap;
-        $this->proxyFactory = new ProxyFactory;
-    }
-
-    /**
-     * Return the wrapped entity class
-     *
-     * @return mixed
-     */
-    public function getEntityClass()
-    {
-        return get_class($this->entity);
-    }
-
-    /**
-     * Returns the wrapped entity
-     *
-     * @return mixed
-     */
-    public function getObject()
-    {
-        return $this->entity;
-    }
-
-    /**
-     * Returns the wrapped entity's map
-     *
-     * @return mixed
-     */
-    public function getMap()
-    {
-        return $this->entityMap;
-    }
-
-    /**
-     * Set the lazyloading proxies on the wrapped entity objet
-     * 
-     * @param  array  $relations  list of relations to be lazy loaded
-     * 
-     * @return void
-     */
-    public function setProxies(array $relations = null)
-    {
-        $attributes = $this->getEntityAttributes();
-        $proxies = [];
-
-        if(is_null($relations)) {
-            $relations = $this->getRelationsToProxy();
-        }
-
-        foreach ($relations as $relation) {
-            // We first look if we need to build the proxy on the relationship.
-            // If the key is handled locally and we know it not to be set,
-            // we'll set the relationship to null
-            if (! $this->relationNeedsProxy($relation, $attributes))  {
-                $proxies[$relation] = null;
-            }
-            else {
-                $targetClass = $this->entityMap->getTargettedClass($relation);
-                $proxies[$relation] = $this->proxyFactory->make($this->getObject(), $relation, $targetClass);
-            }
-        }
-
-        foreach ($proxies as $key => $value) {
-            $this->setEntityAttribute($key, $value);
-        }
-    }
-
-    /**  
-     * Determine which relations we have to build proxy for, by parsing
-     * attributes and finding methods that aren't set.
-     * 
-     * @return array
-     */
-    protected function getRelationsToProxy()
-    {
-        $proxies = [];
-        $attributes = $this->getEntityAttributes();
-
-        foreach ($this->entityMap->getRelationships() as $relation) {
-            if (!array_key_exists($relation, $attributes)) {
-                $proxies[] = $relation;
-            }
-        }
-
-        return $proxies;
-    }
-
-    /**  
-     * Determine if the relation needs a proxy or not
-     * 
-     * @param  string $relation  
-     * @param  array $attributes 
-     * @return boolean
-     */
-    protected function relationNeedsProxy($relation, $attributes)
-    {
-        if(in_array($relation, $this->entityMap->getRelationshipsWithoutProxy())) {
-            return false;
-        }
-
-        $localKey = $this->entityMap->getLocalKeys($relation);
-
-        if(is_null($localKey)) return true;
-
-        if(is_array($localKey)) {
-            $localKey = $localKey['id'];
-        }
-
-        if(! isset($attributes[$localKey])) {
-            return false;
-        }
-
-        if(is_null($attributes[$localKey])) {
-            return false;
-        }
+	/**
+	 * Original Entity Object
+	 *
+	 * @var mixed
+	 */
+	protected $entity;
+
+	/**
+	 * Corresponding EntityMap
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * @var \Analogue\ORM\System\Proxirs\ProxyFactory
+	 */
+	protected $proxyFactory;
+
+	/**
+	 * Wrapper constructor.
+	 * @param $entity
+	 * @param $entityMap
+	 */
+	public function __construct($entity, $entityMap)
+	{
+		$this->entity = $entity;
+		$this->entityMap = $entityMap;
+		$this->proxyFactory = new ProxyFactory;
+	}
+
+	/**
+	 * Return the wrapped entity class
+	 *
+	 * @return mixed
+	 */
+	public function getEntityClass()
+	{
+		return get_class($this->entity);
+	}
+
+	/**
+	 * Returns the wrapped entity
+	 *
+	 * @return mixed
+	 */
+	public function getObject()
+	{
+		return $this->entity;
+	}
+
+	/**
+	 * Returns the wrapped entity's map
+	 *
+	 * @return mixed
+	 */
+	public function getMap()
+	{
+		return $this->entityMap;
+	}
+
+	/**
+	 * Set the lazyloading proxies on the wrapped entity objet
+	 * 
+	 * @param  array  $relations  list of relations to be lazy loaded
+	 * 
+	 * @return void
+	 */
+	public function setProxies(array $relations = null)
+	{
+		$attributes = $this->getEntityAttributes();
+		$proxies = [];
+
+		if(is_null($relations)) {
+			$relations = $this->getRelationsToProxy();
+		}
+
+		foreach ($relations as $relation) {
+			// We first look if we need to build the proxy on the relationship.
+			// If the key is handled locally and we know it not to be set,
+			// we'll set the relationship to null
+			if (! $this->relationNeedsProxy($relation, $attributes))  {
+				$proxies[$relation] = null;
+			}
+			else {
+				$targetClass = $this->entityMap->getTargettedClass($relation);
+				$proxies[$relation] = $this->proxyFactory->make($this->getObject(), $relation, $targetClass);
+			}
+		}
+
+		foreach ($proxies as $key => $value) {
+			$this->setEntityAttribute($key, $value);
+		}
+	}
+
+	/**  
+	 * Determine which relations we have to build proxy for, by parsing
+	 * attributes and finding methods that aren't set.
+	 * 
+	 * @return array
+	 */
+	protected function getRelationsToProxy()
+	{
+		$proxies = [];
+		$attributes = $this->getEntityAttributes();
+
+		foreach ($this->entityMap->getRelationships() as $relation) {
+			if (!array_key_exists($relation, $attributes)) {
+				$proxies[] = $relation;
+			}
+		}
+
+		return $proxies;
+	}
+
+	/**  
+	 * Determine if the relation needs a proxy or not
+	 * 
+	 * @param  string $relation  
+	 * @param  array $attributes 
+	 * @return boolean
+	 */
+	protected function relationNeedsProxy($relation, $attributes)
+	{
+		if(in_array($relation, $this->entityMap->getRelationshipsWithoutProxy())) {
+			return false;
+		}
+
+		$localKey = $this->entityMap->getLocalKeys($relation);
+
+		if(is_null($localKey)) return true;
+
+		if(is_array($localKey)) {
+			$localKey = $localKey['id'];
+		}
+
+		if(! isset($attributes[$localKey])) {
+			return false;
+		}
+
+		if(is_null($attributes[$localKey])) {
+			return false;
+		}
         
-        return true;
-    }
-
-    /**
-     * @param string $key
-     * @param string $value
-     * @return mixed
-     */
-    abstract public function setEntityAttribute($key, $value);
-
-    /**
-     * @param string $key
-     * @return mixed
-     */
-    abstract public function getEntityAttribute($key);
-
-    /**
-     * @param array $attributes
-     * @return mixed
-     */
-    abstract public function setEntityAttributes(array $attributes);
-
-    /**
-     * @return mixed
-     */
-    abstract public function getEntityAttributes();
-
-    /**
-     * @param string $key
-     * @return mixed
-     */
-    abstract public function hasAttribute($key);
+		return true;
+	}
+
+	/**
+	 * @param string $key
+	 * @param string $value
+	 * @return mixed
+	 */
+	abstract public function setEntityAttribute($key, $value);
+
+	/**
+	 * @param string $key
+	 * @return mixed
+	 */
+	abstract public function getEntityAttribute($key);
+
+	/**
+	 * @param array $attributes
+	 * @return mixed
+	 */
+	abstract public function setEntityAttributes(array $attributes);
+
+	/**
+	 * @return mixed
+	 */
+	abstract public function getEntityAttributes();
+
+	/**
+	 * @param string $key
+	 * @return mixed
+	 */
+	abstract public function hasAttribute($key);
 }

src/System/Query.php

Indentation +842 added lines, -842 removed lines

@@ -19,846 +19,846 @@
  */
 class Query
 {
-    /**
-     * Mapper Instance
-     *
-     * @var \Analogue\ORM\System\Mapper
-     */
-    protected $mapper;
-
-    /**
-     * DB Adatper
-     *
-     * @var \Analogue\ORM\Drivers\DBAdapter
-     */
-    protected $adapter;
-
-    /**
-     * Query Builder Instance
-     *
-     * @var \Analogue\ORM\Drivers\QueryAdapter|\Analogue\ORM\Drivers\IlluminateQueryAdapter
-     */
-    protected $query;
-
-    /**
-     * Entity Map Instance
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * The relationships that should be eager loaded.
-     *
-     * @var array
-     */
-    protected $eagerLoad = [];
-
-    /**
-     * All of the registered builder macros.
-     *
-     * @var array
-     */
-    protected $macros = [];
-
-    /**
-     * The methods that should be returned from query builder.
-     *
-     * @var array
-     */
-    protected $passthru = [
-        'toSql',
-        'lists',
-        'pluck',
-        'count',
-        'min',
-        'max',
-        'avg',
-        'sum',
-        'exists',
-        'getBindings',
-    ];
-
-    /**
-     * Query Builder Blacklist
-     */
-    protected $blacklist = [
-        'insert',
-        'insertGetId',
-        'lock',
-        'lockForUpdate',
-        'sharedLock',
-        'update',
-        'increment',
-        'decrement',
-        'delete',
-        'truncate',
-        'raw',
-    ];
-
-    /**
-     * Create a new Analogue Query Builder instance.
-     *
-     * @param  Mapper    $mapper
-     * @param  DBAdapter $adapter
-     */
-    public function __construct(Mapper $mapper, DBAdapter $adapter)
-    {
-        $this->mapper = $mapper;
-
-        $this->adapter = $adapter;
-
-        $this->entityMap = $mapper->getEntityMap();
-
-        // Specify the table to work on
-        $this->query = $adapter->getQuery()->from($this->entityMap->getTable());
-
-        $this->with($this->entityMap->getEagerloadedRelationships());
-    }
-
-    /**
-     * Run the query and return the result
-     *
-     * @param  array $columns
-     * @return \Analogue\ORM\EntityCollection
-     */
-    public function get($columns = ['*'])
-    {
-        $entities = $this->getEntities($columns);
-
-        // If we actually found models we will also eager load any relationships that
-        // have been specified as needing to be eager loaded, which will solve the
-        // n+1 query issue for the developers to avoid running a lot of queries.
-
-        if (count($entities) > 0) {
-            $entities = $this->eagerLoadRelations($entities);
-        }
-
-        return $this->entityMap->newCollection($entities);
-    }
-
-    /**
-     * Find an entity by its primary key
-     *
-     * @param  string|integer $id
-     * @param  array          $columns
-     * @return \Analogue\ORM\Mappable
-     */
-    public function find($id, $columns = ['*'])
-    {
-        if (is_array($id)) {
-            return $this->findMany($id, $columns);
-        }
-
-        $this->query->where($this->entityMap->getKeyName(), '=', $id);
-
-        return $this->first($columns);
-    }
-
-    /**
-     * Find many entities by their primary keys.
-     *
-     * @param  array $id
-     * @param  array $columns
-     * @return EntityCollection
-     */
-    public function findMany($id, $columns = ['*'])
-    {
-        if (empty($id)) {
-            return new EntityCollection;
-        }
-
-        $this->query->whereIn($this->entityMap->getKeyName(), $id);
-
-        return $this->get($columns);
-    }
-
-    /**
-     * Find a model by its primary key or throw an exception.
-     *
-     * @param  mixed $id
-     * @param  array $columns
-     * @throws \Analogue\ORM\Exceptions\EntityNotFoundException
-     * @return mixed|self
-     */
-    public function findOrFail($id, $columns = ['*'])
-    {
-        if (!is_null($entity = $this->find($id, $columns))) {
-            return $entity;
-        }
-
-        throw (new EntityNotFoundException)->setEntity(get_class($this->entityMap));
-    }
-
-
-    /**
-     * Execute the query and get the first result.
-     *
-     * @param  array $columns
-     * @return \Analogue\ORM\Entity
-     */
-    public function first($columns = ['*'])
-    {
-        return $this->take(1)->get($columns)->first();
-    }
-
-    /**
-     * Execute the query and get the first result or throw an exception.
-     *
-     * @param  array $columns
-     * @throws EntityNotFoundException
-     * @return \Analogue\ORM\Entity
-     */
-    public function firstOrFail($columns = ['*'])
-    {
-        if (!is_null($entity = $this->first($columns))) {
-            return $entity;
-        }
-
-        throw (new EntityNotFoundException)->setEntity(get_class($this->entityMap));
-    }
-
-    /**
-     * Pluck a single column from the database.
-     *
-     * @param  string $column
-     * @return mixed
-     */
-    public function pluck($column)
-    {
-        $result = $this->first([$column]);
-
-        if ($result) {
-            return $result->{$column};
-        }
-    }
-
-    /**
-     * Chunk the results of the query.
-     *
-     * @param  int      $count
-     * @param  callable $callback
-     * @return void
-     */
-    public function chunk($count, callable $callback)
-    {
-        $results = $this->forPage($page = 1, $count)->get();
-
-        while (count($results) > 0) {
-            // On each chunk result set, we will pass them to the callback and then let the
-            // developer take care of everything within the callback, which allows us to
-            // keep the memory low for spinning through large result sets for working.
-            call_user_func($callback, $results);
-
-            $page++;
-
-            $results = $this->forPage($page, $count)->get();
-        }
-    }
-
-    /**
-     * Get an array with the values of a given column.
-     *
-     * @param  string $column
-     * @param  string $key
-     * @return array
-     */
-    public function lists($column, $key = null)
-    {
-        return $this->query->pluck($column, $key);
-    }
-
-    /**
-     * Get a paginator for the "select" statement.
-     *
-     * @param  int   $perPage
-     * @param  array $columns
-     * @return LengthAwarePaginator
-     */
-    public function paginate($perPage = null, $columns = ['*'])
-    {
-        $total = $this->query->getCountForPagination();
-
-        $this->query->forPage(
-            $page = Paginator::resolveCurrentPage(),
-            $perPage = $perPage ?: $this->entityMap->getPerPage()
-        );
-
-        return new LengthAwarePaginator($this->get($columns)->all(), $total, $perPage, $page, [
-            'path' => Paginator::resolveCurrentPath()
-        ]);
-    }
-
-    /**
-     * Get a paginator for a grouped statement.
-     *
-     * @param  \Illuminate\Pagination\Factory $paginator
-     * @param  int                            $perPage
-     * @param  array                          $columns
-     * @return \Illuminate\Pagination\Paginator
-     */
-    protected function groupedPaginate($paginator, $perPage, $columns)
-    {
-        $results = $this->get($columns)->all();
-
-        return $this->query->buildRawPaginator($paginator, $results, $perPage);
-    }
-
-    /**
-     * Get a paginator for an ungrouped statement.
-     *
-     * @param  \Illuminate\Pagination\Factory $paginator
-     * @param  int                            $perPage
-     * @param  array                          $columns
-     * @return \Illuminate\Pagination\Paginator
-     */
-    protected function ungroupedPaginate($paginator, $perPage, $columns)
-    {
-        $total = $this->query->getPaginationCount();
-
-        // Once we have the paginator we need to set the limit and offset values for
-        // the query so we can get the properly paginated items. Once we have an
-        // array of items we can create the paginator instances for the items.
-        $page = $paginator->getCurrentPage($total);
-
-        $this->query->forPage($page, $perPage);
-
-        return $paginator->make($this->get($columns)->all(), $total, $perPage);
-    }
-
-    /**
-     * Paginate the given query into a simple paginator.
-     *
-     * @param  int   $perPage
-     * @param  array $columns
-     * @return \Illuminate\Contracts\Pagination\Paginator
-     */
-    public function simplePaginate($perPage = null, $columns = ['*'])
-    {
-        $page = Paginator::resolveCurrentPage();
-
-        $perPage = $perPage ?: $this->entityMap->getPerPage();
-
-        $this->skip(($page - 1) * $perPage)->take($perPage + 1);
-
-        return new Paginator($this->get($columns)->all(), $perPage, $page, ['path' => Paginator::resolveCurrentPath()]);
-    }
-
-    /**
-     * Add a basic where clause to the query.
-     *
-     * @param  string $column
-     * @param  string $operator
-     * @param  mixed  $value
-     * @param  string $boolean
-     * @return $this
-     */
-    public function where($column, $operator = null, $value = null, $boolean = 'and')
-    {
-        if ($column instanceof Closure) {
-            $query = $this->newQueryWithoutScopes();
-
-            call_user_func($column, $query);
-
-            $this->query->addNestedWhereQuery($query->getQuery(), $boolean);
-        } else {
-            call_user_func_array([$this->query, 'where'], func_get_args());
-        }
-
-        return $this;
-    }
-
-    /**
-     * Add an "or where" clause to the query.
-     *
-     * @param  string $column
-     * @param  string $operator
-     * @param  mixed  $value
-     * @return \Analogue\ORM\System\Query
-     */
-    public function orWhere($column, $operator = null, $value = null)
-    {
-        return $this->where($column, $operator, $value, 'or');
-    }
-
-    /**
-     * Add a relationship count condition to the query.
-     *
-     * @param  string   $relation
-     * @param  string   $operator
-     * @param  int      $count
-     * @param  string   $boolean
-     * @param  \Closure $callback
-     * @return \Analogue\ORM\System\Query
-     */
-    public function has($relation, $operator = '>=', $count = 1, $boolean = 'and', $callback = null)
-    {
-        $entity = $this->mapper->newInstance();
-
-        $relation = $this->getHasRelationQuery($relation, $entity);
-
-        $query = $relation->getRelationCountQuery($relation->getRelatedMapper()->getQuery(), $this);
-
-        if ($callback) {
-            call_user_func($callback, $query);
-        }
-
-        return $this->addHasWhere($query, $relation, $operator, $count, $boolean);
-    }
-
-    /**
-     * Add a relationship count condition to the query with where clauses.
-     *
-     * @param  string   $relation
-     * @param  \Closure $callback
-     * @param  string   $operator
-     * @param  int      $count
-     * @return \Analogue\ORM\System\Query
-     */
-    public function whereHas($relation, Closure $callback, $operator = '>=', $count = 1)
-    {
-        return $this->has($relation, $operator, $count, 'and', $callback);
-    }
-
-    /**
-     * Add a relationship count condition to the query with an "or".
-     *
-     * @param  string $relation
-     * @param  string $operator
-     * @param  int    $count
-     * @return \Analogue\ORM\System\Query
-     */
-    public function orHas($relation, $operator = '>=', $count = 1)
-    {
-        return $this->has($relation, $operator, $count, 'or');
-    }
-
-    /**
-     * Add a relationship count condition to the query with where clauses and an "or".
-     *
-     * @param  string   $relation
-     * @param  \Closure $callback
-     * @param  string   $operator
-     * @param  int      $count
-     * @return \Analogue\ORM\System\Query
-     */
-    public function orWhereHas($relation, Closure $callback, $operator = '>=', $count = 1)
-    {
-        return $this->has($relation, $operator, $count, 'or', $callback);
-    }
-
-    /**
-     * Add the "has" condition where clause to the query.
-     *
-     * @param  \Analogue\ORM\System\Query               $hasQuery
-     * @param  \Analogue\ORM\Relationships\Relationship $relation
-     * @param  string                                   $operator
-     * @param  int                                      $count
-     * @param  string                                   $boolean
-     * @return \Analogue\ORM\System\Query
-     */
-    protected function addHasWhere(Query $hasQuery, Relationship $relation, $operator, $count, $boolean)
-    {
-        $this->mergeWheresToHas($hasQuery, $relation);
-
-        if (is_numeric($count)) {
-            $count = new Expression($count);
-        }
-
-        return $this->where(new Expression('(' . $hasQuery->toSql() . ')'), $operator, $count, $boolean);
-    }
-
-    /**
-     * Merge the "wheres" from a relation query to a has query.
-     *
-     * @param  \Analogue\ORM\System\Query               $hasQuery
-     * @param  \Analogue\ORM\Relationships\Relationship $relation
-     * @return void
-     */
-    protected function mergeWheresToHas(Query $hasQuery, Relationship $relation)
-    {
-        // Here we have the "has" query and the original relation. We need to copy over any
-        // where clauses the developer may have put in the relationship function over to
-        // the has query, and then copy the bindings from the "has" query to the main.
-        $relationQuery = $relation->getBaseQuery();
-
-        $hasQuery->mergeWheres(
-            $relationQuery->wheres, $relationQuery->getBindings()
-        );
-
-        $this->query->mergeBindings($hasQuery->getQuery());
-    }
-
-    /**
-     * Get the "has relation" base query instance.
-     *
-     * @param  string $relation
-     * @param         $entity
-     * @return \Analogue\ORM\System\Query
-     */
-    protected function getHasRelationQuery($relation, $entity)
-    {
-        return Relationship::noConstraints(function () use ($relation, $entity) {
-            return $this->entityMap->$relation($entity);
-        });
-    }
-
-    /**
-     * Get the table for the current query object
-     *
-     * @return string
-     */
-    public function getTable()
-    {
-        return $this->entityMap->getTable();
-    }
-
-    /**
-     * Set the relationships that should be eager loaded.
-     *
-     * @param  mixed $relations
-     * @return $this
-     */
-    public function with($relations)
-    {
-        if (is_string($relations)) {
-            $relations = func_get_args();
-        }
-
-        $eagers = $this->parseRelations($relations);
-
-        $this->eagerLoad = array_merge($this->eagerLoad, $eagers);
-
-        return $this;
-    }
-
-    /**
-     * Parse a list of relations into individuals.
-     *
-     * @param  array $relations
-     * @return array
-     */
-    protected function parseRelations(array $relations)
-    {
-        $results = [];
-
-        foreach ($relations as $name => $constraints) {
-            // If the "relation" value is actually a numeric key, we can assume that no
-            // constraints have been specified for the eager load and we'll just put
-            // an empty Closure with the loader so that we can treat all the same.
-            if (is_numeric($name)) {
-                $f = function () {};
-
-                list($name, $constraints) = [$constraints, $f];
-            }
-
-            // We need to separate out any nested includes. Which allows the developers
-            // to load deep relationships using "dots" without stating each level of
-            // the relationship with its own key in the array of eager load names.
-            $results = $this->parseNested($name, $results);
-
-            $results[$name] = $constraints;
-        }
-
-        return $results;
-    }
-
-
-    /**
-     * Parse the nested relationships in a relation.
-     *
-     * @param  string $name
-     * @param  array  $results
-     * @return array
-     */
-    protected function parseNested($name, $results)
-    {
-        $progress = [];
-
-        // If the relation has already been set on the result array, we will not set it
-        // again, since that would override any constraints that were already placed
-        // on the relationships. We will only set the ones that are not specified.
-        foreach (explode('.', $name) as $segment) {
-            $progress[] = $segment;
-
-            if (!isset($results[$last = implode('.', $progress)])) {
-                $results[$last] = function () {};
-            }
-        }
-
-        return $results;
-    }
-
-    /**
-     * Get the relationships being eagerly loaded.
-     *
-     * @return array
-     */
-    public function getEagerLoads()
-    {
-        return $this->eagerLoad;
-    }
-
-    /**
-     * Set the relationships being eagerly loaded.
-     *
-     * @param  array $eagerLoad
-     * @return void
-     */
-    public function setEagerLoads(array $eagerLoad)
-    {
-        $this->eagerLoad = $eagerLoad;
-    }
-
-    /**
-     * Eager load the relationships for the entities.
-     *
-     * @param  array $entities
-     * @return array
-     */
-    public function eagerLoadRelations($entities)
-    {
-        foreach ($this->eagerLoad as $name => $constraints) {
-            // For nested eager loads we'll skip loading them here and they will be set as an
-            // eager load on the query to retrieve the relation so that they will be eager
-            // loaded on that query, because that is where they get hydrated as models.
-            if (strpos($name, '.') === false) {
-                $entities = $this->loadRelation($entities, $name, $constraints);
-            }
-        }
-
-        return $entities;
-    }
-
-    /**
-     * Eagerly load the relationship on a set of entities.
-     *
-     * @param  array    $entities
-     * @param  string   $name
-     * @param  \Closure $constraints
-     * @return array
-     */
-    protected function loadRelation(array $entities, $name, Closure $constraints)
-    {
-        // First we will "back up" the existing where conditions on the query so we can
-        // add our eager constraints. Then we will merge the wheres that were on the
-        // query back to it in order that any where conditions might be specified.
-        $relation = $this->getRelation($name);
-
-        $relation->addEagerConstraints($entities);
-
-        call_user_func($constraints, $relation);
-
-        $entities = $relation->initRelation($entities, $name);
-
-        // Once we have the results, we just match those back up to their parent models
-        // using the relationship instance. Then we just return the finished arrays
-        // of models which have been eagerly hydrated and are readied for return.
-
-        $results = $relation->getEager();
-
-        return $relation->match($entities, $results, $name);
-    }
-
-    /**
-     * Get the relation instance for the given relation name.
-     *
-     * @param  string $relation
-     * @return \Analogue\ORM\Relationships\Relationship
-     */
-    public function getRelation($relation)
-    {
-        // We want to run a relationship query without any constrains so that we will
-        // not have to remove these where clauses manually which gets really hacky
-        // and is error prone while we remove the developer's own where clauses.
-        $query = Relationship::noConstraints(function () use ($relation) {
-            return $this->entityMap->$relation($this->getEntityInstance());
-        });
-
-        $nested = $this->nestedRelations($relation);
-
-        // If there are nested relationships set on the query, we will put those onto
-        // the query instances so that they can be handled after this relationship
-        // is loaded. In this way they will all trickle down as they are loaded.
-        if (count($nested) > 0) {
-            $query->getQuery()->with($nested);
-        }
-
-        return $query;
-    }
-
-    /**
-     * Get the deeply nested relations for a given top-level relation.
-     *
-     * @param  string $relation
-     * @return array
-     */
-    protected function nestedRelations($relation)
-    {
-        $nested = [];
-
-        // We are basically looking for any relationships that are nested deeper than
-        // the given top-level relationship. We will just check for any relations
-        // that start with the given top relations and adds them to our arrays.
-        foreach ($this->eagerLoad as $name => $constraints) {
-            if ($this->isNested($name, $relation)) {
-                $nested[substr($name, strlen($relation . '.'))] = $constraints;
-            }
-        }
-
-        return $nested;
-    }
-
-    /**
-     * Determine if the relationship is nested.
-     *
-     * @param  string $name
-     * @param  string $relation
-     * @return bool
-     */
-    protected function isNested($name, $relation)
-    {
-        $dots = str_contains($name, '.');
-
-        return $dots && starts_with($name, $relation . '.');
-    }
-
-    /**
-     * Add the Entity primary key if not in requested columns
-     *
-     * @param  array $columns
-     * @return array
-     */
-    protected function enforceIdColumn($columns)
-    {
-        if (!in_array($this->entityMap->getKeyName(), $columns)) {
-            $columns[] = $this->entityMap->getKeyName();
-        }
-        return $columns;
-    }
-
-    /**
-     * Get the hydrated models without eager loading.
-     *
-     * @param  array  $columns
-     * @return \Analogue\ORM\EntityCollection
-     */
-    public function getEntities($columns = ['*'])
-    {
-        // As we need the primary key to feed the
-        // entity cache, we need it loaded on each
-        // request
-        $columns = $this->enforceIdColumn($columns);
-
-        // Run the query
-        $results = $this->query->get($columns)->toArray();
-
-        // Create a result builder.
-        $builder = new ResultBuilder(Manager::getInstance(), $this->mapper, array_keys($this->getEagerLoads()));
-
-        return $builder->build($results);
-    }
-
-    /**
-     * Get a new instance for the entity
-     *
-     * @return \Analogue\ORM\Entity
-     */
-    public function getEntityInstance()
-    {
-        return $this->mapper->newInstance();
-    }
-
-    /**
-     * Extend the builder with a given callback.
-     *
-     * @param  string   $name
-     * @param  \Closure $callback
-     * @return void
-     */
-    public function macro($name, Closure $callback)
-    {
-        $this->macros[$name] = $callback;
-    }
-
-    /**
-     * Get the given macro by name.
-     *
-     * @param  string $name
-     * @return \Closure
-     */
-    public function getMacro($name)
-    {
-        return array_get($this->macros, $name);
-    }
-
-    /**
-     * Get a new query builder for the model's table.
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function newQuery()
-    {
-        $builder = new Query($this->mapper, $this->adapter);
-
-        return $this->applyGlobalScopes($builder);
-    }
-
-    /**
-     * Get a new query builder without any scope applied.
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function newQueryWithoutScopes()
-    {
-        return new Query($this->mapper, $this->adapter);
-    }
-
-    /**
-     * Get the Mapper instance for this Query Builder
-     *
-     * @return \Analogue\ORM\System\Mapper
-     */
-    public function getMapper()
-    {
-        return $this->mapper;
-    }
-
-    /**
-     * Get the underlying query adapter
-     *
-     * (REFACTOR: this method should move out, we need to provide the client classes
-     * with the adapter instead.)
-     *
-     * @return \Analogue\ORM\Drivers\QueryAdapter|\Analogue\ORM\Drivers\IlluminateQueryAdapter
-     */
-    public function getQuery()
-    {
-        return $this->query;
-    }
-
-    /**
-     * Dynamically handle calls into the query instance.
-     *
-     * @param  string $method
-     * @param  array  $parameters
-     * @throws Exception
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        if (isset($this->macros[$method])) {
-            array_unshift($parameters, $this);
-
-            return call_user_func_array($this->macros[$method], $parameters);
-        }
-
-        if (in_array($method, $this->blacklist)) {
-            throw new Exception("Method $method doesn't exist");
-        }
-
-        $result = call_user_func_array([$this->query, $method], $parameters);
-
-        return in_array($method, $this->passthru) ? $result : $this;
-    }
+	/**
+	 * Mapper Instance
+	 *
+	 * @var \Analogue\ORM\System\Mapper
+	 */
+	protected $mapper;
+
+	/**
+	 * DB Adatper
+	 *
+	 * @var \Analogue\ORM\Drivers\DBAdapter
+	 */
+	protected $adapter;
+
+	/**
+	 * Query Builder Instance
+	 *
+	 * @var \Analogue\ORM\Drivers\QueryAdapter|\Analogue\ORM\Drivers\IlluminateQueryAdapter
+	 */
+	protected $query;
+
+	/**
+	 * Entity Map Instance
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * The relationships that should be eager loaded.
+	 *
+	 * @var array
+	 */
+	protected $eagerLoad = [];
+
+	/**
+	 * All of the registered builder macros.
+	 *
+	 * @var array
+	 */
+	protected $macros = [];
+
+	/**
+	 * The methods that should be returned from query builder.
+	 *
+	 * @var array
+	 */
+	protected $passthru = [
+		'toSql',
+		'lists',
+		'pluck',
+		'count',
+		'min',
+		'max',
+		'avg',
+		'sum',
+		'exists',
+		'getBindings',
+	];
+
+	/**
+	 * Query Builder Blacklist
+	 */
+	protected $blacklist = [
+		'insert',
+		'insertGetId',
+		'lock',
+		'lockForUpdate',
+		'sharedLock',
+		'update',
+		'increment',
+		'decrement',
+		'delete',
+		'truncate',
+		'raw',
+	];
+
+	/**
+	 * Create a new Analogue Query Builder instance.
+	 *
+	 * @param  Mapper    $mapper
+	 * @param  DBAdapter $adapter
+	 */
+	public function __construct(Mapper $mapper, DBAdapter $adapter)
+	{
+		$this->mapper = $mapper;
+
+		$this->adapter = $adapter;
+
+		$this->entityMap = $mapper->getEntityMap();
+
+		// Specify the table to work on
+		$this->query = $adapter->getQuery()->from($this->entityMap->getTable());
+
+		$this->with($this->entityMap->getEagerloadedRelationships());
+	}
+
+	/**
+	 * Run the query and return the result
+	 *
+	 * @param  array $columns
+	 * @return \Analogue\ORM\EntityCollection
+	 */
+	public function get($columns = ['*'])
+	{
+		$entities = $this->getEntities($columns);
+
+		// If we actually found models we will also eager load any relationships that
+		// have been specified as needing to be eager loaded, which will solve the
+		// n+1 query issue for the developers to avoid running a lot of queries.
+
+		if (count($entities) > 0) {
+			$entities = $this->eagerLoadRelations($entities);
+		}
+
+		return $this->entityMap->newCollection($entities);
+	}
+
+	/**
+	 * Find an entity by its primary key
+	 *
+	 * @param  string|integer $id
+	 * @param  array          $columns
+	 * @return \Analogue\ORM\Mappable
+	 */
+	public function find($id, $columns = ['*'])
+	{
+		if (is_array($id)) {
+			return $this->findMany($id, $columns);
+		}
+
+		$this->query->where($this->entityMap->getKeyName(), '=', $id);
+
+		return $this->first($columns);
+	}
+
+	/**
+	 * Find many entities by their primary keys.
+	 *
+	 * @param  array $id
+	 * @param  array $columns
+	 * @return EntityCollection
+	 */
+	public function findMany($id, $columns = ['*'])
+	{
+		if (empty($id)) {
+			return new EntityCollection;
+		}
+
+		$this->query->whereIn($this->entityMap->getKeyName(), $id);
+
+		return $this->get($columns);
+	}
+
+	/**
+	 * Find a model by its primary key or throw an exception.
+	 *
+	 * @param  mixed $id
+	 * @param  array $columns
+	 * @throws \Analogue\ORM\Exceptions\EntityNotFoundException
+	 * @return mixed|self
+	 */
+	public function findOrFail($id, $columns = ['*'])
+	{
+		if (!is_null($entity = $this->find($id, $columns))) {
+			return $entity;
+		}
+
+		throw (new EntityNotFoundException)->setEntity(get_class($this->entityMap));
+	}
+
+
+	/**
+	 * Execute the query and get the first result.
+	 *
+	 * @param  array $columns
+	 * @return \Analogue\ORM\Entity
+	 */
+	public function first($columns = ['*'])
+	{
+		return $this->take(1)->get($columns)->first();
+	}
+
+	/**
+	 * Execute the query and get the first result or throw an exception.
+	 *
+	 * @param  array $columns
+	 * @throws EntityNotFoundException
+	 * @return \Analogue\ORM\Entity
+	 */
+	public function firstOrFail($columns = ['*'])
+	{
+		if (!is_null($entity = $this->first($columns))) {
+			return $entity;
+		}
+
+		throw (new EntityNotFoundException)->setEntity(get_class($this->entityMap));
+	}
+
+	/**
+	 * Pluck a single column from the database.
+	 *
+	 * @param  string $column
+	 * @return mixed
+	 */
+	public function pluck($column)
+	{
+		$result = $this->first([$column]);
+
+		if ($result) {
+			return $result->{$column};
+		}
+	}
+
+	/**
+	 * Chunk the results of the query.
+	 *
+	 * @param  int      $count
+	 * @param  callable $callback
+	 * @return void
+	 */
+	public function chunk($count, callable $callback)
+	{
+		$results = $this->forPage($page = 1, $count)->get();
+
+		while (count($results) > 0) {
+			// On each chunk result set, we will pass them to the callback and then let the
+			// developer take care of everything within the callback, which allows us to
+			// keep the memory low for spinning through large result sets for working.
+			call_user_func($callback, $results);
+
+			$page++;
+
+			$results = $this->forPage($page, $count)->get();
+		}
+	}
+
+	/**
+	 * Get an array with the values of a given column.
+	 *
+	 * @param  string $column
+	 * @param  string $key
+	 * @return array
+	 */
+	public function lists($column, $key = null)
+	{
+		return $this->query->pluck($column, $key);
+	}
+
+	/**
+	 * Get a paginator for the "select" statement.
+	 *
+	 * @param  int   $perPage
+	 * @param  array $columns
+	 * @return LengthAwarePaginator
+	 */
+	public function paginate($perPage = null, $columns = ['*'])
+	{
+		$total = $this->query->getCountForPagination();
+
+		$this->query->forPage(
+			$page = Paginator::resolveCurrentPage(),
+			$perPage = $perPage ?: $this->entityMap->getPerPage()
+		);
+
+		return new LengthAwarePaginator($this->get($columns)->all(), $total, $perPage, $page, [
+			'path' => Paginator::resolveCurrentPath()
+		]);
+	}
+
+	/**
+	 * Get a paginator for a grouped statement.
+	 *
+	 * @param  \Illuminate\Pagination\Factory $paginator
+	 * @param  int                            $perPage
+	 * @param  array                          $columns
+	 * @return \Illuminate\Pagination\Paginator
+	 */
+	protected function groupedPaginate($paginator, $perPage, $columns)
+	{
+		$results = $this->get($columns)->all();
+
+		return $this->query->buildRawPaginator($paginator, $results, $perPage);
+	}
+
+	/**
+	 * Get a paginator for an ungrouped statement.
+	 *
+	 * @param  \Illuminate\Pagination\Factory $paginator
+	 * @param  int                            $perPage
+	 * @param  array                          $columns
+	 * @return \Illuminate\Pagination\Paginator
+	 */
+	protected function ungroupedPaginate($paginator, $perPage, $columns)
+	{
+		$total = $this->query->getPaginationCount();
+
+		// Once we have the paginator we need to set the limit and offset values for
+		// the query so we can get the properly paginated items. Once we have an
+		// array of items we can create the paginator instances for the items.
+		$page = $paginator->getCurrentPage($total);
+
+		$this->query->forPage($page, $perPage);
+
+		return $paginator->make($this->get($columns)->all(), $total, $perPage);
+	}
+
+	/**
+	 * Paginate the given query into a simple paginator.
+	 *
+	 * @param  int   $perPage
+	 * @param  array $columns
+	 * @return \Illuminate\Contracts\Pagination\Paginator
+	 */
+	public function simplePaginate($perPage = null, $columns = ['*'])
+	{
+		$page = Paginator::resolveCurrentPage();
+
+		$perPage = $perPage ?: $this->entityMap->getPerPage();
+
+		$this->skip(($page - 1) * $perPage)->take($perPage + 1);
+
+		return new Paginator($this->get($columns)->all(), $perPage, $page, ['path' => Paginator::resolveCurrentPath()]);
+	}
+
+	/**
+	 * Add a basic where clause to the query.
+	 *
+	 * @param  string $column
+	 * @param  string $operator
+	 * @param  mixed  $value
+	 * @param  string $boolean
+	 * @return $this
+	 */
+	public function where($column, $operator = null, $value = null, $boolean = 'and')
+	{
+		if ($column instanceof Closure) {
+			$query = $this->newQueryWithoutScopes();
+
+			call_user_func($column, $query);
+
+			$this->query->addNestedWhereQuery($query->getQuery(), $boolean);
+		} else {
+			call_user_func_array([$this->query, 'where'], func_get_args());
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Add an "or where" clause to the query.
+	 *
+	 * @param  string $column
+	 * @param  string $operator
+	 * @param  mixed  $value
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function orWhere($column, $operator = null, $value = null)
+	{
+		return $this->where($column, $operator, $value, 'or');
+	}
+
+	/**
+	 * Add a relationship count condition to the query.
+	 *
+	 * @param  string   $relation
+	 * @param  string   $operator
+	 * @param  int      $count
+	 * @param  string   $boolean
+	 * @param  \Closure $callback
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function has($relation, $operator = '>=', $count = 1, $boolean = 'and', $callback = null)
+	{
+		$entity = $this->mapper->newInstance();
+
+		$relation = $this->getHasRelationQuery($relation, $entity);
+
+		$query = $relation->getRelationCountQuery($relation->getRelatedMapper()->getQuery(), $this);
+
+		if ($callback) {
+			call_user_func($callback, $query);
+		}
+
+		return $this->addHasWhere($query, $relation, $operator, $count, $boolean);
+	}
+
+	/**
+	 * Add a relationship count condition to the query with where clauses.
+	 *
+	 * @param  string   $relation
+	 * @param  \Closure $callback
+	 * @param  string   $operator
+	 * @param  int      $count
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function whereHas($relation, Closure $callback, $operator = '>=', $count = 1)
+	{
+		return $this->has($relation, $operator, $count, 'and', $callback);
+	}
+
+	/**
+	 * Add a relationship count condition to the query with an "or".
+	 *
+	 * @param  string $relation
+	 * @param  string $operator
+	 * @param  int    $count
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function orHas($relation, $operator = '>=', $count = 1)
+	{
+		return $this->has($relation, $operator, $count, 'or');
+	}
+
+	/**
+	 * Add a relationship count condition to the query with where clauses and an "or".
+	 *
+	 * @param  string   $relation
+	 * @param  \Closure $callback
+	 * @param  string   $operator
+	 * @param  int      $count
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function orWhereHas($relation, Closure $callback, $operator = '>=', $count = 1)
+	{
+		return $this->has($relation, $operator, $count, 'or', $callback);
+	}
+
+	/**
+	 * Add the "has" condition where clause to the query.
+	 *
+	 * @param  \Analogue\ORM\System\Query               $hasQuery
+	 * @param  \Analogue\ORM\Relationships\Relationship $relation
+	 * @param  string                                   $operator
+	 * @param  int                                      $count
+	 * @param  string                                   $boolean
+	 * @return \Analogue\ORM\System\Query
+	 */
+	protected function addHasWhere(Query $hasQuery, Relationship $relation, $operator, $count, $boolean)
+	{
+		$this->mergeWheresToHas($hasQuery, $relation);
+
+		if (is_numeric($count)) {
+			$count = new Expression($count);
+		}
+
+		return $this->where(new Expression('(' . $hasQuery->toSql() . ')'), $operator, $count, $boolean);
+	}
+
+	/**
+	 * Merge the "wheres" from a relation query to a has query.
+	 *
+	 * @param  \Analogue\ORM\System\Query               $hasQuery
+	 * @param  \Analogue\ORM\Relationships\Relationship $relation
+	 * @return void
+	 */
+	protected function mergeWheresToHas(Query $hasQuery, Relationship $relation)
+	{
+		// Here we have the "has" query and the original relation. We need to copy over any
+		// where clauses the developer may have put in the relationship function over to
+		// the has query, and then copy the bindings from the "has" query to the main.
+		$relationQuery = $relation->getBaseQuery();
+
+		$hasQuery->mergeWheres(
+			$relationQuery->wheres, $relationQuery->getBindings()
+		);
+
+		$this->query->mergeBindings($hasQuery->getQuery());
+	}
+
+	/**
+	 * Get the "has relation" base query instance.
+	 *
+	 * @param  string $relation
+	 * @param         $entity
+	 * @return \Analogue\ORM\System\Query
+	 */
+	protected function getHasRelationQuery($relation, $entity)
+	{
+		return Relationship::noConstraints(function () use ($relation, $entity) {
+			return $this->entityMap->$relation($entity);
+		});
+	}
+
+	/**
+	 * Get the table for the current query object
+	 *
+	 * @return string
+	 */
+	public function getTable()
+	{
+		return $this->entityMap->getTable();
+	}
+
+	/**
+	 * Set the relationships that should be eager loaded.
+	 *
+	 * @param  mixed $relations
+	 * @return $this
+	 */
+	public function with($relations)
+	{
+		if (is_string($relations)) {
+			$relations = func_get_args();
+		}
+
+		$eagers = $this->parseRelations($relations);
+
+		$this->eagerLoad = array_merge($this->eagerLoad, $eagers);
+
+		return $this;
+	}
+
+	/**
+	 * Parse a list of relations into individuals.
+	 *
+	 * @param  array $relations
+	 * @return array
+	 */
+	protected function parseRelations(array $relations)
+	{
+		$results = [];
+
+		foreach ($relations as $name => $constraints) {
+			// If the "relation" value is actually a numeric key, we can assume that no
+			// constraints have been specified for the eager load and we'll just put
+			// an empty Closure with the loader so that we can treat all the same.
+			if (is_numeric($name)) {
+				$f = function () {};
+
+				list($name, $constraints) = [$constraints, $f];
+			}
+
+			// We need to separate out any nested includes. Which allows the developers
+			// to load deep relationships using "dots" without stating each level of
+			// the relationship with its own key in the array of eager load names.
+			$results = $this->parseNested($name, $results);
+
+			$results[$name] = $constraints;
+		}
+
+		return $results;
+	}
+
+
+	/**
+	 * Parse the nested relationships in a relation.
+	 *
+	 * @param  string $name
+	 * @param  array  $results
+	 * @return array
+	 */
+	protected function parseNested($name, $results)
+	{
+		$progress = [];
+
+		// If the relation has already been set on the result array, we will not set it
+		// again, since that would override any constraints that were already placed
+		// on the relationships. We will only set the ones that are not specified.
+		foreach (explode('.', $name) as $segment) {
+			$progress[] = $segment;
+
+			if (!isset($results[$last = implode('.', $progress)])) {
+				$results[$last] = function () {};
+			}
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Get the relationships being eagerly loaded.
+	 *
+	 * @return array
+	 */
+	public function getEagerLoads()
+	{
+		return $this->eagerLoad;
+	}
+
+	/**
+	 * Set the relationships being eagerly loaded.
+	 *
+	 * @param  array $eagerLoad
+	 * @return void
+	 */
+	public function setEagerLoads(array $eagerLoad)
+	{
+		$this->eagerLoad = $eagerLoad;
+	}
+
+	/**
+	 * Eager load the relationships for the entities.
+	 *
+	 * @param  array $entities
+	 * @return array
+	 */
+	public function eagerLoadRelations($entities)
+	{
+		foreach ($this->eagerLoad as $name => $constraints) {
+			// For nested eager loads we'll skip loading them here and they will be set as an
+			// eager load on the query to retrieve the relation so that they will be eager
+			// loaded on that query, because that is where they get hydrated as models.
+			if (strpos($name, '.') === false) {
+				$entities = $this->loadRelation($entities, $name, $constraints);
+			}
+		}
+
+		return $entities;
+	}
+
+	/**
+	 * Eagerly load the relationship on a set of entities.
+	 *
+	 * @param  array    $entities
+	 * @param  string   $name
+	 * @param  \Closure $constraints
+	 * @return array
+	 */
+	protected function loadRelation(array $entities, $name, Closure $constraints)
+	{
+		// First we will "back up" the existing where conditions on the query so we can
+		// add our eager constraints. Then we will merge the wheres that were on the
+		// query back to it in order that any where conditions might be specified.
+		$relation = $this->getRelation($name);
+
+		$relation->addEagerConstraints($entities);
+
+		call_user_func($constraints, $relation);
+
+		$entities = $relation->initRelation($entities, $name);
+
+		// Once we have the results, we just match those back up to their parent models
+		// using the relationship instance. Then we just return the finished arrays
+		// of models which have been eagerly hydrated and are readied for return.
+
+		$results = $relation->getEager();
+
+		return $relation->match($entities, $results, $name);
+	}
+
+	/**
+	 * Get the relation instance for the given relation name.
+	 *
+	 * @param  string $relation
+	 * @return \Analogue\ORM\Relationships\Relationship
+	 */
+	public function getRelation($relation)
+	{
+		// We want to run a relationship query without any constrains so that we will
+		// not have to remove these where clauses manually which gets really hacky
+		// and is error prone while we remove the developer's own where clauses.
+		$query = Relationship::noConstraints(function () use ($relation) {
+			return $this->entityMap->$relation($this->getEntityInstance());
+		});
+
+		$nested = $this->nestedRelations($relation);
+
+		// If there are nested relationships set on the query, we will put those onto
+		// the query instances so that they can be handled after this relationship
+		// is loaded. In this way they will all trickle down as they are loaded.
+		if (count($nested) > 0) {
+			$query->getQuery()->with($nested);
+		}
+
+		return $query;
+	}
+
+	/**
+	 * Get the deeply nested relations for a given top-level relation.
+	 *
+	 * @param  string $relation
+	 * @return array
+	 */
+	protected function nestedRelations($relation)
+	{
+		$nested = [];
+
+		// We are basically looking for any relationships that are nested deeper than
+		// the given top-level relationship. We will just check for any relations
+		// that start with the given top relations and adds them to our arrays.
+		foreach ($this->eagerLoad as $name => $constraints) {
+			if ($this->isNested($name, $relation)) {
+				$nested[substr($name, strlen($relation . '.'))] = $constraints;
+			}
+		}
+
+		return $nested;
+	}
+
+	/**
+	 * Determine if the relationship is nested.
+	 *
+	 * @param  string $name
+	 * @param  string $relation
+	 * @return bool
+	 */
+	protected function isNested($name, $relation)
+	{
+		$dots = str_contains($name, '.');
+
+		return $dots && starts_with($name, $relation . '.');
+	}
+
+	/**
+	 * Add the Entity primary key if not in requested columns
+	 *
+	 * @param  array $columns
+	 * @return array
+	 */
+	protected function enforceIdColumn($columns)
+	{
+		if (!in_array($this->entityMap->getKeyName(), $columns)) {
+			$columns[] = $this->entityMap->getKeyName();
+		}
+		return $columns;
+	}
+
+	/**
+	 * Get the hydrated models without eager loading.
+	 *
+	 * @param  array  $columns
+	 * @return \Analogue\ORM\EntityCollection
+	 */
+	public function getEntities($columns = ['*'])
+	{
+		// As we need the primary key to feed the
+		// entity cache, we need it loaded on each
+		// request
+		$columns = $this->enforceIdColumn($columns);
+
+		// Run the query
+		$results = $this->query->get($columns)->toArray();
+
+		// Create a result builder.
+		$builder = new ResultBuilder(Manager::getInstance(), $this->mapper, array_keys($this->getEagerLoads()));
+
+		return $builder->build($results);
+	}
+
+	/**
+	 * Get a new instance for the entity
+	 *
+	 * @return \Analogue\ORM\Entity
+	 */
+	public function getEntityInstance()
+	{
+		return $this->mapper->newInstance();
+	}
+
+	/**
+	 * Extend the builder with a given callback.
+	 *
+	 * @param  string   $name
+	 * @param  \Closure $callback
+	 * @return void
+	 */
+	public function macro($name, Closure $callback)
+	{
+		$this->macros[$name] = $callback;
+	}
+
+	/**
+	 * Get the given macro by name.
+	 *
+	 * @param  string $name
+	 * @return \Closure
+	 */
+	public function getMacro($name)
+	{
+		return array_get($this->macros, $name);
+	}
+
+	/**
+	 * Get a new query builder for the model's table.
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function newQuery()
+	{
+		$builder = new Query($this->mapper, $this->adapter);
+
+		return $this->applyGlobalScopes($builder);
+	}
+
+	/**
+	 * Get a new query builder without any scope applied.
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function newQueryWithoutScopes()
+	{
+		return new Query($this->mapper, $this->adapter);
+	}
+
+	/**
+	 * Get the Mapper instance for this Query Builder
+	 *
+	 * @return \Analogue\ORM\System\Mapper
+	 */
+	public function getMapper()
+	{
+		return $this->mapper;
+	}
+
+	/**
+	 * Get the underlying query adapter
+	 *
+	 * (REFACTOR: this method should move out, we need to provide the client classes
+	 * with the adapter instead.)
+	 *
+	 * @return \Analogue\ORM\Drivers\QueryAdapter|\Analogue\ORM\Drivers\IlluminateQueryAdapter
+	 */
+	public function getQuery()
+	{
+		return $this->query;
+	}
+
+	/**
+	 * Dynamically handle calls into the query instance.
+	 *
+	 * @param  string $method
+	 * @param  array  $parameters
+	 * @throws Exception
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		if (isset($this->macros[$method])) {
+			array_unshift($parameters, $this);
+
+			return call_user_func_array($this->macros[$method], $parameters);
+		}
+
+		if (in_array($method, $this->blacklist)) {
+			throw new Exception("Method $method doesn't exist");
+		}
+
+		$result = call_user_func_array([$this->query, $method], $parameters);
+
+		return in_array($method, $this->passthru) ? $result : $this;
+	}
 }
\ No newline at end of file