analogueorm / analogue

src/MappableTrait.php

Indentation +55 added lines, -55 removed lines

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

src/Entity.php

Indentation +97 added lines, -97 removed lines

@@ -6,112 +6,112 @@
 
 class Entity extends ValueObject
 {
-    /**
-     * Entities Hidden Attributes, that will be discarded when converting
-     * the entity to Array/Json
-     * (can include any embedded object's attribute)
-     *
-     * @var array
-     */
-    protected $hidden = [];
+	/**
+	 * Entities Hidden Attributes, that will be discarded when converting
+	 * the entity to Array/Json
+	 * (can include any embedded object's attribute)
+	 *
+	 * @var array
+	 */
+	protected $hidden = [];
 
-    /**
-     * Return the entity's attribute
-     * @param  string $key
-     * @return mixed
-     */
-    public function __get($key)
-    {
-        if ($this->hasGetMutator($key)) {
-            $method = 'get' . $this->getMutatorMethod($key);
+	/**
+	 * Return the entity's attribute
+	 * @param  string $key
+	 * @return mixed
+	 */
+	public function __get($key)
+	{
+		if ($this->hasGetMutator($key)) {
+			$method = 'get' . $this->getMutatorMethod($key);
 
-            $attribute = null;
+			$attribute = null;
 
-            if (isset($this->attributes[$key])) {
-                $attribute = $this->attributes[$key];
-            }
+			if (isset($this->attributes[$key])) {
+				$attribute = $this->attributes[$key];
+			}
 
-            return $this->$method($attribute);
-        }
-        if (!array_key_exists($key, $this->attributes)) {
-            return null;
-        }
-        if ($this->attributes[$key] instanceof EntityProxy) {
-            $this->attributes[$key] = $this->attributes[$key]->load();
-        }
-        return $this->attributes[$key];
-    }
+			return $this->$method($attribute);
+		}
+		if (!array_key_exists($key, $this->attributes)) {
+			return null;
+		}
+		if ($this->attributes[$key] instanceof EntityProxy) {
+			$this->attributes[$key] = $this->attributes[$key]->load();
+		}
+		return $this->attributes[$key];
+	}
 
-    /**
-     * Dynamically set attributes on the entity.
-     *
-     * @param  string $key
-     * @param  mixed  $value
-     * @return void
-     */
-    public function __set($key, $value)
-    {
-        if ($this->hasSetMutator($key)) {
-            $method = 'set' . $this->getMutatorMethod($key);
+	/**
+	 * Dynamically set attributes on the entity.
+	 *
+	 * @param  string $key
+	 * @param  mixed  $value
+	 * @return void
+	 */
+	public function __set($key, $value)
+	{
+		if ($this->hasSetMutator($key)) {
+			$method = 'set' . $this->getMutatorMethod($key);
 
-            $this->$method($value);
-        } else {
-            $this->attributes[$key] = $value;
-        }
-    }
+			$this->$method($value);
+		} else {
+			$this->attributes[$key] = $value;
+		}
+	}
 
-    /**
-     * Is a getter method defined ?
-     *
-     * @param  string $key
-     * @return boolean
-     */
-    protected function hasGetMutator($key)
-    {
-        return method_exists($this, 'get' . $this->getMutatorMethod($key)) ? true : false;
-    }
+	/**
+	 * Is a getter method defined ?
+	 *
+	 * @param  string $key
+	 * @return boolean
+	 */
+	protected function hasGetMutator($key)
+	{
+		return method_exists($this, 'get' . $this->getMutatorMethod($key)) ? true : false;
+	}
 
-    /**
-     * Is a setter method defined ?
-     *
-     * @param  string $key
-     * @return boolean
-     */
-    protected function hasSetMutator($key)
-    {
-        return method_exists($this, 'set' . $this->getMutatorMethod($key)) ? true : false;
-    }
+	/**
+	 * Is a setter method defined ?
+	 *
+	 * @param  string $key
+	 * @return boolean
+	 */
+	protected function hasSetMutator($key)
+	{
+		return method_exists($this, 'set' . $this->getMutatorMethod($key)) ? true : false;
+	}
 
-    /**
-     * @param $key
-     * @return string
-     */
-    protected function getMutatorMethod($key)
-    {
-        return ucfirst($key) . 'Attribute';
-    }
+	/**
+	 * @param $key
+	 * @return string
+	 */
+	protected function getMutatorMethod($key)
+	{
+		return ucfirst($key) . 'Attribute';
+	}
 
-    /**
-     * Convert every attributes to value / arrays
-     *
-     * @return array
-     */
-    public function toArray()
-    {
-        // First, call the trait method before filtering
-        // with Entity specific methods
-        $attributes = $this->attributesToArray($this->attributes);
+	/**
+	 * Convert every attributes to value / arrays
+	 *
+	 * @return array
+	 */
+	public function toArray()
+	{
+		// First, call the trait method before filtering
+		// with Entity specific methods
+		$attributes = $this->attributesToArray($this->attributes);
         
-        foreach ($this->attributes as $key => $attribute) {
-            if (in_array($key, $this->hidden)) {
-                unset($attributes[$key]);
-                continue;
-            }
-            if ($this->hasGetMutator($key)) {
-                $method = 'get' . $this->getMutatorMethod($key);
-                $attributes[$key] = $this->$method($attribute);
-            }
-        }
-        return $attributes;
-    }
+		foreach ($this->attributes as $key => $attribute) {
+			if (in_array($key, $this->hidden)) {
+				unset($attributes[$key]);
+				continue;
+			}
+			if ($this->hasGetMutator($key)) {
+				$method = 'get' . $this->getMutatorMethod($key);
+				$attributes[$key] = $this->$method($attribute);
+			}
+		}
+		return $attributes;
+	}
 }

Spacing +6 added lines, -6 removed lines

@@ -23,7 +23,7 @@ 
     public function __get($key)
     {
         if ($this->hasGetMutator($key)) {
-            $method = 'get' . $this->getMutatorMethod($key);
+            $method = 'get'.$this->getMutatorMethod($key);
 
             $attribute = null;
 
@@ -52,7 +52,7 @@ 
     public function __set($key, $value)
     {
         if ($this->hasSetMutator($key)) {
-            $method = 'set' . $this->getMutatorMethod($key);
+            $method = 'set'.$this->getMutatorMethod($key);
 
             $this->$method($value);
         } else {
@@ -68,7 +68,7 @@ 
      */
     protected function hasGetMutator($key)
     {
-        return method_exists($this, 'get' . $this->getMutatorMethod($key)) ? true : false;
+        return method_exists($this, 'get'.$this->getMutatorMethod($key)) ? true : false;
     }
 
     /**
@@ -79,7 +79,7 @@ 
      */
     protected function hasSetMutator($key)
     {
-        return method_exists($this, 'set' . $this->getMutatorMethod($key)) ? true : false;
+        return method_exists($this, 'set'.$this->getMutatorMethod($key)) ? true : false;
     }
 
     /**
@@ -88,7 +88,7 @@ 
      */
     protected function getMutatorMethod($key)
     {
-        return ucfirst($key) . 'Attribute';
+        return ucfirst($key).'Attribute';
     }
 
     /**
@@ -108,7 +108,7 @@ 
                 continue;
             }
             if ($this->hasGetMutator($key)) {
-                $method = 'get' . $this->getMutatorMethod($key);
+                $method = 'get'.$this->getMutatorMethod($key);
                 $attributes[$key] = $this->$method($attribute);
             }
         }

src/Exceptions/EntityNotFoundException.php

Indentation +27 added lines, -27 removed lines

@@ -6,35 +6,35 @@
 
 class EntityNotFoundException extends RuntimeException
 {
-    /**
-     * Name of the affected Entity Map.
-     *
-     * @var string
-     */
-    protected $entity;
+	/**
+	 * Name of the affected Entity Map.
+	 *
+	 * @var string
+	 */
+	protected $entity;
 
-    /**
-     * Set the affected Entity Map.
-     *
-     * @param  string   $entity
-     * @return $this
-     */
-    public function setEntity($entity)
-    {
-        $this->entity = $entity;
+	/**
+	 * Set the affected Entity Map.
+	 *
+	 * @param  string   $entity
+	 * @return $this
+	 */
+	public function setEntity($entity)
+	{
+		$this->entity = $entity;
 
-        $this->message = "No query results for entity [{$entity}].";
+		$this->message = "No query results for entity [{$entity}].";
 
-        return $this;
-    }
+		return $this;
+	}
 
-    /**
-     * Get the affected Entity.
-     *
-     * @return string
-     */
-    public function getEntity()
-    {
-        return $this->entity;
-    }
+	/**
+	 * Get the affected Entity.
+	 *
+	 * @return string
+	 */
+	public function getEntity()
+	{
+		return $this->entity;
+	}
 }

src/EntityMap.php

Indentation +1147 added lines, -1147 removed lines

@@ -23,1165 +23,1165 @@
  */
 class EntityMap
 {
-    /**
-     * The mapping driver to use with this entity
-     */
-    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';
-
-    /**
-     * Array containing a list of class attributes. Mandatory if the
-     * mapped entity is a Plain PHP Object.
-     *
-     * @var array
-     */
-    protected $attributes = [];
-
-    /**
-     * The Custom Domain Class to use with this mapping
-     *
-     * @var string|null
-     */
-    protected $class = null;
-
-    /**
-     * Attributes that should be treated as Value Objects
-     *
-     * @var array
-     */
-    protected $embeddables = [];
+	/**
+	 * The mapping driver to use with this entity
+	 */
+	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';
+
+	/**
+	 * Array containing a list of class attributes. Mandatory if the
+	 * mapped entity is a Plain PHP Object.
+	 *
+	 * @var array
+	 */
+	protected $attributes = [];
+
+	/**
+	 * The Custom Domain Class to use with this mapping
+	 *
+	 * @var string|null
+	 */
+	protected $class = null;
+
+	/**
+	 * Attributes that should be treated as 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 = [];
-
-    /**
-     * 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 = [];
-
-    /**
-     * 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 many to many relationship methods.
-     *
-     * @var array
-     */
-    protected static $manyMethods = ['belongsToMany', 'morphToMany', 'morphedByMany'];
-
-    /**
-     * The 'Many' relationships classes, which related Entity attribute should be
-     * an array/entityCollection
-     *
-     * @var array
-     */
-    protected static $manyClasses = ['BelongsToMany', 'HasMany', 'HasManyThrough', 'MorphMany', 'MorphToMany'];
-
-    /**
-     * The 'Single' relationships classes, which related Entity attribute should be
-     * another Entity.
-     *
-     * @var array
-     */
-    protected static $singleClasses = ['BelongsTo', 'HasOne', 'MorphOne', 'MorphTo'];
-
-    /**
-     * Relationships with a pivot record
-     *
-     * @var array
-     */
-    protected static $pivotClasses = ['BelongsToMany', 'MorphToMany'];
-
-    /**
-     * Relationships on which key is stored in the Entity itself
-     *
-     * @var array
-     */
-    protected static $localClasses = ['BelongsTo', 'MorphTo'];
-
-    /**
-     * Relationships on which key is stored in the related Entity record or in a pivot record
-     *
-     * @var array
-     */
-    protected static $foreignClasses = [
-        'BelongsToMany',
-        'HasMany',
-        'HasManyThrough',
-        'MorphMany',
-        'MorphToMany',
-        'HasOne',
-        'MorphOne',
-    ];
-
-    /**
-     * The date format to use with the current database connection
-     *
-     * @var string
-     */
-    protected $dateFormat;
-
-    /**
-     * The Analogue's manager instance.
-     *
-     * @var \Analogue\ORM\System\Manager
-     */
-    private $manager;
-
-    /**
-     * Set the Manager that will be used for relationship's mapper instantiations.
-     *
-     * @param Manager $manager
-     */
-    public function setManager(Manager $manager)
-    {
-        $this->manager = $manager;
-    }
-
-    /**
-     * 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;
-    }
+	/**
+	 * 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 = [];
+
+	/**
+	 * 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 = [];
+
+	/**
+	 * 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 many to many relationship methods.
+	 *
+	 * @var array
+	 */
+	protected static $manyMethods = ['belongsToMany', 'morphToMany', 'morphedByMany'];
+
+	/**
+	 * The 'Many' relationships classes, which related Entity attribute should be
+	 * an array/entityCollection
+	 *
+	 * @var array
+	 */
+	protected static $manyClasses = ['BelongsToMany', 'HasMany', 'HasManyThrough', 'MorphMany', 'MorphToMany'];
+
+	/**
+	 * The 'Single' relationships classes, which related Entity attribute should be
+	 * another Entity.
+	 *
+	 * @var array
+	 */
+	protected static $singleClasses = ['BelongsTo', 'HasOne', 'MorphOne', 'MorphTo'];
+
+	/**
+	 * Relationships with a pivot record
+	 *
+	 * @var array
+	 */
+	protected static $pivotClasses = ['BelongsToMany', 'MorphToMany'];
+
+	/**
+	 * Relationships on which key is stored in the Entity itself
+	 *
+	 * @var array
+	 */
+	protected static $localClasses = ['BelongsTo', 'MorphTo'];
+
+	/**
+	 * Relationships on which key is stored in the related Entity record or in a pivot record
+	 *
+	 * @var array
+	 */
+	protected static $foreignClasses = [
+		'BelongsToMany',
+		'HasMany',
+		'HasManyThrough',
+		'MorphMany',
+		'MorphToMany',
+		'HasOne',
+		'MorphOne',
+	];
+
+	/**
+	 * The date format to use with the current database connection
+	 *
+	 * @var string
+	 */
+	protected $dateFormat;
+
+	/**
+	 * The Analogue's manager instance.
+	 *
+	 * @var \Analogue\ORM\System\Manager
+	 */
+	private $manager;
+
+	/**
+	 * Set the Manager that will be used for relationship's mapper instantiations.
+	 *
+	 * @param Manager $manager
+	 */
+	public function setManager(Manager $manager)
+	{
+		$this->manager = $manager;
+	}
+
+	/**
+	 * 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;
-        }
+	/**
+	 * 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)
-    {
-        // Throw exception if class not exists
-
-        $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;
-    }
-
-    /**
-     * 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;
-    }
-
-    /**
-     * 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;
-    }
-
-    /**
-     * 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;
-    }
+		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)
+	{
+		// Throw exception if class not exists
+
+		$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;
+	}
+
+	/**
+	 * 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;
+	}
+
+	/**
+	 * 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;
+	}
+
+	/**
+	 * 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;
-    }
+	/**
+	 * 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';
-    }
-
-    /**
-     * Define a one-to-one relationship.
-     *
-     * @param         $entity
-     * @param  string $relatedClass entity class
-     * @param  string $foreignKey
-     * @param  string $localKey
-     * @throws MappingException
-     * @return \Analogue\ORM\Relationships\HasOne
-     */
-    public function hasOne($entity, $relatedClass, $foreignKey = null, $localKey = null)
-    {
-        $foreignKey = $foreignKey ?: $this->getForeignKey();
-
-        $relatedMapper = $this->manager->mapper($relatedClass);
-
-        $relatedMap = $relatedMapper->getEntityMap();
-
-        $localKey = $localKey ?: $this->getKeyName();
-
-        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 = $this->manager->mapper($related);
-
-        $table = $relatedMapper->getEntityMap()->getTable();
+	/**
+	 * 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';
+	}
+
+	/**
+	 * Define a one-to-one relationship.
+	 *
+	 * @param         $entity
+	 * @param  string $relatedClass entity class
+	 * @param  string $foreignKey
+	 * @param  string $localKey
+	 * @throws MappingException
+	 * @return \Analogue\ORM\Relationships\HasOne
+	 */
+	public function hasOne($entity, $relatedClass, $foreignKey = null, $localKey = null)
+	{
+		$foreignKey = $foreignKey ?: $this->getForeignKey();
+
+		$relatedMapper = $this->manager->mapper($relatedClass);
+
+		$relatedMap = $relatedMapper->getEntityMap();
+
+		$localKey = $localKey ?: $this->getKeyName();
+
+		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 = $this->manager->mapper($related);
+
+		$table = $relatedMapper->getEntityMap()->getTable();
         
-        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, $relation = null)
-    {
-        // If no relation name was given, we will use this debug backtrace to extract
-        // the calling method's name and use that as the relationship name as most
-        // of the time this will be what we desire to use for the relationships.
-        if (is_null($relation)) {
-            list(, $caller) = debug_backtrace(false);
-
-            $relation = $caller['function'];
-        }
-
-        // 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';
-        }
-
-        $relatedMapper = $this->manager->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']);
-        }
-
-        list($type, $id) = $this->getMorphs($name, $type, $id);
+		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, $relation = null)
+	{
+		// If no relation name was given, we will use this debug backtrace to extract
+		// the calling method's name and use that as the relationship name as most
+		// of the time this will be what we desire to use for the relationships.
+		if (is_null($relation)) {
+			list(, $caller) = debug_backtrace(false);
+
+			$relation = $caller['function'];
+		}
+
+		// 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';
+		}
+
+		$relatedMapper = $this->manager->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']);
+		}
+
+		list($type, $id) = $this->getMorphs($name, $type, $id);
         
-        $mapper = $this->manager->mapper(get_class($entity));
+		$mapper = $this->manager->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 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 {
-            $relatedMapper = $this->manager->mapper($class);
-
-            $foreignKey = $relatedMapper->getEntityMap()->getKeyName();
+		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 {
+			$relatedMapper = $this->manager->mapper($class);
+
+			$foreignKey = $relatedMapper->getEntityMap()->getKeyName();
             
-            return new MorphTo(
-                $mapper, $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 = $this->manager->mapper($related);
-
-        $table = $relatedMapper->getEntityMap()->getTable() . '.' . $foreignKey;
-
-        $localKey = $localKey ?: $this->getKeyName();
-
-        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 = $this->manager->mapper($related);
-
-        $throughMapper = $this->manager->mapper($through);
-
-
-        $firstKey = $firstKey ?: $this->getForeignKey();
-
-        $throughMap = $throughMapper->getEntityMap();
-
-        $secondKey = $secondKey ?: $throughMap->getForeignKey();
-
-        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 = $this->manager->mapper($related);
-
-        $table = $relatedMapper->getEntityMap()->getTable();
-
-        $localKey = $localKey ?: $this->getKeyName();
+			return new MorphTo(
+				$mapper, $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 = $this->manager->mapper($related);
+
+		$table = $relatedMapper->getEntityMap()->getTable() . '.' . $foreignKey;
+
+		$localKey = $localKey ?: $this->getKeyName();
+
+		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 = $this->manager->mapper($related);
+
+		$throughMapper = $this->manager->mapper($through);
+
+
+		$firstKey = $firstKey ?: $this->getForeignKey();
+
+		$throughMap = $throughMapper->getEntityMap();
+
+		$secondKey = $secondKey ?: $throughMap->getForeignKey();
+
+		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 = $this->manager->mapper($related);
+
+		$table = $relatedMapper->getEntityMap()->getTable();
+
+		$localKey = $localKey ?: $this->getKeyName();
         
-        return new MorphMany($relatedMapper, $entity, $table . '.' . $type, $table . '.' . $id, $localKey);
-    }
-
-    /**
-     * Define a many-to-many relationship.
-     *
-     * @param  mixed       $entity
-     * @param  string      $related
-     * @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, $relation = null)
-    {
-        // If no relationship name was passed, we will pull backtraces to get the
-        // name of the calling function. We will use that function name as the
-        // title of this relation since that is a great convention to apply.
-        if (is_null($relation)) {
-            $relation = $this->getBelongsToManyCaller();
-        }
-
-        // 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 = $this->manager->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)
-    {
-        $caller = $this->getBelongsToManyCaller();
-
-        // 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 = $this->manager->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)
-    {
-        $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 relationship name of the belongs to many.
-     *
-     * @return string
-     */
-    protected function getBelongsToManyCaller()
-    {
-        $self = __FUNCTION__;
-
-        $caller = array_first(debug_backtrace(false), function ($key, $trace) use ($self) {
-            $caller = $trace['function'];
-
-            return (!in_array($caller, EntityMap::$manyMethods) && $caller != $self);
-        });
-
-        return !is_null($caller) ? $caller['function'] : null;
-    }
-
-    /**
-     * 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()
-    {
-        return $this->morphClass ?: $this->getClass();
-    }
+		return new MorphMany($relatedMapper, $entity, $table . '.' . $type, $table . '.' . $id, $localKey);
+	}
+
+	/**
+	 * Define a many-to-many relationship.
+	 *
+	 * @param  mixed       $entity
+	 * @param  string      $related
+	 * @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, $relation = null)
+	{
+		// If no relationship name was passed, we will pull backtraces to get the
+		// name of the calling function. We will use that function name as the
+		// title of this relation since that is a great convention to apply.
+		if (is_null($relation)) {
+			$relation = $this->getBelongsToManyCaller();
+		}
+
+		// 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 = $this->manager->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)
+	{
+		$caller = $this->getBelongsToManyCaller();
+
+		// 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 = $this->manager->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)
+	{
+		$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 relationship name of the belongs to many.
+	 *
+	 * @return string
+	 */
+	protected function getBelongsToManyCaller()
+	{
+		$self = __FUNCTION__;
+
+		$caller = array_first(debug_backtrace(false), function ($key, $trace) use ($self) {
+			$caller = $trace['function'];
+
+			return (!in_array($caller, EntityMap::$manyMethods) && $caller != $self);
+		});
+
+		return !is_null($caller) ? $caller['function'] : null;
+	}
+
+	/**
+	 * 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()
+	{
+		return $this->morphClass ?: $this->getClass();
+	}
     
-    /**
-     * Create a new Entity Collection instance.
-     *
-     * @param  array $entities
-     * @return \Analogue\ORM\EntityCollection
-     */
-    public function newCollection(array $entities = [])
-    {
-        return new EntityCollection($entities, $this);
-    }
-
-    /**
-     * 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');
+	/**
+	 * Create a new Entity Collection instance.
+	 *
+	 * @param  array $entities
+	 * @return \Analogue\ORM\EntityCollection
+	 */
+	public function newCollection(array $entities = [])
+	{
+		return new EntityCollection($entities, $this);
+	}
+
+	/**
+	 * 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) {
-                    $relationships[] = $methodName;
-                }
-            }
-        }
-
-        return $relationships;
-    }
-
-    /**
-     * Sort Relationships methods by type
-     *
-     * @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));
+		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) {
+					$relationships[] = $methodName;
+				}
+			}
+		}
+
+		return $relationships;
+	}
+
+	/**
+	 * Sort Relationships methods by type
+	 *
+	 * @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) {
-            $relationObject = $this->$relation($entity);
-
-            $class = class_basename(get_class($relationObject));
-
-            if (in_array($class, static::$singleClasses)) {
-                $this->singleRelations[] = $relation;
-            }
-
-            if (in_array($class, static::$manyClasses)) {
-                $this->manyRelations[] = $relation;
-            }
-
-            if (in_array($class, static::$localClasses)) {
-                $this->localRelations[] = $relation;
-            }
-
-            if (in_array($class, static::$foreignClasses)) {
-                $this->foreignRelations[] = $relation;
-            }
-
-            if (in_array($class, static::$pivotClasses)) {
-                $this->pivotRelations[] = $relation;
-            }
-        }
-    }
-
-    /**
-     * 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]);
-    }
+		foreach ($this->relationships as $relation) {
+			$relationObject = $this->$relation($entity);
+
+			$class = class_basename(get_class($relationObject));
+
+			if (in_array($class, static::$singleClasses)) {
+				$this->singleRelations[] = $relation;
+			}
+
+			if (in_array($class, static::$manyClasses)) {
+				$this->manyRelations[] = $relation;
+			}
+
+			if (in_array($class, static::$localClasses)) {
+				$this->localRelations[] = $relation;
+			}
+
+			if (in_array($class, static::$foreignClasses)) {
+				$this->foreignRelations[] = $relation;
+			}
+
+			if (in_array($class, static::$pivotClasses)) {
+				$this->pivotRelations[] = $relation;
+			}
+		}
+	}
+
+	/**
+	 * 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]);
+	}
 }

Spacing +14 added lines, -14 removed lines

@@ -393,7 +393,7 @@ 
         if (!is_null($this->sequence)) {
             return $this->sequence;
         } else {
-            return $this->getTable() . '_id_seq';
+            return $this->getTable().'_id_seq';
         }
     }
 
@@ -563,7 +563,7 @@ 
      */
     public function getQualifiedKeyName()
     {
-        return $this->getTable() . '.' . $this->getKeyName();
+        return $this->getTable().'.'.$this->getKeyName();
     }
 
     /**
@@ -644,7 +644,7 @@ 
      */
     public function getForeignKey()
     {
-        return snake_case(class_basename($this->getClass())) . '_id';
+        return snake_case(class_basename($this->getClass())).'_id';
     }
 
     /**
@@ -667,7 +667,7 @@ 
 
         $localKey = $localKey ?: $this->getKeyName();
 
-        return new HasOne($relatedMapper, $entity, $relatedMap->getTable() . '.' . $foreignKey, $localKey);
+        return new HasOne($relatedMapper, $entity, $relatedMap->getTable().'.'.$foreignKey, $localKey);
     }
 
     /**
@@ -692,7 +692,7 @@ 
 
         $table = $relatedMapper->getEntityMap()->getTable();
         
-        return new MorphOne($relatedMapper, $entity, $table . '.' . $type, $table . '.' . $id, $localKey);
+        return new MorphOne($relatedMapper, $entity, $table.'.'.$type, $table.'.'.$id, $localKey);
     }
 
     /**
@@ -721,7 +721,7 @@ 
         // 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';
+            $foreignKey = snake_case($relation).'_id';
         }
 
         $relatedMapper = $this->manager->mapper($related);
@@ -798,7 +798,7 @@ 
 
         $relatedMapper = $this->manager->mapper($related);
 
-        $table = $relatedMapper->getEntityMap()->getTable() . '.' . $foreignKey;
+        $table = $relatedMapper->getEntityMap()->getTable().'.'.$foreignKey;
 
         $localKey = $localKey ?: $this->getKeyName();
 
@@ -856,7 +856,7 @@ 
 
         $localKey = $localKey ?: $this->getKeyName();
         
-        return new MorphMany($relatedMapper, $entity, $table . '.' . $type, $table . '.' . $id, $localKey);
+        return new MorphMany($relatedMapper, $entity, $table.'.'.$type, $table.'.'.$id, $localKey);
     }
 
     /**
@@ -921,7 +921,7 @@ 
         // 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';
+        $foreignKey = $foreignKey ?: $name.'_id';
 
         $relatedMapper = $this->manager->mapper($related);
 
@@ -951,7 +951,7 @@ 
         // 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';
+        $otherKey = $otherKey ?: $name.'_id';
 
         return $this->morphToMany($entity, $related, $name, $table, $foreignKey, $otherKey, true);
     }
@@ -965,7 +965,7 @@ 
     {
         $self = __FUNCTION__;
 
-        $caller = array_first(debug_backtrace(false), function ($key, $trace) use ($self) {
+        $caller = array_first(debug_backtrace(false), function($key, $trace) use ($self) {
             $caller = $trace['function'];
 
             return (!in_array($caller, EntityMap::$manyMethods) && $caller != $self);
@@ -1009,9 +1009,9 @@ 
      */
     protected function getMorphs($name, $type, $id)
     {
-        $type = $type ?: $name . '_type';
+        $type = $type ?: $name.'_type';
 
-        $id = $id ?: $name . '_id';
+        $id = $id ?: $name.'_id';
 
         return [$type, $id];
     }
@@ -1176,7 +1176,7 @@ 
     public function __call($method, $parameters)
     {
         if (!array_key_exists($method, $this->dynamicRelationships)) {
-            throw new Exception(get_class($this) . " has no method $method");
+            throw new Exception(get_class($this)." has no method $method");
         }
 
         // Add $this to parameters so the closure can call relationship method on the map.

src/System/Aggregate.php

Indentation +992 added lines, -992 removed lines

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

Spacing +3 added lines, -3 removed lines

@@ -350,7 +350,7 @@ 
      */
     public function getEntityHash()
     {
-        return $this->getEntityClass() . '.' . $this->getEntityId();
+        return $this->getEntityClass().'.'.$this->getEntityId();
     }
 
     /**
@@ -566,7 +566,7 @@ 
             $prefix = snake_case(class_basename($embed));
 
             foreach ($valueObjectAttributes as $key=>$value) {
-                $valueObjectAttributes[$prefix . '_' . $key] = $value;
+                $valueObjectAttributes[$prefix.'_'.$key] = $value;
                 unset($valueObjectAttributes[$key]);
             }
 
@@ -854,7 +854,7 @@ 
      */
     protected function getEntityHashesFromRelation($relation)
     {
-        return array_map(function ($aggregate) {
+        return array_map(function($aggregate) {
             return $aggregate->getEntityHash();
         }, $this->relationships[$relation]);
     }

src/System/ScopeInterface.php

Indentation +14 added lines, -14 removed lines

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

src/System/CachedRelationship.php

Indentation +58 added lines, -58 removed lines

@@ -8,68 +8,68 @@
  */
 class CachedRelationship
 {
-    /**
-     * The Hash of the related entity
-     *
-     * @var string
-     */
-    protected $hash;
+	/**
+	 * The Hash of the related entity
+	 *
+	 * @var string
+	 */
+	protected $hash;
 
-    /**
-     * Pivot attributes, if any
-     *
-     * @var array
-     */
-    protected $pivotAttributes;
+	/**
+	 * Pivot attributes, if any
+	 *
+	 * @var array
+	 */
+	protected $pivotAttributes;
 
-    /**
-     * CachedRelationship constructor.
-     * @param $hash
-     * @param array $pivotAttributes
-     */
-    public function __construct($hash, $pivotAttributes = [])
-    {
-        $this->hash = $hash;
-        $this->pivotAttributes = $pivotAttributes;
-    }
+	/**
+	 * CachedRelationship constructor.
+	 * @param $hash
+	 * @param array $pivotAttributes
+	 */
+	public function __construct($hash, $pivotAttributes = [])
+	{
+		$this->hash = $hash;
+		$this->pivotAttributes = $pivotAttributes;
+	}
 
-    /**
-     * Return true if any pivot attributes are present
-     *
-     * @return boolean
-     */
-    public function hasPivotAttributes()
-    {
-        return count($this->pivotAttributes) > 0;
-    }
+	/**
+	 * Return true if any pivot attributes are present
+	 *
+	 * @return boolean
+	 */
+	public function hasPivotAttributes()
+	{
+		return count($this->pivotAttributes) > 0;
+	}
 
-    /**
-     * Returns the hash of the related entity
-     *
-     * @return string
-     */
-    public function getHash()
-    {
-        return $this->hash;
-    }
+	/**
+	 * Returns the hash of the related entity
+	 *
+	 * @return string
+	 */
+	public function getHash()
+	{
+		return $this->hash;
+	}
 
-    /**
-     * Get the cached values for the pivot attributes
-     *
-     * @return array
-     */
-    public function getPivotAttributes()
-    {
-        return $this->pivotAttributes;
-    }
+	/**
+	 * Get the cached values for the pivot attributes
+	 *
+	 * @return array
+	 */
+	public function getPivotAttributes()
+	{
+		return $this->pivotAttributes;
+	}
 
-    /**
-     * Access to the hash for fast cache comparison
-     *
-     * @return string
-     */
-    public function __toString()
-    {
-        return $this->hash;
-    }
+	/**
+	 * Access to the hash for fast cache comparison
+	 *
+	 * @return string
+	 */
+	public function __toString()
+	{
+		return $this->hash;
+	}
 }

src/System/Manager.php

Indentation +431 added lines, -431 removed lines

@@ -15,439 +15,439 @@
  */
 class Manager
 {
-    /**
-     * Driver Manager
-     *
-     * @var \Analogue\ORM\Drivers\Manager
-     */
-    protected $drivers;
-
-    /**
-     * Registered entity classes and corresponding map objects.
-     *
-     * @var array
-     */
-    protected $entityClasses = [];
-
-    /**
-     * Key value store of ValueObject Classes and corresponding map classes
-     *
-     * @var array
-     */
-    protected $valueClasses = [];
-
-    /**
-     * Loaded Mappers
-     *
-     * @var array
-     */
-    protected $mappers = [];
-
-    /**
-     * Loaded Repositories
-     *
-     * @var array
-     */
-    protected $repositories = [];
-
-    /**
-     * Event dispatcher instance
-     *
-     * @var \Illuminate\Contracts\Events\Dispatcher
-     */
-    protected $eventDispatcher;
-
-    /**
-     * Manager instance
-     *
-     * @var Manager
-     */
-    protected static $instance;
-
-    /**
-     * Available Analogue Events
-     *
-     * @var array
-     */
-    protected $events = [
-        'initializing',
-        'initialized',
-        'store',
-        'stored',
-        'creating',
-        'created',
-        'updating',
-        'updated',
-        'deleting',
-        'deleted',
-    ];
-
-    /**
-     * @param \Analogue\ORM\Drivers\Manager $driverManager
-     * @param Dispatcher $event
-     */
-    public function __construct(DriverManager $driverManager, Dispatcher $event)
-    {
-        $this->drivers = $driverManager;
-
-        $this->eventDispatcher = $event;
-
-        static::$instance = $this;
-    }
-
-    /**
-     * Return the Driver Manager's instance
-     *
-     * @return \Analogue\ORM\Drivers\Manager
-     */
-    public function getDriverManager()
-    {
-        return $this->drivers;
-    }
-
-    /**
-     * Create a mapper for a given entity
-     *
-     * @param  \Analogue\ORM\Mappable|string $entity
-     * @param  mixed                         $entityMap
-     * @throws MappingException
-     * @return Mapper
-     */
-    public function mapper($entity, $entityMap = null)
-    {
-        if ($entity instanceof Wrapper) {
-            throw new MappingException('Tried to instantiate mapper on wrapped Entity');
-        }
-
-        if (!is_string($entity)) {
-            $entity = get_class($entity);
-        }
-
-        // Return existing mapper instance if exists.
-        if (array_key_exists($entity, $this->mappers)) {
-            return $this->mappers[$entity];
-        } else {
-            return $this->buildMapper($entity, $entityMap);
-        }
-    }
-
-    /**
-     * Build a new Mapper instance for a given Entity
-     *
-     * @param  string $entity
-     * @param         $entityMap
-     * @throws MappingException
-     * @return Mapper
-     */
-    protected function buildMapper($entity, $entityMap)
-    {
-        // If an EntityMap hasn't been manually registered by the user
-        // register it at runtime.
-        if (!$this->isRegisteredEntity($entity)) {
-            $this->register($entity, $entityMap);
-        }
-
-        $entityMap = $this->entityClasses[$entity];
-
-        $factory = new MapperFactory($this->drivers, $this->eventDispatcher, $this);
-
-        $mapper = $factory->make($entity, $entityMap);
-
-        $this->mappers[$entity] = $mapper;
-
-        // At this point we can safely call the boot() method on the entityMap as
-        // the mapper is now instantiated & registered within the manager.
-
-        $mapper->getEntityMap()->boot();
+	/**
+	 * Driver Manager
+	 *
+	 * @var \Analogue\ORM\Drivers\Manager
+	 */
+	protected $drivers;
+
+	/**
+	 * Registered entity classes and corresponding map objects.
+	 *
+	 * @var array
+	 */
+	protected $entityClasses = [];
+
+	/**
+	 * Key value store of ValueObject Classes and corresponding map classes
+	 *
+	 * @var array
+	 */
+	protected $valueClasses = [];
+
+	/**
+	 * Loaded Mappers
+	 *
+	 * @var array
+	 */
+	protected $mappers = [];
+
+	/**
+	 * Loaded Repositories
+	 *
+	 * @var array
+	 */
+	protected $repositories = [];
+
+	/**
+	 * Event dispatcher instance
+	 *
+	 * @var \Illuminate\Contracts\Events\Dispatcher
+	 */
+	protected $eventDispatcher;
+
+	/**
+	 * Manager instance
+	 *
+	 * @var Manager
+	 */
+	protected static $instance;
+
+	/**
+	 * Available Analogue Events
+	 *
+	 * @var array
+	 */
+	protected $events = [
+		'initializing',
+		'initialized',
+		'store',
+		'stored',
+		'creating',
+		'created',
+		'updating',
+		'updated',
+		'deleting',
+		'deleted',
+	];
+
+	/**
+	 * @param \Analogue\ORM\Drivers\Manager $driverManager
+	 * @param Dispatcher $event
+	 */
+	public function __construct(DriverManager $driverManager, Dispatcher $event)
+	{
+		$this->drivers = $driverManager;
+
+		$this->eventDispatcher = $event;
+
+		static::$instance = $this;
+	}
+
+	/**
+	 * Return the Driver Manager's instance
+	 *
+	 * @return \Analogue\ORM\Drivers\Manager
+	 */
+	public function getDriverManager()
+	{
+		return $this->drivers;
+	}
+
+	/**
+	 * Create a mapper for a given entity
+	 *
+	 * @param  \Analogue\ORM\Mappable|string $entity
+	 * @param  mixed                         $entityMap
+	 * @throws MappingException
+	 * @return Mapper
+	 */
+	public function mapper($entity, $entityMap = null)
+	{
+		if ($entity instanceof Wrapper) {
+			throw new MappingException('Tried to instantiate mapper on wrapped Entity');
+		}
+
+		if (!is_string($entity)) {
+			$entity = get_class($entity);
+		}
+
+		// Return existing mapper instance if exists.
+		if (array_key_exists($entity, $this->mappers)) {
+			return $this->mappers[$entity];
+		} else {
+			return $this->buildMapper($entity, $entityMap);
+		}
+	}
+
+	/**
+	 * Build a new Mapper instance for a given Entity
+	 *
+	 * @param  string $entity
+	 * @param         $entityMap
+	 * @throws MappingException
+	 * @return Mapper
+	 */
+	protected function buildMapper($entity, $entityMap)
+	{
+		// If an EntityMap hasn't been manually registered by the user
+		// register it at runtime.
+		if (!$this->isRegisteredEntity($entity)) {
+			$this->register($entity, $entityMap);
+		}
+
+		$entityMap = $this->entityClasses[$entity];
+
+		$factory = new MapperFactory($this->drivers, $this->eventDispatcher, $this);
+
+		$mapper = $factory->make($entity, $entityMap);
+
+		$this->mappers[$entity] = $mapper;
+
+		// At this point we can safely call the boot() method on the entityMap as
+		// the mapper is now instantiated & registered within the manager.
+
+		$mapper->getEntityMap()->boot();
         
-        return $mapper;
-    }
-
-    /**
-     * Create a mapper for a given entity (static alias)
-     *
-     * @param  \Analogue\ORM\Mappable|string $entity
-     * @param  null|EntityMap                $entityMap
-     * @throws MappingException
-     * @return Mapper
-     */
-    public static function getMapper($entity, $entityMap = null)
-    {
-        return static::$instance->mapper($entity, $entityMap);
-    }
-
-    /**
-     * Get the Repository instance for the given Entity
-     *
-     * @param  \Analogue\ORM\Mappable|string $entity
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     * @return \Analogue\ORM\Repository
-     */
-    public function repository($entity)
-    {
-        if (!is_string($entity)) {
-            $entity = get_class($entity);
-        }
-
-        // First we check if the repository is not already created.
-        if (array_key_exists($entity, $this->repositories)) {
-            return $this->repositories[$entity];
-        }
-
-        $this->repositories[$entity] = new Repository($this->mapper($entity));
+		return $mapper;
+	}
+
+	/**
+	 * Create a mapper for a given entity (static alias)
+	 *
+	 * @param  \Analogue\ORM\Mappable|string $entity
+	 * @param  null|EntityMap                $entityMap
+	 * @throws MappingException
+	 * @return Mapper
+	 */
+	public static function getMapper($entity, $entityMap = null)
+	{
+		return static::$instance->mapper($entity, $entityMap);
+	}
+
+	/**
+	 * Get the Repository instance for the given Entity
+	 *
+	 * @param  \Analogue\ORM\Mappable|string $entity
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 * @return \Analogue\ORM\Repository
+	 */
+	public function repository($entity)
+	{
+		if (!is_string($entity)) {
+			$entity = get_class($entity);
+		}
+
+		// First we check if the repository is not already created.
+		if (array_key_exists($entity, $this->repositories)) {
+			return $this->repositories[$entity];
+		}
+
+		$this->repositories[$entity] = new Repository($this->mapper($entity));
         
-        return $this->repositories[$entity];
-    }
-
-    /**
-     * Register an entity
-     *
-     * @param  string|\Analogue\ORM\Mappable $entity    entity's class name
-     * @param  string|EntityMap              $entityMap map's class name
-     * @throws MappingException
-     * @return void
-     */
-    public function register($entity, $entityMap = null)
-    {
-        // If an object is provider, get the class name from it
-        if (!is_string($entity)) {
-            $entity = get_class($entity);
-        }
-
-        if ($this->isRegisteredEntity($entity)) {
-            throw new MappingException("Entity $entity is already registered.");
-        }
-
-        if (!class_exists($entity)) {
-            throw new MappingException("Class $entity does not exists");
-        }
-
-        if (is_null($entityMap)) {
-            $entityMap = $this->getEntityMapInstanceFor($entity);
-        }
-
-        if (is_string($entityMap)) {
-            $entityMap = new $entityMap;
-        }
-
-        if (!$entityMap instanceof EntityMap) {
-            throw new MappingException(get_class($entityMap) . ' must be an instance of EntityMap.');
-        }
-
-        $entityMap->setClass($entity);
-
-        $entityMap->setManager($this);
-
-        $this->entityClasses[$entity] = $entityMap;
-    }
-
-    /**
-     * Get the entity map instance for a custom entity
-     *
-     * @param  string   $entity
-     * @return \Analogue\ORM\Mappable
-     */
-    protected function getEntityMapInstanceFor($entity)
-    {
-        if (class_exists($entity . 'Map')) {
-            $map = $entity . 'Map';
-            $map = new $map;
-        } else {
-            // Generate an EntityMap object
-            $map = $this->getNewEntityMap();
-        }
+		return $this->repositories[$entity];
+	}
+
+	/**
+	 * Register an entity
+	 *
+	 * @param  string|\Analogue\ORM\Mappable $entity    entity's class name
+	 * @param  string|EntityMap              $entityMap map's class name
+	 * @throws MappingException
+	 * @return void
+	 */
+	public function register($entity, $entityMap = null)
+	{
+		// If an object is provider, get the class name from it
+		if (!is_string($entity)) {
+			$entity = get_class($entity);
+		}
+
+		if ($this->isRegisteredEntity($entity)) {
+			throw new MappingException("Entity $entity is already registered.");
+		}
+
+		if (!class_exists($entity)) {
+			throw new MappingException("Class $entity does not exists");
+		}
+
+		if (is_null($entityMap)) {
+			$entityMap = $this->getEntityMapInstanceFor($entity);
+		}
+
+		if (is_string($entityMap)) {
+			$entityMap = new $entityMap;
+		}
+
+		if (!$entityMap instanceof EntityMap) {
+			throw new MappingException(get_class($entityMap) . ' must be an instance of EntityMap.');
+		}
+
+		$entityMap->setClass($entity);
+
+		$entityMap->setManager($this);
+
+		$this->entityClasses[$entity] = $entityMap;
+	}
+
+	/**
+	 * Get the entity map instance for a custom entity
+	 *
+	 * @param  string   $entity
+	 * @return \Analogue\ORM\Mappable
+	 */
+	protected function getEntityMapInstanceFor($entity)
+	{
+		if (class_exists($entity . 'Map')) {
+			$map = $entity . 'Map';
+			$map = new $map;
+		} else {
+			// Generate an EntityMap object
+			$map = $this->getNewEntityMap();
+		}
         
-        return $map;
-    }
-
-    /**
-     * Dynamically create an entity map for a custom entity class
-     *
-     * @return EntityMap
-     */
-    protected function getNewEntityMap()
-    {
-        return new EntityMap;
-    }
-
-    /**
-     * Register a Value Object
-     *
-     * @param  string $valueObject
-     * @param  string $valueMap
-     * @throws MappingException
-     * @return void
-     */
-    public function registerValueObject($valueObject, $valueMap = null)
-    {
-        if (!is_string($valueObject)) {
-            $valueObject = get_class($valueObject);
-        }
-
-        if (is_null($valueMap)) {
-            $valueMap = $valueObject . 'Map';
-        }
-
-        if (!class_exists($valueMap)) {
-            throw new MappingException("$valueMap doesn't exists");
-        }
-
-        $this->valueClasses[$valueObject] = $valueMap;
-    }
-
-    /**
-     * Return true is the object is registered as value object
-     *
-     * @param  mixed $object
-     * @return boolean
-     */
-    public function isValueObject($object)
-    {
-        if (!is_string($object)) {
-            $object = get_class($object);
-        }
-
-        return array_key_exists($object, $this->valueClasses);
-    }
-
-    /**
-     * Get the Value Map for a given Value Object Class
-     *
-     * @param  string $valueObject
-     * @throws MappingException
-     * @return \Analogue\ORM\ValueMap
-     */
-    public function getValueMap($valueObject)
-    {
-        if (!is_string($valueObject)) {
-            $valueObject = get_class($valueObject);
-        }
-
-        if (!array_key_exists($valueObject, $this->valueClasses)) {
-            $this->registerValueObject($valueObject);
-        }
-        $valueMap = new $this->valueClasses[$valueObject];
-
-        $valueMap->setClass($valueObject);
-
-        return $valueMap;
-    }
-
-    /**
-     * Instantiate a new Value Object instance
-     *
-     * @param  string $valueObject
-     * @return \Analogue\ORM\ValueObject
-     */
-    public function getValueObjectInstance($valueObject)
-    {
-        $prototype = unserialize(sprintf('O:%d:"%s":0:{}', strlen($valueObject), $valueObject));
-        return $prototype;
-    }
-
-    /**
-     * Register Analogue Plugin
-     *
-     * @param  string $plugin class
-     * @return void
-     */
-    public function registerPlugin($plugin)
-    {
-        $plugin = new $plugin($this);
-
-        $this->events = array_merge($this->events, $plugin->getCustomEvents());
-
-        $plugin->register();
-    }
-
-    /**
-     * Check if the entity is already registered
-     *
-     * @param  string|object $entity
-     * @return boolean
-     */
-    public function isRegisteredEntity($entity)
-    {
-        if (!is_string($entity)) {
-            $entity = get_class($entity);
-        }
-
-        return array_key_exists($entity, $this->entityClasses);
-    }
-
-    /**
-     * Register event listeners that will be fired regardless the type
-     * of the entity.
-     *
-     * @param  string $event
-     * @param  \Closure $callback
-     * @throws \Exception
-     * @return void
-     */
-    public function registerGlobalEvent($event, $callback)
-    {
-        if (!in_array($event, $this->events)) {
-            throw new \Exception("Analogue : Event $event doesn't exist");
-        }
-        $this->eventDispatcher->listen("analogue.{$event}.*", $callback);
-    }
-
-    /**
-     * Shortcut to Mapper store
-     *
-     * @param  mixed $entity
-     * @throws MappingException
-     * @return mixed
-     */
-    public function store($entity)
-    {
-        return $this->mapper($entity)->store($entity);
-    }
-
-    /**
-     * Shortcut to Mapper delete
-     *
-     * @param  mixed $entity
-     * @throws MappingException
-     * @return \Illuminate\Support\Collection|null
-     */
-    public function delete($entity)
-    {
-        return $this->mapper($entity)->delete($entity);
-    }
-
-    /**
-     * Shortcut to Mapper query
-     *
-     * @param  mixed $entity
-     * @throws MappingException
-     * @return Query
-     */
-    public function query($entity)
-    {
-        return $this->mapper($entity)->query();
-    }
-
-    /**
-     * Shortcut to Mapper Global Query
-     *
-     * @param  mixed $entity
-     * @throws MappingException
-     * @return Query
-     */
-    public function globalQuery($entity)
-    {
-        return $this->mapper($entity)->globalQuery();
-    }
+		return $map;
+	}
+
+	/**
+	 * Dynamically create an entity map for a custom entity class
+	 *
+	 * @return EntityMap
+	 */
+	protected function getNewEntityMap()
+	{
+		return new EntityMap;
+	}
+
+	/**
+	 * Register a Value Object
+	 *
+	 * @param  string $valueObject
+	 * @param  string $valueMap
+	 * @throws MappingException
+	 * @return void
+	 */
+	public function registerValueObject($valueObject, $valueMap = null)
+	{
+		if (!is_string($valueObject)) {
+			$valueObject = get_class($valueObject);
+		}
+
+		if (is_null($valueMap)) {
+			$valueMap = $valueObject . 'Map';
+		}
+
+		if (!class_exists($valueMap)) {
+			throw new MappingException("$valueMap doesn't exists");
+		}
+
+		$this->valueClasses[$valueObject] = $valueMap;
+	}
+
+	/**
+	 * Return true is the object is registered as value object
+	 *
+	 * @param  mixed $object
+	 * @return boolean
+	 */
+	public function isValueObject($object)
+	{
+		if (!is_string($object)) {
+			$object = get_class($object);
+		}
+
+		return array_key_exists($object, $this->valueClasses);
+	}
+
+	/**
+	 * Get the Value Map for a given Value Object Class
+	 *
+	 * @param  string $valueObject
+	 * @throws MappingException
+	 * @return \Analogue\ORM\ValueMap
+	 */
+	public function getValueMap($valueObject)
+	{
+		if (!is_string($valueObject)) {
+			$valueObject = get_class($valueObject);
+		}
+
+		if (!array_key_exists($valueObject, $this->valueClasses)) {
+			$this->registerValueObject($valueObject);
+		}
+		$valueMap = new $this->valueClasses[$valueObject];
+
+		$valueMap->setClass($valueObject);
+
+		return $valueMap;
+	}
+
+	/**
+	 * Instantiate a new Value Object instance
+	 *
+	 * @param  string $valueObject
+	 * @return \Analogue\ORM\ValueObject
+	 */
+	public function getValueObjectInstance($valueObject)
+	{
+		$prototype = unserialize(sprintf('O:%d:"%s":0:{}', strlen($valueObject), $valueObject));
+		return $prototype;
+	}
+
+	/**
+	 * Register Analogue Plugin
+	 *
+	 * @param  string $plugin class
+	 * @return void
+	 */
+	public function registerPlugin($plugin)
+	{
+		$plugin = new $plugin($this);
+
+		$this->events = array_merge($this->events, $plugin->getCustomEvents());
+
+		$plugin->register();
+	}
+
+	/**
+	 * Check if the entity is already registered
+	 *
+	 * @param  string|object $entity
+	 * @return boolean
+	 */
+	public function isRegisteredEntity($entity)
+	{
+		if (!is_string($entity)) {
+			$entity = get_class($entity);
+		}
+
+		return array_key_exists($entity, $this->entityClasses);
+	}
+
+	/**
+	 * Register event listeners that will be fired regardless the type
+	 * of the entity.
+	 *
+	 * @param  string $event
+	 * @param  \Closure $callback
+	 * @throws \Exception
+	 * @return void
+	 */
+	public function registerGlobalEvent($event, $callback)
+	{
+		if (!in_array($event, $this->events)) {
+			throw new \Exception("Analogue : Event $event doesn't exist");
+		}
+		$this->eventDispatcher->listen("analogue.{$event}.*", $callback);
+	}
+
+	/**
+	 * Shortcut to Mapper store
+	 *
+	 * @param  mixed $entity
+	 * @throws MappingException
+	 * @return mixed
+	 */
+	public function store($entity)
+	{
+		return $this->mapper($entity)->store($entity);
+	}
+
+	/**
+	 * Shortcut to Mapper delete
+	 *
+	 * @param  mixed $entity
+	 * @throws MappingException
+	 * @return \Illuminate\Support\Collection|null
+	 */
+	public function delete($entity)
+	{
+		return $this->mapper($entity)->delete($entity);
+	}
+
+	/**
+	 * Shortcut to Mapper query
+	 *
+	 * @param  mixed $entity
+	 * @throws MappingException
+	 * @return Query
+	 */
+	public function query($entity)
+	{
+		return $this->mapper($entity)->query();
+	}
+
+	/**
+	 * Shortcut to Mapper Global Query
+	 *
+	 * @param  mixed $entity
+	 * @throws MappingException
+	 * @return Query
+	 */
+	public function globalQuery($entity)
+	{
+		return $this->mapper($entity)->globalQuery();
+	}
     
-    /**
-     * Return the Singleton instance of the manager
-     *
-     * @return Manager
-     */
-    public static function getInstance()
-    {
-        return static::$instance;
-    }
+	/**
+	 * Return the Singleton instance of the manager
+	 *
+	 * @return Manager
+	 */
+	public static function getInstance()
+	{
+		return static::$instance;
+	}
 }

Spacing +4 added lines, -4 removed lines

@@ -232,7 +232,7 @@ 
         }
 
         if (!$entityMap instanceof EntityMap) {
-            throw new MappingException(get_class($entityMap) . ' must be an instance of EntityMap.');
+            throw new MappingException(get_class($entityMap).' must be an instance of EntityMap.');
         }
 
         $entityMap->setClass($entity);
@@ -250,8 +250,8 @@ 
      */
     protected function getEntityMapInstanceFor($entity)
     {
-        if (class_exists($entity . 'Map')) {
-            $map = $entity . 'Map';
+        if (class_exists($entity.'Map')) {
+            $map = $entity.'Map';
             $map = new $map;
         } else {
             // Generate an EntityMap object
@@ -286,7 +286,7 @@ 
         }
 
         if (is_null($valueMap)) {
-            $valueMap = $valueObject . 'Map';
+            $valueMap = $valueObject.'Map';
         }
 
         if (!class_exists($valueMap)) {

src/System/Wrappers/EntityWrapper.php

Indentation +68 added lines, -68 removed lines

@@ -7,79 +7,79 @@
  */
 class EntityWrapper extends Wrapper
 {
-    /**
-     * Method used by the mapper to set the object
-     * attribute raw values (hydration)
-     *
-     * @param array $attributes
-     *
-     * @return void
-     */
-    public function setEntityAttributes(array $attributes)
-    {
-        $this->entity->setEntityAttributes($attributes);
-    }
+	/**
+	 * Method used by the mapper to set the object
+	 * attribute raw values (hydration)
+	 *
+	 * @param array $attributes
+	 *
+	 * @return void
+	 */
+	public function setEntityAttributes(array $attributes)
+	{
+		$this->entity->setEntityAttributes($attributes);
+	}
 
-    /**
-     * Method used by the mapper to get the
-     * raw object's values.
-     *
-     * @return array
-     */
-    public function getEntityAttributes()
-    {
-        return $this->entity->getEntityAttributes();
-    }
+	/**
+	 * Method used by the mapper to get the
+	 * raw object's values.
+	 *
+	 * @return array
+	 */
+	public function getEntityAttributes()
+	{
+		return $this->entity->getEntityAttributes();
+	}
 
-    /**
-     * Method used by the mapper to set raw
-     * key-value pair
-     *
-     * @param string $key
-     * @param string $value
-     *
-     * @return void
-     */
-    public function setEntityAttribute($key, $value)
-    {
-        $attributes = $this->entity->getEntityAttributes();
+	/**
+	 * Method used by the mapper to set raw
+	 * key-value pair
+	 *
+	 * @param string $key
+	 * @param string $value
+	 *
+	 * @return void
+	 */
+	public function setEntityAttribute($key, $value)
+	{
+		$attributes = $this->entity->getEntityAttributes();
 
-        $attributes[$key] = $value;
+		$attributes[$key] = $value;
 
-        $this->entity->setEntityAttributes($attributes);
-    }
+		$this->entity->setEntityAttributes($attributes);
+	}
 
-    /**
-     * Method used by the mapper to get single
-     * key-value pair
-     *
-     * @param  string $key
-     * @return mixed|null
-     */
-    public function getEntityAttribute($key)
-    {
-        if ($this->hasAttribute($key)) {
-            $attributes = $this->entity->getEntityAttributes();
-            return $attributes[$key];
-        } else {
-            return null;
-        }
-    }
+	/**
+	 * Method used by the mapper to get single
+	 * key-value pair
+	 *
+	 * @param  string $key
+	 * @return mixed|null
+	 */
+	public function getEntityAttribute($key)
+	{
+		if ($this->hasAttribute($key)) {
+			$attributes = $this->entity->getEntityAttributes();
+			return $attributes[$key];
+		} else {
+			return null;
+		}
+	}
 
-    /**
-     * Test if a given attribute exists
-     *
-     * @param  string $key
-     * @return boolean
-     */
-    public function hasAttribute($key)
-    {
-        $attributes = $this->entity->getEntityAttributes();
+	/**
+	 * Test if a given attribute exists
+	 *
+	 * @param  string $key
+	 * @return boolean
+	 */
+	public function hasAttribute($key)
+	{
+		$attributes = $this->entity->getEntityAttributes();
 
-        if (array_key_exists($key, $attributes)) {
-            return true;
-        } else {
-            return false;
-        }
-    }
+		if (array_key_exists($key, $attributes)) {
+			return true;
+		} else {
+			return false;
+		}
+	}
 }