analogueorm / analogue

src/Drivers/IlluminateDBAdapter.php

Doc Comments +1 added lines, -1 removed lines

@@ -27,7 +27,7 @@
     /**
      * Return a new Query instance for this driver
      *
-     * @return QueryAdapter
+     * @return IlluminateQueryBuilder
      */
     public function getQuery()
     {

Indentation +56 added lines, -56 removed lines

@@ -10,68 +10,68 @@
  */
 class IlluminateDBAdapter implements DBAdapter
 {
-    /**
-     * @var Connection
-     */
-    protected $connection;
+	/**
+	 * @var Connection
+	 */
+	protected $connection;
 
-    /**
-     * IlluminateDBAdapter constructor.
-     * @param Connection $connection
-     */
-    public function __construct(Connection $connection)
-    {
-        $this->connection = $connection;
-    }
+	/**
+	 * IlluminateDBAdapter constructor.
+	 * @param Connection $connection
+	 */
+	public function __construct(Connection $connection)
+	{
+		$this->connection = $connection;
+	}
 
-    /**
-     * Return a new Query instance for this driver
-     *
-     * @return QueryAdapter
-     */
-    public function getQuery()
-    {
-        $connection = $this->connection;
+	/**
+	 * Return a new Query instance for this driver
+	 *
+	 * @return QueryAdapter
+	 */
+	public function getQuery()
+	{
+		$connection = $this->connection;
 
-        $grammar = $connection->getQueryGrammar();
+		$grammar = $connection->getQueryGrammar();
 
-        return new IlluminateQueryBuilder($connection, $grammar, $connection->getPostProcessor());
-    }
+		return new IlluminateQueryBuilder($connection, $grammar, $connection->getPostProcessor());
+	}
 
-    /**
-     * Get the date format supported by the current connection
-     *
-     * @return string
-     */
-    public function getDateFormat()
-    {
-        return $this->connection->getQueryGrammar()->getDateFormat();
-    }
+	/**
+	 * Get the date format supported by the current connection
+	 *
+	 * @return string
+	 */
+	public function getDateFormat()
+	{
+		return $this->connection->getQueryGrammar()->getDateFormat();
+	}
 
-    /**
-     * Start a DB transaction on driver that supports it.
-     * @return void
-     */
-    public function beginTransaction()
-    {
-        $this->connection->beginTransaction();
-    }
+	/**
+	 * Start a DB transaction on driver that supports it.
+	 * @return void
+	 */
+	public function beginTransaction()
+	{
+		$this->connection->beginTransaction();
+	}
 
-    /**
-     * Commit a DB transaction on driver that supports it.
-     * @return void
-     */
-    public function commit()
-    {
-        $this->connection->commit();
-    }
+	/**
+	 * Commit a DB transaction on driver that supports it.
+	 * @return void
+	 */
+	public function commit()
+	{
+		$this->connection->commit();
+	}
 
-    /**
-     * Rollback a DB transaction
-     * @return void
-     */
-    public function rollback()
-    {
-        $this->connection->rollBack();
-    }
+	/**
+	 * Rollback a DB transaction
+	 * @return void
+	 */
+	public function rollback()
+	{
+		$this->connection->rollBack();
+	}
 }

src/Commands/Command.php

Indentation +23 added lines, -23 removed lines

@@ -7,31 +7,31 @@
 
 abstract class Command
 {
-    /**
-     * The aggregated entity on which the command is executed
-     *
-     * @var \Analogue\ORM\System\Aggregate
-     */
-    protected $aggregate;
+	/**
+	 * The aggregated entity on which the command is executed
+	 *
+	 * @var \Analogue\ORM\System\Aggregate
+	 */
+	protected $aggregate;
 
-    /**
-     * Query Builder instance
-     *
-     * @var \Illuminate\Database\Query\Builder
-     */
-    protected $query;
+	/**
+	 * Query Builder instance
+	 *
+	 * @var \Illuminate\Database\Query\Builder
+	 */
+	protected $query;
 
-    /**
-     * Command constructor.
-     * @param Aggregate $aggregate
-     * @param QueryAdapter|\Analogue\ORM\Drivers\IlluminateQueryAdapter $query
-     */
-    public function __construct(Aggregate $aggregate, Builder $query)
-    {
-        $this->aggregate = $aggregate;
+	/**
+	 * Command constructor.
+	 * @param Aggregate $aggregate
+	 * @param QueryAdapter|\Analogue\ORM\Drivers\IlluminateQueryAdapter $query
+	 */
+	public function __construct(Aggregate $aggregate, Builder $query)
+	{
+		$this->aggregate = $aggregate;
 
-        $this->query = $query->from($aggregate->getEntityMap()->getTable());
-    }
+		$this->query = $query->from($aggregate->getEntityMap()->getTable());
+	}
 
-    abstract public function execute();
+	abstract public function execute();
 }

src/Commands/Store.php

Braces +1 added lines, -2 removed lines

@@ -44,8 +44,7 @@
             $this->insert();
 
             $mapper->fireEvent('created', $entity, false);
-        }
-        else if ($this->aggregate->isDirty()) {
+        } else if ($this->aggregate->isDirty()) {
             if ($mapper->fireEvent('updating', $entity) === false) {
                 return false;
             }

Indentation +220 added lines, -220 removed lines

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

src/Drivers/IlluminateQueryBuilder.php

Indentation +1 added lines, -1 removed lines

@@ -6,5 +6,5 @@
 
 class EntityMapNotFoundException extends RuntimeException
 {
-    //
+	//
 }

src/Entity.php

Indentation +116 added lines, -116 removed lines

@@ -6,133 +6,133 @@
 
 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)
-    {
-        $key = ucwords(str_replace(['-', '_'], ' ', $key));
-        return str_replace(' ', '', $key) . "Attribute";
-    }
+	/**
+	 * @param $key
+	 * @return string
+	 */
+	protected function getMutatorMethod($key)
+	{
+		$key = ucwords(str_replace(['-', '_'], ' ', $key));
+		return str_replace(' ', '', $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;
+	}
 
-    /**
-     * Fill an entity with key-value pairs
-     * 
-     * @param  array  $attributes 
-     * @return void
-     */
-    public function fill(array $attributes)
-    {
-        foreach ($attributes as $key => $attribute) {
+	/**
+	 * Fill an entity with key-value pairs
+	 * 
+	 * @param  array  $attributes 
+	 * @return void
+	 */
+	public function fill(array $attributes)
+	{
+		foreach ($attributes as $key => $attribute) {
             
-            if ($this->hasSetMutator($key)) {
-                $method = 'set' . $this->getMutatorMethod($key);
-                $this->attributes[$key] = $this->$method($attribute);
-            }
-            else {
-                $this->attributes[$key] = $attribute;
-            }
-        }
-    }
+			if ($this->hasSetMutator($key)) {
+				$method = 'set' . $this->getMutatorMethod($key);
+				$this->attributes[$key] = $this->$method($attribute);
+			}
+			else {
+				$this->attributes[$key] = $attribute;
+			}
+		}
+	}
 }

Spacing +7 added lines, -7 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;
     }
 
     /**
@@ -89,7 +89,7 @@ 
     protected function getMutatorMethod($key)
     {
         $key = ucwords(str_replace(['-', '_'], ' ', $key));
-        return str_replace(' ', '', $key) . "Attribute";
+        return str_replace(' ', '', $key)."Attribute";
     }
 
     /**
@@ -109,7 +109,7 @@ 
                 continue;
             }
             if ($this->hasGetMutator($key)) {
-                $method = 'get' . $this->getMutatorMethod($key);
+                $method = 'get'.$this->getMutatorMethod($key);
                 $attributes[$key] = $this->$method($attribute);
             }
         }
@@ -127,7 +127,7 @@ 
         foreach ($attributes as $key => $attribute) {
             
             if ($this->hasSetMutator($key)) {
-                $method = 'set' . $this->getMutatorMethod($key);
+                $method = 'set'.$this->getMutatorMethod($key);
                 $this->attributes[$key] = $this->$method($attribute);
             }
             else {

Braces +1 added lines, -2 removed lines

@@ -129,8 +129,7 @@
             if ($this->hasSetMutator($key)) {
                 $method = 'set' . $this->getMutatorMethod($key);
                 $this->attributes[$key] = $this->$method($attribute);
-            }
-            else {
+            } else {
                 $this->attributes[$key] = $attribute;
             }
         }

src/System/Manager.php

Doc Comments +3 added lines, -3 removed lines

@@ -141,7 +141,7 @@ 
      * Create a mapper for a given entity
      *
      * @param  \Analogue\ORM\Mappable|string|array|\Traversable $entity
-     * @param  mixed                                            $entityMap
+     * @param  null|EntityMap                                            $entityMap
      * @throws MappingException
      * @throws \InvalidArgumentException
      * @return Mapper
@@ -243,7 +243,7 @@ 
     /**
      * Check if the entity is already registered
      *
-     * @param  string|Entity $entity
+     * @param  string $entity
      * @return boolean
      */
     public function isRegisteredEntity($entity)
@@ -312,7 +312,7 @@ 
     /**
      * Register an entity
      *
-     * @param  string|\Analogue\ORM\Mappable $entity    entity's class name
+     * @param  string $entity    entity's class name
      * @param  string|EntityMap              $entityMap map's class name
      * @throws MappingException
      * @return void

Unused Use Statements -1 removed lines

@@ -5,7 +5,6 @@
 use Analogue\ORM\Entity;
 use Analogue\ORM\Plugins\AnaloguePluginInterface;
 use Analogue\ORM\ValueMap;
-use Exception;
 use Analogue\ORM\EntityMap;
 use Analogue\ORM\Repository;
 use Illuminate\Support\Collection;

Spacing +8 added lines, -8 removed lines

@@ -177,7 +177,7 @@ 
         // We first check if the entity is traversable and we'll resolve
         // the entity based on the first item of the object.   
         if ($this->isTraversable($entity)) {
-            if (! count($entity)) {
+            if (!count($entity)) {
                 throw new \InvalidArgumentException('Length of Entity collection must be greater than 0');
             }
 
@@ -341,7 +341,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);
@@ -359,8 +359,8 @@ 
      */
     protected function getEntityMapInstanceFor($entity)
     {
-        if (class_exists($entity . 'Map')) {
-            $map = $entity . 'Map';
+        if (class_exists($entity.'Map')) {
+            $map = $entity.'Map';
             $map = new $map;
             return $map;
         }
@@ -388,7 +388,7 @@ 
     protected function getMapFromNamespaces($class)
     {
         foreach ($this->customMapNamespaces as $namespace) {
-            if($map = $this->findMapInNamespace($class, $namespace)) {
+            if ($map = $this->findMapInNamespace($class, $namespace)) {
                 return $map;
             }
         }
@@ -530,15 +530,15 @@ 
 
             // First, we'll look into registered namespaces for Entity Maps,
             // if any. Then we'll fallback to the same namespace of the object
-            if(! $valueMap = $this->getMapFromNamespaces($valueObject)) {
-                $valueMap = $valueObject . 'Map';    
+            if (!$valueMap = $this->getMapFromNamespaces($valueObject)) {
+                $valueMap = $valueObject.'Map';    
             }
             else {
                 $valueMap = get_class($valueMap);
             }
         }
 
-        if (! class_exists($valueMap)) {
+        if (!class_exists($valueMap)) {
             throw new MappingException("$valueMap doesn't exists");
         }
 

Braces +1 added lines, -2 removed lines

@@ -129,8 +129,7 @@
             if ($this->hasSetMutator($key)) {
                 $method = 'set' . $this->getMutatorMethod($key);
                 $this->attributes[$key] = $this->$method($attribute);
-            }
-            else {
+            } else {
                 $this->attributes[$key] = $attribute;
             }
         }

Indentation +646 added lines, -646 removed lines

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

src/EntityCollection.php

Spacing +6 added lines, -6 removed lines

@@ -42,7 +42,7 @@ 
             $key = $this->getEntityKey($key);
         }
 
-        return array_first($this->items, function ($entity, $itemKey) use ($key) {
+        return array_first($this->items, function($entity, $itemKey) use ($key) {
 
             return $this->getEntityKey($entity) == $key;
         }, $default);
@@ -153,14 +153,14 @@ 
      */
     public function getEntityHashes()
     {
-        return array_map(function ($entity) {
+        return array_map(function($entity) {
             $class = get_class($entity);
 
             $mapper = Manager::getMapper($class);
 
             $keyName = $mapper->getEntityMap()->getKeyName();
 
-            return $class . '.' . $entity->getEntityAttribute($keyName);
+            return $class.'.'.$entity->getEntityAttribute($keyName);
         },
         $this->items);
     }
@@ -183,7 +183,7 @@ 
 
             $keyName = $mapper->getEntityMap()->getKeyName();
 
-            if (in_array($class . '.' . $item->$keyName, $hashes)) {
+            if (in_array($class.'.'.$item->$keyName, $hashes)) {
                 $subset[] = $item;
             }
         }
@@ -330,7 +330,7 @@ 
      */
     public function max($key = null)
     {
-        return $this->reduce(function ($result, $item) use ($key) {
+        return $this->reduce(function($result, $item) use ($key) {
             $wrapper = $this->factory->make($item);
 
             return (is_null($result) || $wrapper->getEntityAttribute($key) > $result) ?
@@ -347,7 +347,7 @@ 
      */
     public function min($key = null)
     {
-        return $this->reduce(function ($result, $item) use ($key) {
+        return $this->reduce(function($result, $item) use ($key) {
             $wrapper = $this->factory->make($item);
 
             return (is_null($result) || $wrapper->getEntityAttribute($key) < $result)

Doc Comments +1 added lines, -1 removed lines

@@ -78,7 +78,7 @@
     /**
      * Push an item onto the end of the collection.
      *
-     * @param  mixed $value
+     * @param  Mappable $value
      * @return void
      */
     public function push($value)

Indentation +410 added lines, -410 removed lines

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

src/System/Wrappers/PlainObjectWrapper.php

Indentation +233 added lines, -233 removed lines

@@ -6,239 +6,239 @@
 
 class PlainObjectWrapper extends Wrapper
 {
-    /**
-     * The list of attributes for the managed entity
-     *
-     * @var array
-     */
-    protected $attributeList;
-
-    /**
-     * The reflection class for the managed entity
-     *
-     * @var ReflectionClass
-     */
-    protected $reflection;
-
-    /**
-     * Attributes which have no existence on the actual entity
-     * but which exists in DB (eg : foreign key)
-     * 
-     * @var array
-     */
-    protected $virtualAttributes = [];
-
-    /**
-     * PlainObjectWrapper constructor.
-     * 
-     * @param $popoEntity
-     * @param $entityMap
-     */
-    public function __construct($popoEntity, $entityMap)
-    {
-        $this->reflection = new ReflectionClass($popoEntity);
-
-        parent::__construct($popoEntity, $entityMap);
-
-        $this->attributeList = $this->getAttributeList();
-    }
-
-    /**
-     * Get Compiled Attributes (key, attributes, embed, relations)
-     *
-     * @return array
-     */
-    protected function getAttributeList()
-    {
-        return  $this->entityMap->getCompiledAttributes();
-    }
-
-    /**
-     * Extract Attributes from a Plain Php Object
-     *
-     * @return array $attributes
-     */
-    protected function extract()
-    {
-        $properties = $this->getMappedProperties();
-
-        $attributes = [];
-
-        foreach ($properties as $property) {
-            $name = $property->getName();
-
-            if ($property->isPublic()) {
-                $attributes[$name] = $this->entity->$name;
-            } else {
-                $property->setAccessible(true);
+	/**
+	 * The list of attributes for the managed entity
+	 *
+	 * @var array
+	 */
+	protected $attributeList;
+
+	/**
+	 * The reflection class for the managed entity
+	 *
+	 * @var ReflectionClass
+	 */
+	protected $reflection;
+
+	/**
+	 * Attributes which have no existence on the actual entity
+	 * but which exists in DB (eg : foreign key)
+	 * 
+	 * @var array
+	 */
+	protected $virtualAttributes = [];
+
+	/**
+	 * PlainObjectWrapper constructor.
+	 * 
+	 * @param $popoEntity
+	 * @param $entityMap
+	 */
+	public function __construct($popoEntity, $entityMap)
+	{
+		$this->reflection = new ReflectionClass($popoEntity);
+
+		parent::__construct($popoEntity, $entityMap);
+
+		$this->attributeList = $this->getAttributeList();
+	}
+
+	/**
+	 * Get Compiled Attributes (key, attributes, embed, relations)
+	 *
+	 * @return array
+	 */
+	protected function getAttributeList()
+	{
+		return  $this->entityMap->getCompiledAttributes();
+	}
+
+	/**
+	 * Extract Attributes from a Plain Php Object
+	 *
+	 * @return array $attributes
+	 */
+	protected function extract()
+	{
+		$properties = $this->getMappedProperties();
+
+		$attributes = [];
+
+		foreach ($properties as $property) {
+			$name = $property->getName();
+
+			if ($property->isPublic()) {
+				$attributes[$name] = $this->entity->$name;
+			} else {
+				$property->setAccessible(true);
     
-                $attributes[$name] = $property->getValue($this->entity);
-            }
-        }
-
-        return $attributes;
-    }
-
-    /**
-     * @return \ReflectionProperty[]
-     */
-    protected function getMappedProperties()
-    {
-        $objectProperties = $this->reflection->getProperties();
-
-        $attributeList = $this->getAttributeList();
-
-        // We need to filter out properties that could belong to the object
-        // and which are not intended to be handled by the ORM
-        return array_filter($objectProperties, function (\ReflectionProperty $item) use ($attributeList) {
-            if (in_array($item->getName(), $attributeList)) {
-                return true;
-            }
-        });
-    }
-
-    /**
-     * Get the property's value from reflection
-     * 
-     * @param  string $name
-     * @return \ReflectionProperty | null
-     */
-    protected function getMappedProperty($name)
-    {
-        return $this->reflection->getProperty($name);
-    }
-
-    /**
-     * Hydrate Plain PHP Object with wrapped attributes
-     *
-     * @param  $attributes
-     * @return void
-     */
-    protected function hydrate($attributes)
-    {
-        $properties = $this->getMappedProperties();
-
-        foreach ($properties as $property) {
-            $name = $property->getName();
-
-            if ($property->isPublic()) {
-                $this->entity->$name = $attributes[$name];
-            } else {
-                $property->setAccessible(true);
-
-                $property->setValue($this->entity, $attributes[$name]);
-            }
-        }
-    }
-
-    /**
-     * Method used by the mapper to set the object
-     * attribute raw values (hydration)
-     *
-     * @param array $attributes
-     *
-     * @return void
-     */
-    public function setEntityAttributes(array $attributes)
-    {
-        $this->hydrate($attributes);
-    }
-
-    /**
-     * Method used by the mapper to get the
-     * raw object's values.
-     *
-     * @return array
-     */
-    public function getEntityAttributes()
-    {
-        $properties = $this->extract();
-
-        return array_merge($properties, $this->virtualAttributes);
-    }
-
-    /**
-     * Method used by the mapper to set raw
-     * key-value pair
-     *
-     * @param string $key
-     * @param string $value
-     *
-     * @return void
-     */
-    public function setEntityAttribute($key, $value)
-    {
-        if(! $this->reflection->hasProperty($key)) {
-            $this->virtualAttributes[$key] = $value;
-            return;
-        }
-
-        $property = $this->getMappedProperty($key);
-
-        if ($property->isPublic()) {
-            $this->entity->$key = $value;
-        } else {
-            $property->setAccessible(true);
+				$attributes[$name] = $property->getValue($this->entity);
+			}
+		}
+
+		return $attributes;
+	}
+
+	/**
+	 * @return \ReflectionProperty[]
+	 */
+	protected function getMappedProperties()
+	{
+		$objectProperties = $this->reflection->getProperties();
+
+		$attributeList = $this->getAttributeList();
+
+		// We need to filter out properties that could belong to the object
+		// and which are not intended to be handled by the ORM
+		return array_filter($objectProperties, function (\ReflectionProperty $item) use ($attributeList) {
+			if (in_array($item->getName(), $attributeList)) {
+				return true;
+			}
+		});
+	}
+
+	/**
+	 * Get the property's value from reflection
+	 * 
+	 * @param  string $name
+	 * @return \ReflectionProperty | null
+	 */
+	protected function getMappedProperty($name)
+	{
+		return $this->reflection->getProperty($name);
+	}
+
+	/**
+	 * Hydrate Plain PHP Object with wrapped attributes
+	 *
+	 * @param  $attributes
+	 * @return void
+	 */
+	protected function hydrate($attributes)
+	{
+		$properties = $this->getMappedProperties();
+
+		foreach ($properties as $property) {
+			$name = $property->getName();
+
+			if ($property->isPublic()) {
+				$this->entity->$name = $attributes[$name];
+			} else {
+				$property->setAccessible(true);
+
+				$property->setValue($this->entity, $attributes[$name]);
+			}
+		}
+	}
+
+	/**
+	 * Method used by the mapper to set the object
+	 * attribute raw values (hydration)
+	 *
+	 * @param array $attributes
+	 *
+	 * @return void
+	 */
+	public function setEntityAttributes(array $attributes)
+	{
+		$this->hydrate($attributes);
+	}
+
+	/**
+	 * Method used by the mapper to get the
+	 * raw object's values.
+	 *
+	 * @return array
+	 */
+	public function getEntityAttributes()
+	{
+		$properties = $this->extract();
+
+		return array_merge($properties, $this->virtualAttributes);
+	}
+
+	/**
+	 * Method used by the mapper to set raw
+	 * key-value pair
+	 *
+	 * @param string $key
+	 * @param string $value
+	 *
+	 * @return void
+	 */
+	public function setEntityAttribute($key, $value)
+	{
+		if(! $this->reflection->hasProperty($key)) {
+			$this->virtualAttributes[$key] = $value;
+			return;
+		}
+
+		$property = $this->getMappedProperty($key);
+
+		if ($property->isPublic()) {
+			$this->entity->$key = $value;
+		} else {
+			$property->setAccessible(true);
     
-            $property->setValue($this->entity, $value);
-        }
-
-        $this->attributes[$key] = $value;
-    }
-
-    /**
-     * Method used by the mapper to get single
-     * key-value pair
-     *
-     * @param  string $key
-     * @return mixed|null
-     */
-    public function getEntityAttribute($key)
-    {
-        if(! $this->reflection->hasProperty($key)) {
-            return $this->getVirtualAttribute($key);
-        }
-
-        $property = $this->getMappedProperty($key);
-
-        if ($property->isPublic()) {
-            $value = $this->entity->$key;
-        } else {
-            $property->setAccessible(true);
-            $value = $property->getValue($this->entity);
-        }
-
-        return $value;
-    }
-
-    /**
-     * Return a virtual attributes
-     * 
-     * @param  string $key
-     * @return mixed
-     */
-    protected function getVirtualAttribute($key)
-    {
-        if(array_key_exists($key, $this->virtualAttributes)) {
-            return $this->virtualAttributes[$key];
-        }
-        else {
-            return null;
-        }
-    }
-
-    /**
-     * Test if a given attribute exists
-     *
-     * @param  string  $key
-     * @return boolean
-     */
-    public function hasAttribute($key)
-    {
-        if (in_array($key, $this->attributeList)) {
-            return true;
-        } else {
-            return false;
-        }
-    }
+			$property->setValue($this->entity, $value);
+		}
+
+		$this->attributes[$key] = $value;
+	}
+
+	/**
+	 * Method used by the mapper to get single
+	 * key-value pair
+	 *
+	 * @param  string $key
+	 * @return mixed|null
+	 */
+	public function getEntityAttribute($key)
+	{
+		if(! $this->reflection->hasProperty($key)) {
+			return $this->getVirtualAttribute($key);
+		}
+
+		$property = $this->getMappedProperty($key);
+
+		if ($property->isPublic()) {
+			$value = $this->entity->$key;
+		} else {
+			$property->setAccessible(true);
+			$value = $property->getValue($this->entity);
+		}
+
+		return $value;
+	}
+
+	/**
+	 * Return a virtual attributes
+	 * 
+	 * @param  string $key
+	 * @return mixed
+	 */
+	protected function getVirtualAttribute($key)
+	{
+		if(array_key_exists($key, $this->virtualAttributes)) {
+			return $this->virtualAttributes[$key];
+		}
+		else {
+			return null;
+		}
+	}
+
+	/**
+	 * Test if a given attribute exists
+	 *
+	 * @param  string  $key
+	 * @return boolean
+	 */
+	public function hasAttribute($key)
+	{
+		if (in_array($key, $this->attributeList)) {
+			return true;
+		} else {
+			return false;
+		}
+	}
 }

Spacing +4 added lines, -4 removed lines

@@ -90,7 +90,7 @@ 
 
         // We need to filter out properties that could belong to the object
         // and which are not intended to be handled by the ORM
-        return array_filter($objectProperties, function (\ReflectionProperty $item) use ($attributeList) {
+        return array_filter($objectProperties, function(\ReflectionProperty $item) use ($attributeList) {
             if (in_array($item->getName(), $attributeList)) {
                 return true;
             }
@@ -168,7 +168,7 @@ 
      */
     public function setEntityAttribute($key, $value)
     {
-        if(! $this->reflection->hasProperty($key)) {
+        if (!$this->reflection->hasProperty($key)) {
             $this->virtualAttributes[$key] = $value;
             return;
         }
@@ -195,7 +195,7 @@ 
      */
     public function getEntityAttribute($key)
     {
-        if(! $this->reflection->hasProperty($key)) {
+        if (!$this->reflection->hasProperty($key)) {
             return $this->getVirtualAttribute($key);
         }
 
@@ -219,7 +219,7 @@ 
      */
     protected function getVirtualAttribute($key)
     {
-        if(array_key_exists($key, $this->virtualAttributes)) {
+        if (array_key_exists($key, $this->virtualAttributes)) {
             return $this->virtualAttributes[$key];
         }
         else {

Braces +1 added lines, -2 removed lines

@@ -221,8 +221,7 @@
     {
         if(array_key_exists($key, $this->virtualAttributes)) {
             return $this->virtualAttributes[$key];
-        }
-        else {
+        } else {
             return null;
         }
     }

src/System/ResultBuilder.php

Spacing +1 added lines, -1 removed lines

@@ -122,7 +122,7 @@
 
         $columnMap = $this->entityMap->getDiscriminatorColumnMap();
 
-        $class = isset($columnMap[$type]) ? $columnMap[$type]: $type;
+        $class = isset($columnMap[$type]) ? $columnMap[$type] : $type;
 
         if (!isset($this->builders[$type])) {
             $this->builders[$type] = new EntityBuilder($this->manager->mapper($class), array_keys($this->eagerLoads));

Indentation +124 added lines, -124 removed lines

@@ -6,128 +6,128 @@
 
 class ResultBuilder
 {
-    /**
-     * An instance of the entity manager class.
-     * @var \Analogue\ORM\System\Manager
-     */
-    protected $manager;
-
-    /**
-     * The default mapper used to build entities with.
-     * @var \Analogue\ORM\System\Mapper
-     */
-    protected $defaultMapper;
-
-    /**
-     * Relations that will be eager loaded on this query
-     *
-     * @var array
-     */
-    protected $eagerLoads;
-
-    /**
-     * The Entity Map for the entity to build.
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * An array of builders used by this class to build necessary
-     * entities for each result type.
-     *
-     * @var array
-     */
-    protected $builders = [];
-
-    /**
-     * @param Manager $manager
-     * @param Mapper  $defaultMapper
-     * @param array   $eagerLoads
-     */
-    public function __construct(Manager $manager, Mapper $defaultMapper, array $eagerLoads)
-    {
-        $this->manager = $manager;
-
-        $this->defaultMapper = $defaultMapper;
-
-        $this->eagerLoads = $eagerLoads;
-
-        $this->entityMap = $defaultMapper->getEntityMap();
-    }
-
-    /**
-     * Convert a result set into an array of entities
-     *
-     * @param  array $results
-     * @return \Illuminate\Support\Collection
-     */
-    public function build($results)
-    {
-        switch ($this->entityMap->getInheritanceType()) {
-            case 'single_table':
-                return $this->buildUsingSingleTableInheritance($results);
-                break;
-
-            default:
-                return $this->buildWithDefaultMapper($results);
-                break;
-        }
-    }
-
-    /**
-     * Build an entity from results, using the default mapper on this builder.
-     * This is the default build plan when no table inheritance is being used.
-     *
-     * @param  array $results
-     * @return Collection
-     */
-    protected function buildWithDefaultMapper($results)
-    {
-        $builder = new EntityBuilder($this->defaultMapper, array_keys($this->eagerLoads));
-
-        return collect($results)->map(function($item, $key) use ($builder) {
-            return $builder->build((array) $item);
-        })->all();
-    }
-
-    /**
-     * Build an entity from results, using single table inheritance.
-     *
-     * @param  array $results
-     * @return Collection
-     */
-    protected function buildUsingSingleTableInheritance($results)
-    {
-        return collect($results)->map(function($item, $key) {
-            $builder = $this->builderForResult((array) $item);
-
-            return $builder->build((array) $item);
-        })->all();
-    }
-
-    /**
-     * Given a result array, return the entity builder needed to correctly
-     * build the result into an entity. If no getDiscriminatorColumnMap property
-     * has been defined on the EntityMap, we'll assume that the value stored in
-     * the $type column is the fully qualified class name of the entity and
-     * we'll use it instead.
-     *
-     * @param  array  $result
-     * @return EntityBuilder
-     */
-    protected function builderForResult(array $result)
-    {
-        $type = $result[$this->entityMap->getDiscriminatorColumn()];
-
-        $columnMap = $this->entityMap->getDiscriminatorColumnMap();
-
-        $class = isset($columnMap[$type]) ? $columnMap[$type]: $type;
-
-        if (!isset($this->builders[$type])) {
-            $this->builders[$type] = new EntityBuilder($this->manager->mapper($class), array_keys($this->eagerLoads));
-        }
-
-        return $this->builders[$type];
-    }
+	/**
+	 * An instance of the entity manager class.
+	 * @var \Analogue\ORM\System\Manager
+	 */
+	protected $manager;
+
+	/**
+	 * The default mapper used to build entities with.
+	 * @var \Analogue\ORM\System\Mapper
+	 */
+	protected $defaultMapper;
+
+	/**
+	 * Relations that will be eager loaded on this query
+	 *
+	 * @var array
+	 */
+	protected $eagerLoads;
+
+	/**
+	 * The Entity Map for the entity to build.
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * An array of builders used by this class to build necessary
+	 * entities for each result type.
+	 *
+	 * @var array
+	 */
+	protected $builders = [];
+
+	/**
+	 * @param Manager $manager
+	 * @param Mapper  $defaultMapper
+	 * @param array   $eagerLoads
+	 */
+	public function __construct(Manager $manager, Mapper $defaultMapper, array $eagerLoads)
+	{
+		$this->manager = $manager;
+
+		$this->defaultMapper = $defaultMapper;
+
+		$this->eagerLoads = $eagerLoads;
+
+		$this->entityMap = $defaultMapper->getEntityMap();
+	}
+
+	/**
+	 * Convert a result set into an array of entities
+	 *
+	 * @param  array $results
+	 * @return \Illuminate\Support\Collection
+	 */
+	public function build($results)
+	{
+		switch ($this->entityMap->getInheritanceType()) {
+			case 'single_table':
+				return $this->buildUsingSingleTableInheritance($results);
+				break;
+
+			default:
+				return $this->buildWithDefaultMapper($results);
+				break;
+		}
+	}
+
+	/**
+	 * Build an entity from results, using the default mapper on this builder.
+	 * This is the default build plan when no table inheritance is being used.
+	 *
+	 * @param  array $results
+	 * @return Collection
+	 */
+	protected function buildWithDefaultMapper($results)
+	{
+		$builder = new EntityBuilder($this->defaultMapper, array_keys($this->eagerLoads));
+
+		return collect($results)->map(function($item, $key) use ($builder) {
+			return $builder->build((array) $item);
+		})->all();
+	}
+
+	/**
+	 * Build an entity from results, using single table inheritance.
+	 *
+	 * @param  array $results
+	 * @return Collection
+	 */
+	protected function buildUsingSingleTableInheritance($results)
+	{
+		return collect($results)->map(function($item, $key) {
+			$builder = $this->builderForResult((array) $item);
+
+			return $builder->build((array) $item);
+		})->all();
+	}
+
+	/**
+	 * Given a result array, return the entity builder needed to correctly
+	 * build the result into an entity. If no getDiscriminatorColumnMap property
+	 * has been defined on the EntityMap, we'll assume that the value stored in
+	 * the $type column is the fully qualified class name of the entity and
+	 * we'll use it instead.
+	 *
+	 * @param  array  $result
+	 * @return EntityBuilder
+	 */
+	protected function builderForResult(array $result)
+	{
+		$type = $result[$this->entityMap->getDiscriminatorColumn()];
+
+		$columnMap = $this->entityMap->getDiscriminatorColumnMap();
+
+		$class = isset($columnMap[$type]) ? $columnMap[$type]: $type;
+
+		if (!isset($this->builders[$type])) {
+			$this->builders[$type] = new EntityBuilder($this->manager->mapper($class), array_keys($this->eagerLoads));
+		}
+
+		return $this->builders[$type];
+	}
 }
\ No newline at end of file