analogueorm / analogue

src/Commands/Store.php

Indentation +227 added lines, -227 removed lines

@@ -14,241 +14,241 @@
  */
 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);
-        }
+	/**
+	 * 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);
+		}
         
-        /**
-         * We'll only run an update if the entity
-         * is actually dirty
-         */
-        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();
-
-        // Now we can sync the related collections
-        if ($this->aggregate->exists()) {
-            $this->aggregate->syncRelationships($foreignRelationships);
-        }
-
-        // 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();
-        }
-
-
-        // 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();
+		/**
+		 * We'll only run an update if the entity
+		 * is actually dirty
+		 */
+		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();
+
+		// Now we can sync the related collections
+		if ($this->aggregate->exists()) {
+			$this->aggregate->syncRelationships($foreignRelationships);
+		}
+
+		// 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();
+		}
+
+
+		// 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/EntityCollection.php

Indentation +379 added lines, -379 removed lines

@@ -10,387 +10,387 @@
 
 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 ($itemKey, $entity) 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)
-    {
-        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);
+	/**
+	 * 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 ($itemKey, $entity) 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)
+	{
+		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();
+			$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);
+			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();
+			$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
-     * @throws MappingException
-     * @return self
-     */
-    public function unique($key = null)
-    {
-        $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);
-    }
+		$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
+	 * @throws MappingException
+	 * @return self
+	 */
+	public function unique($key = null)
+	{
+		$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);
+	}
 }

Spacing +6 added lines, -6 removed lines

@@ -42,7 +42,7 @@ 
             $key = $this->getEntityKey($key);
         }
 
-        return array_first($this->items, function ($itemKey, $entity) use ($key) {
+        return array_first($this->items, function($itemKey, $entity) use ($key) {
             return $this->getEntityKey($entity) == $key;
         }, $default);
     }
@@ -144,14 +144,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);
     }
@@ -174,7 +174,7 @@ 
             
             $keyName = $mapper->getEntityMap()->getKeyName();
 
-            if (in_array($class . '.' . $item->$keyName, $hashes)) {
+            if (in_array($class.'.'.$item->$keyName, $hashes)) {
                 $subset[] = $item;
             }
         }
@@ -321,7 +321,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) ?
@@ -338,7 +338,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)

src/Relationships/BelongsTo.php

Indentation +314 added lines, -314 removed lines

@@ -10,319 +10,319 @@
 
 class BelongsTo extends Relationship
 {
-    /**
-     * The foreign key of the parent model.
-     *
-     * @var string
-     */
-    protected $foreignKey;
-
-    /**
-     * The associated key on the parent model.
-     *
-     * @var string
-     */
-    protected $otherKey;
-
-    /**
-     * The name of the relationship.
-     *
-     * @var string
-     */
-    protected $relation;
-
-    /**
-     * Indicate if the parent entity hold the key for the relation.
-     *
-     * @var boolean
-     */
-    protected static $ownForeignKey = true;
-
-    /**
-     * Create a new belongs to relationship instance.
-     *
-     * @param Mapper   $mapper
-     * @param Mappable $parent
-     * @param string   $foreignKey
-     * @param string   $otherKey
-     * @param string   $relation
-     */
-    public function __construct(Mapper $mapper, $parent, $foreignKey, $otherKey, $relation)
-    {
-        $this->otherKey = $otherKey;
-        $this->relation = $relation;
-        $this->foreignKey = $foreignKey;
-
-        parent::__construct($mapper, $parent);
-    }
-
-    /**
-     * @param  $related
-     * @return mixed
-     */
-    public function attachTo($related)
-    {
-        $this->associate($related);
-    }
-
-    /**
-     * @param $related
-     * @return Mappable
-     */
-    public function detachFrom($related)
-    {
-        return $this->dissociate($related); //todo
-    }
-
-    /**
-     * Get the results of the relationship.
-     *
-     * @param  $relation
-     *
-     * @return \Analogue\ORM\Entity
-     */
-    public function getResults($relation)
-    {
-        $result = $this->query->first();
-
-        $this->cacheRelation($result, $relation);
-
-        return $result;
-    }
-
-    /**
-     * Set the base constraints on the relation query.
-     *
-     * @return void
-     */
-    public function addConstraints()
-    {
-        if (static::$constraints) {
-            // For belongs to relationships, which are essentially the inverse of has one
-            // or has many relationships, we need to actually query on the primary key
-            // of the related models matching on the foreign key that's on a parent.
-            $table = $this->relatedMap->getTable();
-
-            $this->query->where($table . '.' . $this->otherKey, '=', $this->parent->getEntityAttribute($this->foreignKey));
-        }
-    }
-
-    /**
-     * Add the constraints for a relationship count query.
-     *
-     * @param  Query $query
-     * @param  Query $parent
-     * @return Query
-     */
-    public function getRelationCountQuery(Query $query, Query $parent)
-    {
-        $query->select(new Expression('count(*)'));
-
-        $otherKey = $this->wrap($query->getTable() . '.' . $this->otherKey);
-
-        return $query->where($this->getQualifiedForeignKey(), '=', new Expression($otherKey));
-    }
-
-    /**
-     * Set the constraints for an eager load of the relation.
-     *
-     * @param  array $entities
-     * @return void
-     */
-    public function addEagerConstraints(array $entities)
-    {
-        // We'll grab the primary key name of the related models since it could be set to
-        // a non-standard name and not "id". We will then construct the constraint for
-        // our eagerly loading query so it returns the proper models from execution.
-        $key = $this->relatedMap->getTable() . '.' . $this->otherKey;
-
-        $this->query->whereIn($key, $this->getEagerModelKeys($entities));
-    }
-
-    /**
-     * Gather the keys from an array of related models.
-     *
-     * @param  array $entities
-     * @return array
-     */
-    protected function getEagerModelKeys(array $entities)
-    {
-        $keys = [];
-
-        // First we need to gather all of the keys from the parent models so we know what
-        // to query for via the eager loading query. We will add them to an array then
-        // execute a "where in" statement to gather up all of those related records.
-        foreach ($entities as $entity) {
-            $entity = $this->factory->make($entity);
-
-            if (!is_null($value = $entity->getEntityAttribute($this->foreignKey))) {
-                $keys[] = $value;
-            }
-        }
-
-        // If there are no keys that were not null we will just return an array with 0 in
-        // it so the query doesn't fail, but will not return any results, which should
-        // be what this developer is expecting in a case where this happens to them.
-        if (count($keys) == 0) {
-            return [0];
-        }
-
-        return array_values(array_unique($keys));
-    }
-
-    /**
-     * Initialize the relation on a set of models.
-     *
-     * @param  array  $entities
-     * @param  string $relation
-     * @return array
-     */
-    public function initRelation(array $entities, $relation)
-    {
-        foreach ($entities as $entity) {
-            $entity = $this->factory->make($entity);
-            $entity->setEntityAttribute($relation, null);
-        }
-
-        return $entities;
-    }
-
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param  array            $entities
-     * @param  EntityCollection $results
-     * @param  string           $relation
-     * @return array
-     */
-    public function match(array $entities, EntityCollection $results, $relation)
-    {
-        $foreign = $this->foreignKey;
-
-        $other = $this->otherKey;
-
-        // First we will get to build a dictionary of the child models by their primary
-        // key of the relationship, then we can easily match the children back onto
-        // the parents using that dictionary and the primary key of the children.
-        $dictionary = [];
-
-        foreach ($results as $result) {
-            $result = $this->factory->make($result);
-            $dictionary[$result->getEntityAttribute($other)] = $result->getObject();
-        }
-
-        // Once we have the dictionary constructed, we can loop through all the parents
-        // and match back onto their children using these keys of the dictionary and
-        // the primary key of the children to map them onto the correct instances.
-        foreach ($entities as $entity) {
-            $entity = $this->factory->make($entity);
-
-            if (isset($dictionary[$entity->getEntityAttribute($foreign)])) {
-                $entity->setEntityAttribute($relation, $dictionary[$entity->getEntityAttribute($foreign)]);
-            }
-        }
-
-        return $entities;
-    }
-
-    public function sync(array $entities)
-    {
-        if (count($entities) > 1) {
-            throw new MappingException("Single Relationship shouldn't be synced with more than one entity");
-        }
+	/**
+	 * The foreign key of the parent model.
+	 *
+	 * @var string
+	 */
+	protected $foreignKey;
+
+	/**
+	 * The associated key on the parent model.
+	 *
+	 * @var string
+	 */
+	protected $otherKey;
+
+	/**
+	 * The name of the relationship.
+	 *
+	 * @var string
+	 */
+	protected $relation;
+
+	/**
+	 * Indicate if the parent entity hold the key for the relation.
+	 *
+	 * @var boolean
+	 */
+	protected static $ownForeignKey = true;
+
+	/**
+	 * Create a new belongs to relationship instance.
+	 *
+	 * @param Mapper   $mapper
+	 * @param Mappable $parent
+	 * @param string   $foreignKey
+	 * @param string   $otherKey
+	 * @param string   $relation
+	 */
+	public function __construct(Mapper $mapper, $parent, $foreignKey, $otherKey, $relation)
+	{
+		$this->otherKey = $otherKey;
+		$this->relation = $relation;
+		$this->foreignKey = $foreignKey;
+
+		parent::__construct($mapper, $parent);
+	}
+
+	/**
+	 * @param  $related
+	 * @return mixed
+	 */
+	public function attachTo($related)
+	{
+		$this->associate($related);
+	}
+
+	/**
+	 * @param $related
+	 * @return Mappable
+	 */
+	public function detachFrom($related)
+	{
+		return $this->dissociate($related); //todo
+	}
+
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @param  $relation
+	 *
+	 * @return \Analogue\ORM\Entity
+	 */
+	public function getResults($relation)
+	{
+		$result = $this->query->first();
+
+		$this->cacheRelation($result, $relation);
+
+		return $result;
+	}
+
+	/**
+	 * Set the base constraints on the relation query.
+	 *
+	 * @return void
+	 */
+	public function addConstraints()
+	{
+		if (static::$constraints) {
+			// For belongs to relationships, which are essentially the inverse of has one
+			// or has many relationships, we need to actually query on the primary key
+			// of the related models matching on the foreign key that's on a parent.
+			$table = $this->relatedMap->getTable();
+
+			$this->query->where($table . '.' . $this->otherKey, '=', $this->parent->getEntityAttribute($this->foreignKey));
+		}
+	}
+
+	/**
+	 * Add the constraints for a relationship count query.
+	 *
+	 * @param  Query $query
+	 * @param  Query $parent
+	 * @return Query
+	 */
+	public function getRelationCountQuery(Query $query, Query $parent)
+	{
+		$query->select(new Expression('count(*)'));
+
+		$otherKey = $this->wrap($query->getTable() . '.' . $this->otherKey);
+
+		return $query->where($this->getQualifiedForeignKey(), '=', new Expression($otherKey));
+	}
+
+	/**
+	 * Set the constraints for an eager load of the relation.
+	 *
+	 * @param  array $entities
+	 * @return void
+	 */
+	public function addEagerConstraints(array $entities)
+	{
+		// We'll grab the primary key name of the related models since it could be set to
+		// a non-standard name and not "id". We will then construct the constraint for
+		// our eagerly loading query so it returns the proper models from execution.
+		$key = $this->relatedMap->getTable() . '.' . $this->otherKey;
+
+		$this->query->whereIn($key, $this->getEagerModelKeys($entities));
+	}
+
+	/**
+	 * Gather the keys from an array of related models.
+	 *
+	 * @param  array $entities
+	 * @return array
+	 */
+	protected function getEagerModelKeys(array $entities)
+	{
+		$keys = [];
+
+		// First we need to gather all of the keys from the parent models so we know what
+		// to query for via the eager loading query. We will add them to an array then
+		// execute a "where in" statement to gather up all of those related records.
+		foreach ($entities as $entity) {
+			$entity = $this->factory->make($entity);
+
+			if (!is_null($value = $entity->getEntityAttribute($this->foreignKey))) {
+				$keys[] = $value;
+			}
+		}
+
+		// If there are no keys that were not null we will just return an array with 0 in
+		// it so the query doesn't fail, but will not return any results, which should
+		// be what this developer is expecting in a case where this happens to them.
+		if (count($keys) == 0) {
+			return [0];
+		}
+
+		return array_values(array_unique($keys));
+	}
+
+	/**
+	 * Initialize the relation on a set of models.
+	 *
+	 * @param  array  $entities
+	 * @param  string $relation
+	 * @return array
+	 */
+	public function initRelation(array $entities, $relation)
+	{
+		foreach ($entities as $entity) {
+			$entity = $this->factory->make($entity);
+			$entity->setEntityAttribute($relation, null);
+		}
+
+		return $entities;
+	}
+
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param  array            $entities
+	 * @param  EntityCollection $results
+	 * @param  string           $relation
+	 * @return array
+	 */
+	public function match(array $entities, EntityCollection $results, $relation)
+	{
+		$foreign = $this->foreignKey;
+
+		$other = $this->otherKey;
+
+		// First we will get to build a dictionary of the child models by their primary
+		// key of the relationship, then we can easily match the children back onto
+		// the parents using that dictionary and the primary key of the children.
+		$dictionary = [];
+
+		foreach ($results as $result) {
+			$result = $this->factory->make($result);
+			$dictionary[$result->getEntityAttribute($other)] = $result->getObject();
+		}
+
+		// Once we have the dictionary constructed, we can loop through all the parents
+		// and match back onto their children using these keys of the dictionary and
+		// the primary key of the children to map them onto the correct instances.
+		foreach ($entities as $entity) {
+			$entity = $this->factory->make($entity);
+
+			if (isset($dictionary[$entity->getEntityAttribute($foreign)])) {
+				$entity->setEntityAttribute($relation, $dictionary[$entity->getEntityAttribute($foreign)]);
+			}
+		}
+
+		return $entities;
+	}
+
+	public function sync(array $entities)
+	{
+		if (count($entities) > 1) {
+			throw new MappingException("Single Relationship shouldn't be synced with more than one entity");
+		}
         
-        if (count($entities) == 1) {
-            return $this->associate($entities[0]);
-        }
-
-        return false;
-    }
-
-    /**
-     * Associate the model instance to the given parent.
-     *
-     * @param  mixed $entity
-     * @return void
-     */
-    public function associate($entity)
-    {
-        $this->parent->setEntityAttribute($this->foreignKey, $entity->getEntityAttribute($this->otherKey));
-    }
-
-    /**
-     * Dissociate previously associated model from the given parent.
-     *
-     * @return Mappable
-     */
-    public function dissociate()
-    {
-        // The Mapper will retrieve this association within the object model, we won't be using
-        // the foreign key attribute inside the parent Entity.
-        //
-        //$this->parent->setEntityAttribute($this->foreignKey, null);
-
-        $this->parent->setEntityAttribute($this->relation, null);
-    }
-
-    /**
-     * Get the foreign key of the relationship.
-     *
-     * @return string
-     */
-    public function getForeignKey()
-    {
-        return $this->foreignKey;
-    }
-
-    /**
-     * Get the foreign key value pair for a related object
-     *
-     * @param  mixed $related
-     *
-     * @return array
-     */
-    public function getForeignKeyValuePair($related)
-    {
-        $foreignKey = $this->getForeignKey();
-
-        if ($related) {
-            $wrapper = $this->factory->make($related);
-
-            $relatedKey = $this->relatedMap->getKeyName();
-
-            return [$foreignKey => $wrapper->getEntityAttribute($relatedKey)];
-        } else {
-            return [$foreignKey => null];
-        }
-    }
-
-    /**
-     * Get the fully qualified foreign key of the relationship.
-     *
-     * @return string
-     */
-    public function getQualifiedForeignKey()
-    {
-        return $this->parentMap->getTable() . '.' . $this->foreignKey;
-    }
-
-    /**
-     * Get the associated key of the relationship.
-     *
-     * @return string
-     */
-    public function getOtherKey()
-    {
-        return $this->otherKey;
-    }
-
-    /**
-     * Get the fully qualified associated key of the relationship.
-     *
-     * @return string
-     */
-    public function getQualifiedOtherKeyName()
-    {
-        return $this->relatedMap->getTable() . '.' . $this->otherKey;
-    }
+		if (count($entities) == 1) {
+			return $this->associate($entities[0]);
+		}
+
+		return false;
+	}
+
+	/**
+	 * Associate the model instance to the given parent.
+	 *
+	 * @param  mixed $entity
+	 * @return void
+	 */
+	public function associate($entity)
+	{
+		$this->parent->setEntityAttribute($this->foreignKey, $entity->getEntityAttribute($this->otherKey));
+	}
+
+	/**
+	 * Dissociate previously associated model from the given parent.
+	 *
+	 * @return Mappable
+	 */
+	public function dissociate()
+	{
+		// The Mapper will retrieve this association within the object model, we won't be using
+		// the foreign key attribute inside the parent Entity.
+		//
+		//$this->parent->setEntityAttribute($this->foreignKey, null);
+
+		$this->parent->setEntityAttribute($this->relation, null);
+	}
+
+	/**
+	 * Get the foreign key of the relationship.
+	 *
+	 * @return string
+	 */
+	public function getForeignKey()
+	{
+		return $this->foreignKey;
+	}
+
+	/**
+	 * Get the foreign key value pair for a related object
+	 *
+	 * @param  mixed $related
+	 *
+	 * @return array
+	 */
+	public function getForeignKeyValuePair($related)
+	{
+		$foreignKey = $this->getForeignKey();
+
+		if ($related) {
+			$wrapper = $this->factory->make($related);
+
+			$relatedKey = $this->relatedMap->getKeyName();
+
+			return [$foreignKey => $wrapper->getEntityAttribute($relatedKey)];
+		} else {
+			return [$foreignKey => null];
+		}
+	}
+
+	/**
+	 * Get the fully qualified foreign key of the relationship.
+	 *
+	 * @return string
+	 */
+	public function getQualifiedForeignKey()
+	{
+		return $this->parentMap->getTable() . '.' . $this->foreignKey;
+	}
+
+	/**
+	 * Get the associated key of the relationship.
+	 *
+	 * @return string
+	 */
+	public function getOtherKey()
+	{
+		return $this->otherKey;
+	}
+
+	/**
+	 * Get the fully qualified associated key of the relationship.
+	 *
+	 * @return string
+	 */
+	public function getQualifiedOtherKeyName()
+	{
+		return $this->relatedMap->getTable() . '.' . $this->otherKey;
+	}
 }

src/Relationships/Relationship.php

Indentation +425 added lines, -425 removed lines

@@ -19,430 +19,430 @@
  */
 abstract class Relationship
 {
-    /**
-     * The mapper instance for the related entity
-     *
-     * @var Mapper
-     */
-    protected $relatedMapper;
-
-    /**
-     * The Analogue Query Builder instance.
-     *
-     * @var Query
-     */
-    protected $query;
-
-    /**
-     * The parent entity proxy instance.
-     *
-     * @var InternallyMappable
-     */
-    protected $parent;
-
-    /**
-     * The parent entity map
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $parentMap;
-
-    /**
-     * The Parent Mapper instance
-     *
-     * @var Mapper
-     */
-    protected $parentMapper;
-
-    /**
-     * The related entity instance.
-     *
-     * @var object
-     */
-    protected $related;
-
-    /**
-     * The related entity Map
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $relatedMap;
-
-    /**
-     * Indicate if the parent entity hold the key for the relation.
-     *
-     * @var boolean
-     */
-    protected static $ownForeignKey = false;
-
-    /**
-     * Indicate if the relationships use a pivot table.*
-     *
-     * @var boolean
-     */
-    protected static $hasPivot = false;
-
-    /**
-     * Indicates if the relation is adding constraints.
-     *
-     * @var bool
-     */
-    protected static $constraints = true;
-
-    /**
-     * Wrapper factory
-     *
-     * @var \Analogue\ORM\System\Wrappers\Factory
-     */
-    protected $factory;
-
-    /**
-     * Create a new relation instance.
-     *
-     * @param  Mapper   $mapper
-     * @param  Mappable $parent
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     */
-    public function __construct(Mapper $mapper, $parent)
-    {
-        $this->relatedMapper = $mapper;
-
-        $this->query = $mapper->getQuery();
-
-        $this->factory = new Factory;
-
-        $this->parent = $this->factory->make($parent);
-
-        $this->parentMapper = $mapper->getManager()->getMapper($parent);
-
-        $this->parentMap = $this->parentMapper->getEntityMap();
-
-        $this->related = $this->query->getEntityInstance();
-
-        $this->relatedMap = $mapper->getEntityMap();
-
-        $this->addConstraints();
-    }
-
-    /**
-     * @param $related
-     * @return mixed
-     */
-    abstract public function attachTo($related);
-
-    /**
-     * @param $related
-     * @return mixed
-     */
-    abstract public function detachFrom($related);
-
-    /**
-     * Indicate if the parent entity hold the foreign key for relation.
-     *
-     * @return boolean
-     */
-    public function ownForeignKey()
-    {
-        return static::$ownForeignKey;
-    }
-
-    /**
-     * Indicate if the relationship uses a pivot table
-     *
-     * @return boolean
-     */
-    public function hasPivot()
-    {
-        return static::$hasPivot;
-    }
-
-    /**
-     * Set the base constraints on the relation query.
-     *
-     * @return void
-     */
-    abstract public function addConstraints();
-
-    /**
-     * Set the constraints for an eager load of the relation.
-     *
-     * @param  array $models
-     * @return void
-     */
-    abstract public function addEagerConstraints(array $models);
-
-    /**
-     * Initialize the relation on a set of models.
-     *
-     * @param  array  $models
-     * @param  string $relation
-     * @return array
-     */
-    abstract public function initRelation(array $models, $relation);
-
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param  array            $entities
-     * @param  EntityCollection $results
-     * @param  string           $relation
-     * @return array
-     */
-    abstract public function match(array $entities, EntityCollection $results, $relation);
-
-    /**
-     * Get the results of the relationship.
-     *
-     * @param string $relation relation name in parent's entity map
-     * @return mixed
-     */
-    abstract public function getResults($relation);
-
-    /**
-     * Get the relationship for eager loading.
-     *
-     * @return EntityCollection
-     */
-    public function getEager()
-    {
-        return $this->get();
-    }
-
-    /**
-     * Add the constraints for a relationship count query.
-     *
-     * @param  Query $query
-     * @param  Query $parent
-     * @return Query
-     */
-    public function getRelationCountQuery(Query $query, Query $parent)
-    {
-        $query->select(new Expression('count(*)'));
-
-        $key = $this->wrap($this->getQualifiedParentKeyName());
-
-        return $query->where($this->getHasCompareKey(), '=', new Expression($key));
-    }
-
-    /**
-     * Run a callback with constraints disabled on the relation.
-     *
-     * @param  Closure $callback
-     * @return mixed
-     */
-    public static function noConstraints(Closure $callback)
-    {
-        static::$constraints = false;
-
-        // When resetting the relation where clause, we want to shift the first element
-        // off of the bindings, leaving only the constraints that the developers put
-        // as "extra" on the relationships, and not original relation constraints.
-        $results = call_user_func($callback);
-
-        static::$constraints = true;
-
-        return $results;
-    }
-
-    /**
-     * Get all of the primary keys for an array of entities.
-     *
-     * @param  array  $entities
-     * @param  string $key
-     * @return array
-     */
-    protected function getKeys(array $entities, $key = null)
-    {
-        if (is_null($key)) {
-            $key = $this->relatedMap->getKeyName();
-        }
-
-        $host = $this;
-
-        return array_unique(array_values(array_map(function ($value) use ($key, $host) {
-            if (!$value instanceof InternallyMappable) {
-                $value = $host->factory->make($value);
-            }
-
-            return $value->getEntityAttribute($key);
-
-        }, $entities)));
-    }
-
-    /**
-     * Get the underlying query for the relation.
-     *
-     * @return Query
-     */
-    public function getQuery()
-    {
-        return $this->query;
-    }
-
-    /**
-     * Get the base query builder
-     *
-     * @return \Analogue\ORM\Drivers\QueryAdapter
-     */
-    public function getBaseQuery()
-    {
-        return $this->query->getQuery();
-    }
-
-    /**
-     * Get the parent model of the relation.
-     *
-     * @return InternallyMappable
-     */
-    public function getParent()
-    {
-        return $this->parent;
-    }
-
-    /**
-     * Get the fully qualified parent key name.
-     *
-     * @return string
-     */
-    protected function getQualifiedParentKeyName()
-    {
-        return $this->parent->getQualifiedKeyName();
-    }
-
-    /**
-     * Get the related entity of the relation.
-     *
-     * @return \Analogue\ORM\Entity
-     */
-    public function getRelated()
-    {
-        return $this->related;
-    }
-
-    /**
-     * Get the related mapper for the relation
-     *
-     * @return Mapper
-     */
-    public function getRelatedMapper()
-    {
-        return $this->relatedMapper;
-    }
-
-
-    /**
-     * Get the name of the "created at" column.
-     *
-     * @return string
-     */
-    public function createdAt()
-    {
-        return $this->parentMap->getCreatedAtColumn();
-    }
-
-    /**
-     * Get the name of the "updated at" column.
-     *
-     * @return string
-     */
-    public function updatedAt()
-    {
-        return $this->parentMap->getUpdatedAtColumn();
-    }
-
-    /**
-     * Get the name of the related model's "updated at" column.
-     *
-     * @return string
-     */
-    public function relatedUpdatedAt()
-    {
-        return $this->related->getUpdatedAtColumn();
-    }
-
-    /**
-     * Wrap the given value with the parent query's grammar.
-     *
-     * @param  string $value
-     * @return string
-     */
-    public function wrap($value)
-    {
-        return $this->parentMapper->getQuery()->getQuery()->getGrammar()->wrap($value);
-    }
-
-    /**
-     * Get a fresh timestamp
-     *
-     * @return Carbon
-     */
-    protected function freshTimestamp()
-    {
-        return new Carbon;
-    }
-
-    /**
-     * Cache the link between parent and related
-     * into the mapper's Entity Cache.
-     *
-     * @param  EntityCollection|Mappable $results  result of the relation query
-     * @param  string                    $relation name of the relation method on the parent entity
-     * @return void
-     */
-    protected function cacheRelation($results, $relation)
-    {
-        $cache = $this->parentMapper->getEntityCache();
-
-        $cache->cacheLoadedRelationResult($this->parent, $relation, $results, $this);
-    }
-
-    /**
-     * Return Pivot attributes when available on a relationship
-     *
-     * @return array
-     */
-    public function getPivotAttributes()
-    {
-        return [];
-    }
-
-    /**
-     * Get a combo type.primaryKey
-     *
-     * @param  Mappable $entity
-     * @return string
-     */
-    protected function getEntityHash(Mappable $entity)
-    {
-        $class = get_class($entity);
-
-        $keyName = Mapper::getMapper($class)->getEntityMap()->getKeyName();
-
-        return $class . '.' . $entity->getEntityAttribute($keyName);
-    }
-
-    /**
-     * Run synchronization content if needed by the
-     * relation type.
-     *
-     * @param  array $actualContent
-     * @return void
-     */
-    abstract public function sync(array $actualContent);
+	/**
+	 * The mapper instance for the related entity
+	 *
+	 * @var Mapper
+	 */
+	protected $relatedMapper;
+
+	/**
+	 * The Analogue Query Builder instance.
+	 *
+	 * @var Query
+	 */
+	protected $query;
+
+	/**
+	 * The parent entity proxy instance.
+	 *
+	 * @var InternallyMappable
+	 */
+	protected $parent;
+
+	/**
+	 * The parent entity map
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $parentMap;
+
+	/**
+	 * The Parent Mapper instance
+	 *
+	 * @var Mapper
+	 */
+	protected $parentMapper;
+
+	/**
+	 * The related entity instance.
+	 *
+	 * @var object
+	 */
+	protected $related;
+
+	/**
+	 * The related entity Map
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $relatedMap;
+
+	/**
+	 * Indicate if the parent entity hold the key for the relation.
+	 *
+	 * @var boolean
+	 */
+	protected static $ownForeignKey = false;
+
+	/**
+	 * Indicate if the relationships use a pivot table.*
+	 *
+	 * @var boolean
+	 */
+	protected static $hasPivot = false;
+
+	/**
+	 * Indicates if the relation is adding constraints.
+	 *
+	 * @var bool
+	 */
+	protected static $constraints = true;
+
+	/**
+	 * Wrapper factory
+	 *
+	 * @var \Analogue\ORM\System\Wrappers\Factory
+	 */
+	protected $factory;
+
+	/**
+	 * Create a new relation instance.
+	 *
+	 * @param  Mapper   $mapper
+	 * @param  Mappable $parent
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 */
+	public function __construct(Mapper $mapper, $parent)
+	{
+		$this->relatedMapper = $mapper;
+
+		$this->query = $mapper->getQuery();
+
+		$this->factory = new Factory;
+
+		$this->parent = $this->factory->make($parent);
+
+		$this->parentMapper = $mapper->getManager()->getMapper($parent);
+
+		$this->parentMap = $this->parentMapper->getEntityMap();
+
+		$this->related = $this->query->getEntityInstance();
+
+		$this->relatedMap = $mapper->getEntityMap();
+
+		$this->addConstraints();
+	}
+
+	/**
+	 * @param $related
+	 * @return mixed
+	 */
+	abstract public function attachTo($related);
+
+	/**
+	 * @param $related
+	 * @return mixed
+	 */
+	abstract public function detachFrom($related);
+
+	/**
+	 * Indicate if the parent entity hold the foreign key for relation.
+	 *
+	 * @return boolean
+	 */
+	public function ownForeignKey()
+	{
+		return static::$ownForeignKey;
+	}
+
+	/**
+	 * Indicate if the relationship uses a pivot table
+	 *
+	 * @return boolean
+	 */
+	public function hasPivot()
+	{
+		return static::$hasPivot;
+	}
+
+	/**
+	 * Set the base constraints on the relation query.
+	 *
+	 * @return void
+	 */
+	abstract public function addConstraints();
+
+	/**
+	 * Set the constraints for an eager load of the relation.
+	 *
+	 * @param  array $models
+	 * @return void
+	 */
+	abstract public function addEagerConstraints(array $models);
+
+	/**
+	 * Initialize the relation on a set of models.
+	 *
+	 * @param  array  $models
+	 * @param  string $relation
+	 * @return array
+	 */
+	abstract public function initRelation(array $models, $relation);
+
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param  array            $entities
+	 * @param  EntityCollection $results
+	 * @param  string           $relation
+	 * @return array
+	 */
+	abstract public function match(array $entities, EntityCollection $results, $relation);
+
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @param string $relation relation name in parent's entity map
+	 * @return mixed
+	 */
+	abstract public function getResults($relation);
+
+	/**
+	 * Get the relationship for eager loading.
+	 *
+	 * @return EntityCollection
+	 */
+	public function getEager()
+	{
+		return $this->get();
+	}
+
+	/**
+	 * Add the constraints for a relationship count query.
+	 *
+	 * @param  Query $query
+	 * @param  Query $parent
+	 * @return Query
+	 */
+	public function getRelationCountQuery(Query $query, Query $parent)
+	{
+		$query->select(new Expression('count(*)'));
+
+		$key = $this->wrap($this->getQualifiedParentKeyName());
+
+		return $query->where($this->getHasCompareKey(), '=', new Expression($key));
+	}
+
+	/**
+	 * Run a callback with constraints disabled on the relation.
+	 *
+	 * @param  Closure $callback
+	 * @return mixed
+	 */
+	public static function noConstraints(Closure $callback)
+	{
+		static::$constraints = false;
+
+		// When resetting the relation where clause, we want to shift the first element
+		// off of the bindings, leaving only the constraints that the developers put
+		// as "extra" on the relationships, and not original relation constraints.
+		$results = call_user_func($callback);
+
+		static::$constraints = true;
+
+		return $results;
+	}
+
+	/**
+	 * Get all of the primary keys for an array of entities.
+	 *
+	 * @param  array  $entities
+	 * @param  string $key
+	 * @return array
+	 */
+	protected function getKeys(array $entities, $key = null)
+	{
+		if (is_null($key)) {
+			$key = $this->relatedMap->getKeyName();
+		}
+
+		$host = $this;
+
+		return array_unique(array_values(array_map(function ($value) use ($key, $host) {
+			if (!$value instanceof InternallyMappable) {
+				$value = $host->factory->make($value);
+			}
+
+			return $value->getEntityAttribute($key);
+
+		}, $entities)));
+	}
+
+	/**
+	 * Get the underlying query for the relation.
+	 *
+	 * @return Query
+	 */
+	public function getQuery()
+	{
+		return $this->query;
+	}
+
+	/**
+	 * Get the base query builder
+	 *
+	 * @return \Analogue\ORM\Drivers\QueryAdapter
+	 */
+	public function getBaseQuery()
+	{
+		return $this->query->getQuery();
+	}
+
+	/**
+	 * Get the parent model of the relation.
+	 *
+	 * @return InternallyMappable
+	 */
+	public function getParent()
+	{
+		return $this->parent;
+	}
+
+	/**
+	 * Get the fully qualified parent key name.
+	 *
+	 * @return string
+	 */
+	protected function getQualifiedParentKeyName()
+	{
+		return $this->parent->getQualifiedKeyName();
+	}
+
+	/**
+	 * Get the related entity of the relation.
+	 *
+	 * @return \Analogue\ORM\Entity
+	 */
+	public function getRelated()
+	{
+		return $this->related;
+	}
+
+	/**
+	 * Get the related mapper for the relation
+	 *
+	 * @return Mapper
+	 */
+	public function getRelatedMapper()
+	{
+		return $this->relatedMapper;
+	}
+
+
+	/**
+	 * Get the name of the "created at" column.
+	 *
+	 * @return string
+	 */
+	public function createdAt()
+	{
+		return $this->parentMap->getCreatedAtColumn();
+	}
+
+	/**
+	 * Get the name of the "updated at" column.
+	 *
+	 * @return string
+	 */
+	public function updatedAt()
+	{
+		return $this->parentMap->getUpdatedAtColumn();
+	}
+
+	/**
+	 * Get the name of the related model's "updated at" column.
+	 *
+	 * @return string
+	 */
+	public function relatedUpdatedAt()
+	{
+		return $this->related->getUpdatedAtColumn();
+	}
+
+	/**
+	 * Wrap the given value with the parent query's grammar.
+	 *
+	 * @param  string $value
+	 * @return string
+	 */
+	public function wrap($value)
+	{
+		return $this->parentMapper->getQuery()->getQuery()->getGrammar()->wrap($value);
+	}
+
+	/**
+	 * Get a fresh timestamp
+	 *
+	 * @return Carbon
+	 */
+	protected function freshTimestamp()
+	{
+		return new Carbon;
+	}
+
+	/**
+	 * Cache the link between parent and related
+	 * into the mapper's Entity Cache.
+	 *
+	 * @param  EntityCollection|Mappable $results  result of the relation query
+	 * @param  string                    $relation name of the relation method on the parent entity
+	 * @return void
+	 */
+	protected function cacheRelation($results, $relation)
+	{
+		$cache = $this->parentMapper->getEntityCache();
+
+		$cache->cacheLoadedRelationResult($this->parent, $relation, $results, $this);
+	}
+
+	/**
+	 * Return Pivot attributes when available on a relationship
+	 *
+	 * @return array
+	 */
+	public function getPivotAttributes()
+	{
+		return [];
+	}
+
+	/**
+	 * Get a combo type.primaryKey
+	 *
+	 * @param  Mappable $entity
+	 * @return string
+	 */
+	protected function getEntityHash(Mappable $entity)
+	{
+		$class = get_class($entity);
+
+		$keyName = Mapper::getMapper($class)->getEntityMap()->getKeyName();
+
+		return $class . '.' . $entity->getEntityAttribute($keyName);
+	}
+
+	/**
+	 * Run synchronization content if needed by the
+	 * relation type.
+	 *
+	 * @param  array $actualContent
+	 * @return void
+	 */
+	abstract public function sync(array $actualContent);
     
-    /**
-     * Handle dynamic method calls to the relationship.
-     *
-     * @param  string $method
-     * @param  array  $parameters
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        $result = call_user_func_array([$this->query, $method], $parameters);
-
-        if ($result === $this->query) {
-            return $this;
-        }
-
-        return $result;
-    }
+	/**
+	 * Handle dynamic method calls to the relationship.
+	 *
+	 * @param  string $method
+	 * @param  array  $parameters
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		$result = call_user_func_array([$this->query, $method], $parameters);
+
+		if ($result === $this->query) {
+			return $this;
+		}
+
+		return $result;
+	}
 }

src/System/Aggregate.php

Indentation +992 added lines, -992 removed lines

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

src/System/Manager.php

Indentation +455 added lines, -455 removed lines

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

src/System/Mapper.php

Indentation +556 added lines, -556 removed lines

@@ -22,563 +22,563 @@
  */
 class Mapper
 {
-    /**
-     * The Manager instance
-     *
-     * @var \Analogue\ORM\System\Manager
-     */
-    protected $manager;
-
-    /**
-     * Instance of EntityMapper Object
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * The instance of db adapter
-     *
-     * @var \Analogue\ORM\Drivers\DBAdapter
-     */
-    protected $adapter;
-
-
-    /**
-     * Event dispatcher instance
-     *
-     * @var \Illuminate\Contracts\Events\Dispatcher
-     */
-    protected $dispatcher;
-
-    /**
-     * Entity Cache
-     *
-     * @var  \Analogue\ORM\System\EntityCache
-     */
-    protected $cache;
-
-    /**
-     * Global scopes
-     *
-     * @var array
-     */
-    protected $globalScopes = [];
-
-    /**
-     * Custom Commands
-     *
-     * @var array
-     */
-    protected $customCommands = [];
-
-    /**
-     * @param EntityMap  $entityMap
-     * @param DBAdapter  $adapter
-     * @param Dispatcher $dispatcher
-     * @param Manager    $manager
-     */
-    public function __construct(EntityMap $entityMap, DBAdapter $adapter, Dispatcher $dispatcher, Manager $manager)
-    {
-        $this->entityMap = $entityMap;
-
-        $this->adapter = $adapter;
-
-        $this->dispatcher = $dispatcher;
-
-        $this->manager = $manager;
-
-        $this->cache = new EntityCache($entityMap);
-    }
-
-    /**
-     * Persist an entity or an entity collection into the database
-     *
-     * @param  Mappable|Collection $entity
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     * @return Mappable|Collection
-     */
-    public function store($entity)
-    {
-        if ($this->isArrayOrCollection($entity)) {
-            return $this->storeCollection($entity);
-        } else {
-            return $this->storeEntity($entity);
-        }
-    }
-
-    /**
-     * Return true if an object is an array or collection
-     *
-     * @param  mixed $argument
-     * @return boolean
-     */
-    protected function isArrayOrCollection($argument)
-    {
-        return $argument instanceof Collection || is_array($argument);
-    }
-
-    /**
-     * Store a single entity into the database
-     *
-     * @param  Mappable $entity
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     * @return \Analogue\ORM\Entity
-     */
-    protected function storeEntity($entity)
-    {
-        $this->checkEntityType($entity);
-
-        $store = new Store($this->aggregate($entity), $this->newQueryBuilder());
-
-        return $store->execute();
-    }
-
-    /**
-     * Convert an entity into an aggregate root
-     *
-     * @param  mixed $entity
-     * @throws MappingException
-     * @return \Analogue\ORM\System\Aggregate
-     */
-    protected function aggregate($entity)
-    {
-        return new Aggregate($entity);
-    }
-
-    /**
-     * Store an entity collection inside a single DB Transaction
-     *
-     * @param  Collection|array $entities
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     * @return Collection
-     */
-    protected function storeCollection($entities)
-    {
-        $this->adapter->beginTransaction();
-
-        foreach ($entities as $entity) {
-            $this->storeEntity($entity);
-        }
-
-        $this->adapter->commit();
-
-        return $entities;
-    }
-
-    /**
-     * Delete an entity or an entity collection from the database
-     *
-     * @param  mixed|Collection
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     * @return Collection|void
-     */
-    public function delete($entity)
-    {
-        if ($this->isArrayOrCollection($entity)) {
-            return $this->deleteCollection($entity);
-        } else {
-            $this->deleteEntity($entity);
-        }
-    }
-
-    /**
-     * Delete a single entity from the database.
-     *
-     * @param  Mappable $entity
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     * @return void
-     */
-    protected function deleteEntity($entity)
-    {
-        $this->checkEntityType($entity);
-
-        $delete = new Delete($this->aggregate($entity), $this->newQueryBuilder());
-
-        $delete->execute();
-    }
-
-    /**
-     * Delete an Entity Collection inside a single db transaction
-     *
-     * @param  Collection|array $entities
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     * @return Collection
-     */
-    protected function deleteCollection($entities)
-    {
-        $this->adapter->beginTransaction();
-
-        foreach ($entities as $entity) {
-            $this->deleteEntity($entity);
-        }
-
-        $this->adapter->commit();
+	/**
+	 * The Manager instance
+	 *
+	 * @var \Analogue\ORM\System\Manager
+	 */
+	protected $manager;
+
+	/**
+	 * Instance of EntityMapper Object
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * The instance of db adapter
+	 *
+	 * @var \Analogue\ORM\Drivers\DBAdapter
+	 */
+	protected $adapter;
+
+
+	/**
+	 * Event dispatcher instance
+	 *
+	 * @var \Illuminate\Contracts\Events\Dispatcher
+	 */
+	protected $dispatcher;
+
+	/**
+	 * Entity Cache
+	 *
+	 * @var  \Analogue\ORM\System\EntityCache
+	 */
+	protected $cache;
+
+	/**
+	 * Global scopes
+	 *
+	 * @var array
+	 */
+	protected $globalScopes = [];
+
+	/**
+	 * Custom Commands
+	 *
+	 * @var array
+	 */
+	protected $customCommands = [];
+
+	/**
+	 * @param EntityMap  $entityMap
+	 * @param DBAdapter  $adapter
+	 * @param Dispatcher $dispatcher
+	 * @param Manager    $manager
+	 */
+	public function __construct(EntityMap $entityMap, DBAdapter $adapter, Dispatcher $dispatcher, Manager $manager)
+	{
+		$this->entityMap = $entityMap;
+
+		$this->adapter = $adapter;
+
+		$this->dispatcher = $dispatcher;
+
+		$this->manager = $manager;
+
+		$this->cache = new EntityCache($entityMap);
+	}
+
+	/**
+	 * Persist an entity or an entity collection into the database
+	 *
+	 * @param  Mappable|Collection $entity
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 * @return Mappable|Collection
+	 */
+	public function store($entity)
+	{
+		if ($this->isArrayOrCollection($entity)) {
+			return $this->storeCollection($entity);
+		} else {
+			return $this->storeEntity($entity);
+		}
+	}
+
+	/**
+	 * Return true if an object is an array or collection
+	 *
+	 * @param  mixed $argument
+	 * @return boolean
+	 */
+	protected function isArrayOrCollection($argument)
+	{
+		return $argument instanceof Collection || is_array($argument);
+	}
+
+	/**
+	 * Store a single entity into the database
+	 *
+	 * @param  Mappable $entity
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 * @return \Analogue\ORM\Entity
+	 */
+	protected function storeEntity($entity)
+	{
+		$this->checkEntityType($entity);
+
+		$store = new Store($this->aggregate($entity), $this->newQueryBuilder());
+
+		return $store->execute();
+	}
+
+	/**
+	 * Convert an entity into an aggregate root
+	 *
+	 * @param  mixed $entity
+	 * @throws MappingException
+	 * @return \Analogue\ORM\System\Aggregate
+	 */
+	protected function aggregate($entity)
+	{
+		return new Aggregate($entity);
+	}
+
+	/**
+	 * Store an entity collection inside a single DB Transaction
+	 *
+	 * @param  Collection|array $entities
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 * @return Collection
+	 */
+	protected function storeCollection($entities)
+	{
+		$this->adapter->beginTransaction();
+
+		foreach ($entities as $entity) {
+			$this->storeEntity($entity);
+		}
+
+		$this->adapter->commit();
+
+		return $entities;
+	}
+
+	/**
+	 * Delete an entity or an entity collection from the database
+	 *
+	 * @param  mixed|Collection
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 * @return Collection|void
+	 */
+	public function delete($entity)
+	{
+		if ($this->isArrayOrCollection($entity)) {
+			return $this->deleteCollection($entity);
+		} else {
+			$this->deleteEntity($entity);
+		}
+	}
+
+	/**
+	 * Delete a single entity from the database.
+	 *
+	 * @param  Mappable $entity
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 * @return void
+	 */
+	protected function deleteEntity($entity)
+	{
+		$this->checkEntityType($entity);
+
+		$delete = new Delete($this->aggregate($entity), $this->newQueryBuilder());
+
+		$delete->execute();
+	}
+
+	/**
+	 * Delete an Entity Collection inside a single db transaction
+	 *
+	 * @param  Collection|array $entities
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 * @return Collection
+	 */
+	protected function deleteCollection($entities)
+	{
+		$this->adapter->beginTransaction();
+
+		foreach ($entities as $entity) {
+			$this->deleteEntity($entity);
+		}
+
+		$this->adapter->commit();
         
-        return $entities;
-    }
-
-    /**
-     * Return the entity map for this mapper
-     *
-     * @return EntityMap
-     */
-    public function getEntityMap()
-    {
-        return $this->entityMap;
-    }
-
-    /**
-     * Get the entity cache for the current mapper
-     *
-     * @return EntityCache  $entityCache
-     */
-    public function getEntityCache()
-    {
-        return $this->cache;
-    }
-
-    /**
-     * Fire the given event for the entity
-     *
-     * @param  string               $event
-     * @param  \Analogue\ORM\Entity $entity
-     * @param  bool                 $halt
-     * @throws InvalidArgumentException
-     * @return mixed
-     */
-    public function fireEvent($event, $entity, $halt = true)
-    {
-        if ($entity instanceof Wrapper) {
-            throw new InvalidArgumentException('Fired Event with invalid Entity Object');
-        }
-
-        $event = "analogue.{$event}." . $this->entityMap->getClass();
-
-        $method = $halt ? 'until' : 'fire';
-
-        return $this->dispatcher->$method($event, $entity);
-    }
-
-    /**
-     * Register an entity event with the dispatcher.
-     *
-     * @param  string   $event
-     * @param  \Closure $callback
-     * @return void
-     */
-    public function registerEvent($event, $callback)
-    {
-        $name = $this->entityMap->getClass();
-
-        $this->dispatcher->listen("analogue.{$event}.{$name}", $callback);
-    }
-
-    /**
-     * Add a global scope to this mapper query builder
-     *
-     * @param  ScopeInterface $scope
-     * @return void
-     */
-    public function addGlobalScope(ScopeInterface $scope)
-    {
-        $this->globalScopes[get_class($scope)] = $scope;
-    }
-
-    /**
-     * Determine if the mapper has a global scope.
-     *
-     * @param  \Analogue\ORM\System\ScopeInterface $scope
-     * @return bool
-     */
-    public function hasGlobalScope($scope)
-    {
-        return !is_null($this->getGlobalScope($scope));
-    }
-
-    /**
-     * Get a global scope registered with the modal.
-     *
-     * @param  \Analogue\ORM\System\ScopeInterface $scope
-     * @return \Analogue\ORM\System\ScopeInterface|null
-     */
-    public function getGlobalScope($scope)
-    {
-        return array_first($this->globalScopes, function ($key, $value) use ($scope) {
-            return $scope instanceof $value;
-        });
-    }
-
-    /**
-     * Get the global scopes for this class instance.
-     *
-     * @return \Analogue\ORM\System\ScopeInterface
-     */
-    public function getGlobalScopes()
-    {
-        return $this->globalScopes;
-    }
-
-    /**
-     * Apply all of the global scopes to an Analogue Query builder.
-     *
-     * @param Query $query
-     * @return \Analogue\ORM\System\Query
-     */
-    public function applyGlobalScopes($query)
-    {
-        foreach ($this->getGlobalScopes() as $scope) {
-            $scope->apply($query, $this);
-        }
-
-        return $query;
-    }
-
-    /**
-     * Remove all of the global scopes from an Analogue Query builder.
-     *
-     * @param Query $query
-     * @return \Analogue\ORM\System\Query
-     */
-    public function removeGlobalScopes($query)
-    {
-        foreach ($this->getGlobalScopes() as $scope) {
-            $scope->remove($query, $this);
-        }
-
-        return $query;
-    }
-
-    /**
-     * Get a new query instance without a given scope.
-     *
-     * @param  \Analogue\ORM\System\ScopeInterface $scope
-     * @return \Analogue\ORM\System\Query
-     */
-    public function newQueryWithoutScope($scope)
-    {
-        $this->getGlobalScope($scope)->remove($query = $this->getQuery(), $this);
-
-        return $query;
-    }
-
-    /**
-     * Get a new query builder that doesn't have any global scopes.
-     *
-     * @return Query
-     */
-    public function newQueryWithoutScopes()
-    {
-        return $this->removeGlobalScopes($this->getQuery());
-    }
-
-    /**
-     * Add a dynamic method that extends the mapper/repository
-     *
-     * @param string $command
-     */
-    public function addCustomCommand($command)
-    {
-        $name = lcfirst(class_basename($command));
-
-        $this->customCommands[$name] = $command;
-    }
-
-    /**
-     * Execute a custom command on an Entity
-     *
-     * @param  string                 $command
-     * @param  mixed|Collection|array $entity
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     * @return mixed
-     */
-    public function executeCustomCommand($command, $entity)
-    {
-        $commandClass = $this->customCommands[$command];
-
-        if ($this->isArrayOrCollection($entity)) {
-            foreach ($entity as $instance) {
-                $this->executeSingleCustomCommand($commandClass, $instance);
-            }
-        } else {
-            return $this->executeSingleCustomCommand($commandClass, $entity);
-        }
-    }
-
-    /**
-     * Execute a single command instance
-     *
-     * @param  string $commandClass
-     * @param  mixed  $entity
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     * @return mixed
-     */
-    protected function executeSingleCustomCommand($commandClass, $entity)
-    {
-        $this->checkEntityType($entity);
-
-        $instance = new $commandClass($this->aggregate($entity), $this->newQueryBuilder());
-
-        return $instance->execute();
-    }
-
-    /**
-     * Check that the entity correspond to the current mapper.
-     *
-     * @param  mixed $entity
-     * @throws InvalidArgumentException
-     * @return void
-     */
-    protected function checkEntityType($entity)
-    {
-        if (get_class($entity) != $this->entityMap->getClass()) {
-            $expected = $this->entityMap->getClass();
-            $actual = get_class($entity);
-            throw new InvalidArgumentException("Expected : $expected, got $actual.");
-        }
-    }
-
-    /**
-     * Get all the custom commands registered on this mapper
-     *
-     * @return array
-     */
-    public function getCustomCommands()
-    {
-        return array_keys($this->customCommands);
-    }
-
-    /**
-     * Check if this mapper supports this command
-     * @param  string $command
-     * @return boolean
-     */
-    public function hasCustomCommand($command)
-    {
-        return in_array($command, $this->getCustomCommands());
-    }
-
-    /**
-     * Create a new instance of the mapped entity class
-     *
-     * @param  array $attributes
-     * @return mixed
-     */
-    public function newInstance($attributes = [])
-    {
-        $class = $this->entityMap->getClass();
-
-        if ($this->entityMap->activator() != null) {
-            $entity = $this->entityMap->activator();
-        } else {
-            $entity = $this->customClassInstance($class);
-        }
-
-        // prevent hydrating with an empty array
-        if (count($attributes) > 0) {
-            $entity->setEntityAttributes($attributes);
-        }
-
-        return $entity;
-    }
-
-    /**
-     * Use a trick to generate a class prototype that we
-     * can instantiate without calling the constructor.
-     *
-     * @param string|null $className
-     * @throws MappingException
-     * @return mixed
-     */
-    protected function customClassInstance($className)
-    {
-        if (!class_exists($className)) {
-            throw new MappingException("Tried to instantiate a non-existing Entity class : $className");
-        }
-
-        $prototype = unserialize(sprintf('O:%d:"%s":0:{}', strlen($className), $className));
-        return $prototype;
-    }
+		return $entities;
+	}
+
+	/**
+	 * Return the entity map for this mapper
+	 *
+	 * @return EntityMap
+	 */
+	public function getEntityMap()
+	{
+		return $this->entityMap;
+	}
+
+	/**
+	 * Get the entity cache for the current mapper
+	 *
+	 * @return EntityCache  $entityCache
+	 */
+	public function getEntityCache()
+	{
+		return $this->cache;
+	}
+
+	/**
+	 * Fire the given event for the entity
+	 *
+	 * @param  string               $event
+	 * @param  \Analogue\ORM\Entity $entity
+	 * @param  bool                 $halt
+	 * @throws InvalidArgumentException
+	 * @return mixed
+	 */
+	public function fireEvent($event, $entity, $halt = true)
+	{
+		if ($entity instanceof Wrapper) {
+			throw new InvalidArgumentException('Fired Event with invalid Entity Object');
+		}
+
+		$event = "analogue.{$event}." . $this->entityMap->getClass();
+
+		$method = $halt ? 'until' : 'fire';
+
+		return $this->dispatcher->$method($event, $entity);
+	}
+
+	/**
+	 * Register an entity event with the dispatcher.
+	 *
+	 * @param  string   $event
+	 * @param  \Closure $callback
+	 * @return void
+	 */
+	public function registerEvent($event, $callback)
+	{
+		$name = $this->entityMap->getClass();
+
+		$this->dispatcher->listen("analogue.{$event}.{$name}", $callback);
+	}
+
+	/**
+	 * Add a global scope to this mapper query builder
+	 *
+	 * @param  ScopeInterface $scope
+	 * @return void
+	 */
+	public function addGlobalScope(ScopeInterface $scope)
+	{
+		$this->globalScopes[get_class($scope)] = $scope;
+	}
+
+	/**
+	 * Determine if the mapper has a global scope.
+	 *
+	 * @param  \Analogue\ORM\System\ScopeInterface $scope
+	 * @return bool
+	 */
+	public function hasGlobalScope($scope)
+	{
+		return !is_null($this->getGlobalScope($scope));
+	}
+
+	/**
+	 * Get a global scope registered with the modal.
+	 *
+	 * @param  \Analogue\ORM\System\ScopeInterface $scope
+	 * @return \Analogue\ORM\System\ScopeInterface|null
+	 */
+	public function getGlobalScope($scope)
+	{
+		return array_first($this->globalScopes, function ($key, $value) use ($scope) {
+			return $scope instanceof $value;
+		});
+	}
+
+	/**
+	 * Get the global scopes for this class instance.
+	 *
+	 * @return \Analogue\ORM\System\ScopeInterface
+	 */
+	public function getGlobalScopes()
+	{
+		return $this->globalScopes;
+	}
+
+	/**
+	 * Apply all of the global scopes to an Analogue Query builder.
+	 *
+	 * @param Query $query
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function applyGlobalScopes($query)
+	{
+		foreach ($this->getGlobalScopes() as $scope) {
+			$scope->apply($query, $this);
+		}
+
+		return $query;
+	}
+
+	/**
+	 * Remove all of the global scopes from an Analogue Query builder.
+	 *
+	 * @param Query $query
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function removeGlobalScopes($query)
+	{
+		foreach ($this->getGlobalScopes() as $scope) {
+			$scope->remove($query, $this);
+		}
+
+		return $query;
+	}
+
+	/**
+	 * Get a new query instance without a given scope.
+	 *
+	 * @param  \Analogue\ORM\System\ScopeInterface $scope
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function newQueryWithoutScope($scope)
+	{
+		$this->getGlobalScope($scope)->remove($query = $this->getQuery(), $this);
+
+		return $query;
+	}
+
+	/**
+	 * Get a new query builder that doesn't have any global scopes.
+	 *
+	 * @return Query
+	 */
+	public function newQueryWithoutScopes()
+	{
+		return $this->removeGlobalScopes($this->getQuery());
+	}
+
+	/**
+	 * Add a dynamic method that extends the mapper/repository
+	 *
+	 * @param string $command
+	 */
+	public function addCustomCommand($command)
+	{
+		$name = lcfirst(class_basename($command));
+
+		$this->customCommands[$name] = $command;
+	}
+
+	/**
+	 * Execute a custom command on an Entity
+	 *
+	 * @param  string                 $command
+	 * @param  mixed|Collection|array $entity
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 * @return mixed
+	 */
+	public function executeCustomCommand($command, $entity)
+	{
+		$commandClass = $this->customCommands[$command];
+
+		if ($this->isArrayOrCollection($entity)) {
+			foreach ($entity as $instance) {
+				$this->executeSingleCustomCommand($commandClass, $instance);
+			}
+		} else {
+			return $this->executeSingleCustomCommand($commandClass, $entity);
+		}
+	}
+
+	/**
+	 * Execute a single command instance
+	 *
+	 * @param  string $commandClass
+	 * @param  mixed  $entity
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 * @return mixed
+	 */
+	protected function executeSingleCustomCommand($commandClass, $entity)
+	{
+		$this->checkEntityType($entity);
+
+		$instance = new $commandClass($this->aggregate($entity), $this->newQueryBuilder());
+
+		return $instance->execute();
+	}
+
+	/**
+	 * Check that the entity correspond to the current mapper.
+	 *
+	 * @param  mixed $entity
+	 * @throws InvalidArgumentException
+	 * @return void
+	 */
+	protected function checkEntityType($entity)
+	{
+		if (get_class($entity) != $this->entityMap->getClass()) {
+			$expected = $this->entityMap->getClass();
+			$actual = get_class($entity);
+			throw new InvalidArgumentException("Expected : $expected, got $actual.");
+		}
+	}
+
+	/**
+	 * Get all the custom commands registered on this mapper
+	 *
+	 * @return array
+	 */
+	public function getCustomCommands()
+	{
+		return array_keys($this->customCommands);
+	}
+
+	/**
+	 * Check if this mapper supports this command
+	 * @param  string $command
+	 * @return boolean
+	 */
+	public function hasCustomCommand($command)
+	{
+		return in_array($command, $this->getCustomCommands());
+	}
+
+	/**
+	 * Create a new instance of the mapped entity class
+	 *
+	 * @param  array $attributes
+	 * @return mixed
+	 */
+	public function newInstance($attributes = [])
+	{
+		$class = $this->entityMap->getClass();
+
+		if ($this->entityMap->activator() != null) {
+			$entity = $this->entityMap->activator();
+		} else {
+			$entity = $this->customClassInstance($class);
+		}
+
+		// prevent hydrating with an empty array
+		if (count($attributes) > 0) {
+			$entity->setEntityAttributes($attributes);
+		}
+
+		return $entity;
+	}
+
+	/**
+	 * Use a trick to generate a class prototype that we
+	 * can instantiate without calling the constructor.
+	 *
+	 * @param string|null $className
+	 * @throws MappingException
+	 * @return mixed
+	 */
+	protected function customClassInstance($className)
+	{
+		if (!class_exists($className)) {
+			throw new MappingException("Tried to instantiate a non-existing Entity class : $className");
+		}
+
+		$prototype = unserialize(sprintf('O:%d:"%s":0:{}', strlen($className), $className));
+		return $prototype;
+	}
     
-    /**
-     * Get the Analogue Query Builder for this instance
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function getQuery()
-    {
-        $query = new Query($this, $this->adapter);
-
-        return $this->applyGlobalScopes($query);
-    }
+	/**
+	 * Get the Analogue Query Builder for this instance
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function getQuery()
+	{
+		$query = new Query($this, $this->adapter);
+
+		return $this->applyGlobalScopes($query);
+	}
     
-    /**
-     * Get the Analogue Query Builder for this instance
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function query()
-    {
-        return $this->getQuery();
-    }
-
-    /**
-     * Get an unscoped Analogue Query Builder for this instance
-     *
-     * @return \Analogue\ORM\System\Query
-     */
-    public function globalQuery()
-    {
-        return $this->newQueryWithoutScopes();
-    }
-
-    /**
-     * Get a the Underlying QueryAdapter.
-     *
-     * @return \Analogue\ORM\Drivers\QueryAdapter
-     */
-    public function newQueryBuilder()
-    {
-        return $this->adapter->getQuery();
-    }
-
-    /**
-     * Return the manager instance
-     *
-     * @return \Analogue\ORM\System\Manager
-     */
-    public function getManager()
-    {
-        return $this->manager;
-    }
-
-    /**
-     * Dynamically handle calls to custom commands, or Redirects to query()
-     *
-     * @param  string $method
-     * @param  array  $parameters
-     * @throws \Exception
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        // Check if method is a custom command on the mapper
-        if ($this->hasCustomCommand($method)) {
-            if (count($parameters) == 0) {
-                throw new \Exception("$method must at least have 1 argument");
-            }
-            return $this->executeCustomCommand($method, $parameters[0]);
-        }
-
-        // Redirect call on a new query instance
-        return call_user_func_array([$this->query(), $method], $parameters);
-    }
+	/**
+	 * Get the Analogue Query Builder for this instance
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function query()
+	{
+		return $this->getQuery();
+	}
+
+	/**
+	 * Get an unscoped Analogue Query Builder for this instance
+	 *
+	 * @return \Analogue\ORM\System\Query
+	 */
+	public function globalQuery()
+	{
+		return $this->newQueryWithoutScopes();
+	}
+
+	/**
+	 * Get a the Underlying QueryAdapter.
+	 *
+	 * @return \Analogue\ORM\Drivers\QueryAdapter
+	 */
+	public function newQueryBuilder()
+	{
+		return $this->adapter->getQuery();
+	}
+
+	/**
+	 * Return the manager instance
+	 *
+	 * @return \Analogue\ORM\System\Manager
+	 */
+	public function getManager()
+	{
+		return $this->manager;
+	}
+
+	/**
+	 * Dynamically handle calls to custom commands, or Redirects to query()
+	 *
+	 * @param  string $method
+	 * @param  array  $parameters
+	 * @throws \Exception
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		// Check if method is a custom command on the mapper
+		if ($this->hasCustomCommand($method)) {
+			if (count($parameters) == 0) {
+				throw new \Exception("$method must at least have 1 argument");
+			}
+			return $this->executeCustomCommand($method, $parameters[0]);
+		}
+
+		// Redirect call on a new query instance
+		return call_user_func_array([$this->query(), $method], $parameters);
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -259,7 +259,7 @@ 
             throw new InvalidArgumentException('Fired Event with invalid Entity Object');
         }
 
-        $event = "analogue.{$event}." . $this->entityMap->getClass();
+        $event = "analogue.{$event}.".$this->entityMap->getClass();
 
         $method = $halt ? 'until' : 'fire';
 
@@ -310,7 +310,7 @@ 
      */
     public function getGlobalScope($scope)
     {
-        return array_first($this->globalScopes, function ($key, $value) use ($scope) {
+        return array_first($this->globalScopes, function($key, $value) use ($scope) {
             return $scope instanceof $value;
         });
     }

src/System/Query.php

Indentation +837 added lines, -837 removed lines

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

Spacing +7 added lines, -7 removed lines

@@ -466,7 +466,7 @@ 
             $count = new Expression($count);
         }
 
-        return $this->where(new Expression('(' . $hasQuery->toSql() . ')'), $operator, $count, $boolean);
+        return $this->where(new Expression('('.$hasQuery->toSql().')'), $operator, $count, $boolean);
     }
 
     /**
@@ -499,7 +499,7 @@ 
      */
     protected function getHasRelationQuery($relation, $entity)
     {
-        return Relationship::noConstraints(function () use ($relation, $entity) {
+        return Relationship::noConstraints(function() use ($relation, $entity) {
             return $this->entityMap->$relation($entity);
         });
     }
@@ -548,7 +548,7 @@ 
             // constraints have been specified for the eager load and we'll just put
             // an empty Closure with the loader so that we can treat all the same.
             if (is_numeric($name)) {
-                $f = function () {};
+                $f = function() {};
 
                 list($name, $constraints) = [$constraints, $f];
             }
@@ -583,7 +583,7 @@ 
             $progress[] = $segment;
 
             if (!isset($results[$last = implode('.', $progress)])) {
-                $results[$last] = function () {};
+                $results[$last] = function() {};
             }
         }
 
@@ -672,7 +672,7 @@ 
         // We want to run a relationship query without any constrains so that we will
         // not have to remove these where clauses manually which gets really hacky
         // and is error prone while we remove the developer's own where clauses.
-        $query = Relationship::noConstraints(function () use ($relation) {
+        $query = Relationship::noConstraints(function() use ($relation) {
             return $this->entityMap->$relation($this->getEntityInstance());
         });
 
@@ -703,7 +703,7 @@ 
         // that start with the given top relations and adds them to our arrays.
         foreach ($this->eagerLoad as $name => $constraints) {
             if ($this->isNested($name, $relation)) {
-                $nested[substr($name, strlen($relation . '.'))] = $constraints;
+                $nested[substr($name, strlen($relation.'.'))] = $constraints;
             }
         }
 
@@ -721,7 +721,7 @@ 
     {
         $dots = str_contains($name, '.');
 
-        return $dots && starts_with($name, $relation . '.');
+        return $dots && starts_with($name, $relation.'.');
     }
 
     /**