analogueorm / analogue

src/System/Wrappers/Wrapper.php

Indentation +103 added lines, -103 removed lines

@@ -11,107 +11,107 @@
  */
 abstract class Wrapper implements InternallyMappable
 {
-    /**
-     * Original Entity Object
-     *
-     * @var mixed
-     */
-    protected $entity;
-
-    /**
-     * Corresponding EntityMap
-     *
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $entityMap;
-
-    /**
-     * Wrapper constructor.
-     * @param $entity
-     * @param $entityMap
-     */
-    public function __construct($entity, $entityMap)
-    {
-        $this->entity = $entity;
-        $this->entityMap = $entityMap;
-    }
-
-    /**
-     * Return the wrapped entity class
-     *
-     * @return mixed
-     */
-    public function getEntityClass()
-    {
-        return get_class($this->entity);
-    }
-
-    /**
-     * Returns the wrapped entity
-     *
-     * @return mixed
-     */
-    public function getObject()
-    {
-        return $this->entity;
-    }
-
-    /**
-     * Set the lazyloading proxies on the wrapped entity objet
-     *
-     * @return void
-     */
-    public function setProxies()
-    {
-        $attributes = $this->getEntityAttributes();
-        $singleRelations = $this->entityMap->getSingleRelationships();
-        $manyRelations = $this->entityMap->getManyRelationships();
-
-        $proxies = [];
-
-        foreach ($this->entityMap->getRelationships() as $relation) {
-            if (!array_key_exists($relation, $attributes) || is_null($attributes[$relation])) {
-                if (in_array($relation, $singleRelations)) {
-                    $proxies[$relation] = new EntityProxy($this->getObject(), $relation);
-                }
-                if (in_array($relation, $manyRelations)) {
-                    $proxies[$relation] = new CollectionProxy($this->getObject(), $relation);
-                }
-            }
-        }
-
-        foreach ($proxies as $key => $value) {
-            $this->setEntityAttribute($key, $value);
-        }
-    }
-
-    /**
-     * @param string $key
-     * @param string $value
-     * @return mixed
-     */
-    abstract public function setEntityAttribute($key, $value);
-
-    /**
-     * @param string $key
-     * @return mixed
-     */
-    abstract public function getEntityAttribute($key);
-
-    /**
-     * @param array $attributes
-     * @return mixed
-     */
-    abstract public function setEntityAttributes(array $attributes);
-
-    /**
-     * @return mixed
-     */
-    abstract public function getEntityAttributes();
-
-    /**
-     * @param string $key
-     * @return mixed
-     */
-    abstract public function hasAttribute($key);
+	/**
+	 * Original Entity Object
+	 *
+	 * @var mixed
+	 */
+	protected $entity;
+
+	/**
+	 * Corresponding EntityMap
+	 *
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $entityMap;
+
+	/**
+	 * Wrapper constructor.
+	 * @param $entity
+	 * @param $entityMap
+	 */
+	public function __construct($entity, $entityMap)
+	{
+		$this->entity = $entity;
+		$this->entityMap = $entityMap;
+	}
+
+	/**
+	 * Return the wrapped entity class
+	 *
+	 * @return mixed
+	 */
+	public function getEntityClass()
+	{
+		return get_class($this->entity);
+	}
+
+	/**
+	 * Returns the wrapped entity
+	 *
+	 * @return mixed
+	 */
+	public function getObject()
+	{
+		return $this->entity;
+	}
+
+	/**
+	 * Set the lazyloading proxies on the wrapped entity objet
+	 *
+	 * @return void
+	 */
+	public function setProxies()
+	{
+		$attributes = $this->getEntityAttributes();
+		$singleRelations = $this->entityMap->getSingleRelationships();
+		$manyRelations = $this->entityMap->getManyRelationships();
+
+		$proxies = [];
+
+		foreach ($this->entityMap->getRelationships() as $relation) {
+			if (!array_key_exists($relation, $attributes) || is_null($attributes[$relation])) {
+				if (in_array($relation, $singleRelations)) {
+					$proxies[$relation] = new EntityProxy($this->getObject(), $relation);
+				}
+				if (in_array($relation, $manyRelations)) {
+					$proxies[$relation] = new CollectionProxy($this->getObject(), $relation);
+				}
+			}
+		}
+
+		foreach ($proxies as $key => $value) {
+			$this->setEntityAttribute($key, $value);
+		}
+	}
+
+	/**
+	 * @param string $key
+	 * @param string $value
+	 * @return mixed
+	 */
+	abstract public function setEntityAttribute($key, $value);
+
+	/**
+	 * @param string $key
+	 * @return mixed
+	 */
+	abstract public function getEntityAttribute($key);
+
+	/**
+	 * @param array $attributes
+	 * @return mixed
+	 */
+	abstract public function setEntityAttributes(array $attributes);
+
+	/**
+	 * @return mixed
+	 */
+	abstract public function getEntityAttributes();
+
+	/**
+	 * @param string $key
+	 * @return mixed
+	 */
+	abstract public function hasAttribute($key);
 }

src/System/Wrappers/PlainObjectWrapper.php

Indentation +195 added lines, -195 removed lines

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

Spacing +1 added lines, -1 removed lines

@@ -81,7 +81,7 @@
 
         // We need to filter out properties that could belong to the object
         // and which are not intended to be handled by the ORM
-        return array_filter($objectProperties, function (\ReflectionProperty $item) use ($attributeList) {
+        return array_filter($objectProperties, function(\ReflectionProperty $item) use ($attributeList) {
             if (in_array($item->getName(), $attributeList)) {
                 return true;
             }

src/System/Proxies/EntityProxy.php

Indentation +68 added lines, -68 removed lines

@@ -4,81 +4,81 @@
 
 class EntityProxy extends Proxy
 {
-    /**
-     * Underlying entity
-     *
-     * @var mixed
-     */
-    protected $entity;
+	/**
+	 * Underlying entity
+	 *
+	 * @var mixed
+	 */
+	protected $entity;
 
-    /**
-     * Load the underlying relation
-     *
-     * @return void
-     */
-    protected function loadOnce()
-    {
-        $this->entity = $this->load();
-    }
+	/**
+	 * Load the underlying relation
+	 *
+	 * @return void
+	 */
+	protected function loadOnce()
+	{
+		$this->entity = $this->load();
+	}
 
-    /**
-     * Return the actual Entity
-     *
-     * @return mixed
-     */
-    public function getUnderlyingObject()
-    {
-        if (!$this->isLoaded()) {
-            $this->loadOnce();
-        }
+	/**
+	 * Return the actual Entity
+	 *
+	 * @return mixed
+	 */
+	public function getUnderlyingObject()
+	{
+		if (!$this->isLoaded()) {
+			$this->loadOnce();
+		}
 
-        return $this->entity;
-    }
+		return $this->entity;
+	}
 
-    /**
-     * Transparently passes get operation to underlying entity
-     *
-     * @param  string $attribute
-     * @return mixed
-     */
-    public function __get($attribute)
-    {
-        if (!$this->isLoaded()) {
-            $this->loadOnce();
-        }
+	/**
+	 * Transparently passes get operation to underlying entity
+	 *
+	 * @param  string $attribute
+	 * @return mixed
+	 */
+	public function __get($attribute)
+	{
+		if (!$this->isLoaded()) {
+			$this->loadOnce();
+		}
 
-        return $this->entity->$attribute;
-    }
+		return $this->entity->$attribute;
+	}
 
-    /**
-     * Transparently passes set operation to underlying entity
-     *
-     * @param  string $attribute [description]
-     * @param  mixed
-     * @return void
-     */
-    public function __set($attribute, $value)
-    {
-        if (!$this->isLoaded()) {
-            $this->loadOnce();
-        }
+	/**
+	 * Transparently passes set operation to underlying entity
+	 *
+	 * @param  string $attribute [description]
+	 * @param  mixed
+	 * @return void
+	 */
+	public function __set($attribute, $value)
+	{
+		if (!$this->isLoaded()) {
+			$this->loadOnce();
+		}
 
-        $this->entity->$attribute = $value;
-    }
+		$this->entity->$attribute = $value;
+	}
 
-    /**
-     * Transparently Redirect non overrided calls to the lazy loaded Entity
-     *
-     * @param  string $method
-     * @param  array  $parameters
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        if (!$this->isLoaded()) {
-            $this->loadOnce();
-        }
+	/**
+	 * Transparently Redirect non overrided calls to the lazy loaded Entity
+	 *
+	 * @param  string $method
+	 * @param  array  $parameters
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		if (!$this->isLoaded()) {
+			$this->loadOnce();
+		}
 
-        return call_user_func_array([$this->loadedCollection, $method], $parameters);
-    }
+		return call_user_func_array([$this->loadedCollection, $method], $parameters);
+	}
 }

src/System/Proxies/CollectionProxy.php

Indentation +210 added lines, -210 removed lines

@@ -17,218 +17,218 @@
  */
 class CollectionProxy extends Proxy implements ArrayAccess, Arrayable, Countable, IteratorAggregate, Jsonable, JsonSerializable
 {
-    /**
-     * Underlying Lazyloaded collection
-     * @var EntityCollection
-     */
-    protected $loadedCollection;
-
-    /**
-     * Added Items Collection
-     * @var EntityCollection
-     */
-    protected $addedItems;
-
-    /**
-     * @param mixed  $parentEntity
-     * @param string $relation relationship method handled by the proxy.
-     */
-    public function __construct($parentEntity, $relation)
-    {
-        $this->addedItems = new EntityCollection;
-
-        parent::__construct($parentEntity, $relation);
-    }
-
-    /**
-     * Add an entity to the proxy collection, weither it's loaded or not
-     *
-     * @param mixed $entity
-     * @return self|void
-     */
-    public function add($entity)
-    {
-        if ($this->isLoaded()) {
-            return $this->loadedCollection->add($entity);
-        } else {
-            $this->addedItems->add($entity);
-        }
-    }
-
-    /**
-     * Check if Proxy collection has been lazy-loaded
-     *
-     * @return boolean
-     */
-    public function isLoaded()
-    {
-        return !is_null($this->loadedCollection);
-    }
-
-    /**
-     * Return the underlying collection
-     *
-     * @return EntityCollection
-     */
-    public function getUnderlyingCollection()
-    {
-        return $this->loadedCollection;
-    }
-
-    /**
-     * Return Items that has been added prior to lazy-loading
-     *
-     * @return EntityCollection
-     */
-    public function getAddedItems()
-    {
-        return $this->addedItems;
-    }
-
-    /**
-     * Load the underlying relation
-     *
-     * @return void
-     */
-    protected function loadOnce()
-    {
-        if ($this->isLoaded()) {
-            return;
-        }
+	/**
+	 * Underlying Lazyloaded collection
+	 * @var EntityCollection
+	 */
+	protected $loadedCollection;
+
+	/**
+	 * Added Items Collection
+	 * @var EntityCollection
+	 */
+	protected $addedItems;
+
+	/**
+	 * @param mixed  $parentEntity
+	 * @param string $relation relationship method handled by the proxy.
+	 */
+	public function __construct($parentEntity, $relation)
+	{
+		$this->addedItems = new EntityCollection;
+
+		parent::__construct($parentEntity, $relation);
+	}
+
+	/**
+	 * Add an entity to the proxy collection, weither it's loaded or not
+	 *
+	 * @param mixed $entity
+	 * @return self|void
+	 */
+	public function add($entity)
+	{
+		if ($this->isLoaded()) {
+			return $this->loadedCollection->add($entity);
+		} else {
+			$this->addedItems->add($entity);
+		}
+	}
+
+	/**
+	 * Check if Proxy collection has been lazy-loaded
+	 *
+	 * @return boolean
+	 */
+	public function isLoaded()
+	{
+		return !is_null($this->loadedCollection);
+	}
+
+	/**
+	 * Return the underlying collection
+	 *
+	 * @return EntityCollection
+	 */
+	public function getUnderlyingCollection()
+	{
+		return $this->loadedCollection;
+	}
+
+	/**
+	 * Return Items that has been added prior to lazy-loading
+	 *
+	 * @return EntityCollection
+	 */
+	public function getAddedItems()
+	{
+		return $this->addedItems;
+	}
+
+	/**
+	 * Load the underlying relation
+	 *
+	 * @return void
+	 */
+	protected function loadOnce()
+	{
+		if ($this->isLoaded()) {
+			return;
+		}
         
-        $this->loadedCollection = $this->load();
+		$this->loadedCollection = $this->load();
 
-        foreach ($this->addedItems as $entity) {
-            $this->loadedCollection->add($entity);
-        }
+		foreach ($this->addedItems as $entity) {
+			$this->loadedCollection->add($entity);
+		}
 
-        $this->addedItems = null;
-    }
+		$this->addedItems = null;
+	}
     
-    /**
-     * Count the number of items in the collection.
-     *
-     * @return int
-     */
-    public function count()
-    {
-        $this->loadOnce();
-
-        return $this->getUnderlyingCollection()->count();
-    }
-
-    /**
-     * Determine if an item exists at an offset.
-     *
-     * @param  mixed $key
-     * @return bool
-     */
-    public function offsetExists($key)
-    {
-        $this->loadOnce();
-
-        return $this->getUnderlyingCollection()->offsetExists($key);
-    }
-
-    /**
-     * Get an item at a given offset.
-     *
-     * @param  mixed $key
-     * @return mixed
-     */
-    public function offsetGet($key)
-    {
-        $this->loadOnce();
-
-        return $this->getUnderlyingCollection()->offsetGet($key);
-    }
-
-    /**
-     * Set the item at a given offset.
-     *
-     * @param mixed $key
-     * @param mixed $value
-     */
-    public function offsetSet($key, $value)
-    {
-        $this->loadOnce();
-
-        $this->getUnderlyingCollection()->offsetSet($key, $value);
-    }
-
-    /**
-     * Unset the item at a given offset.
-     *
-     * @param string $key
-     */
-    public function offsetUnset($key)
-    {
-        $this->loadOnce();
-
-        $this->getUnderlyingCollection()->offsetUnset($key);
-    }
-
-    /**
-     * Get the collection of items as a plain array.
-     *
-     * @return array
-     */
-    public function toArray()
-    {
-        $this->loadOnce();
-
-        return $this->getUnderlyingCollection()->toArray();
-    }
-
-    /**
-     * Convert the object into something JSON serializable.
-     *
-     * @return array
-     */
-    public function jsonSerialize()
-    {
-        $this->loadOnce();
-
-        return $this->getUnderlyingCollection()->jsonSerialize();
-    }
-
-    /**
-     * Get the collection of items as JSON.
-     *
-     * @param  int $options
-     * @return string
-     */
-    public function toJson($options = 0)
-    {
-        $this->loadOnce();
-
-        return $this->getUnderlyingCollection()->toJson();
-    }
-
-    /**
-     * Get an iterator for the items.
-     *
-     * @return \ArrayIterator
-     */
-    public function getIterator()
-    {
-        $this->loadOnce();
-
-        return $this->getUnderlyingCollection()->getIterator();
-    }
-
-
-    /**
-     * @param  $method
-     * @param  $parameters
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        if (!$this->isLoaded()) {
-            $this->loadOnce();
-        }
-
-        return call_user_func_array([$this->loadedCollection, $method], $parameters);
-    }
+	/**
+	 * Count the number of items in the collection.
+	 *
+	 * @return int
+	 */
+	public function count()
+	{
+		$this->loadOnce();
+
+		return $this->getUnderlyingCollection()->count();
+	}
+
+	/**
+	 * Determine if an item exists at an offset.
+	 *
+	 * @param  mixed $key
+	 * @return bool
+	 */
+	public function offsetExists($key)
+	{
+		$this->loadOnce();
+
+		return $this->getUnderlyingCollection()->offsetExists($key);
+	}
+
+	/**
+	 * Get an item at a given offset.
+	 *
+	 * @param  mixed $key
+	 * @return mixed
+	 */
+	public function offsetGet($key)
+	{
+		$this->loadOnce();
+
+		return $this->getUnderlyingCollection()->offsetGet($key);
+	}
+
+	/**
+	 * Set the item at a given offset.
+	 *
+	 * @param mixed $key
+	 * @param mixed $value
+	 */
+	public function offsetSet($key, $value)
+	{
+		$this->loadOnce();
+
+		$this->getUnderlyingCollection()->offsetSet($key, $value);
+	}
+
+	/**
+	 * Unset the item at a given offset.
+	 *
+	 * @param string $key
+	 */
+	public function offsetUnset($key)
+	{
+		$this->loadOnce();
+
+		$this->getUnderlyingCollection()->offsetUnset($key);
+	}
+
+	/**
+	 * Get the collection of items as a plain array.
+	 *
+	 * @return array
+	 */
+	public function toArray()
+	{
+		$this->loadOnce();
+
+		return $this->getUnderlyingCollection()->toArray();
+	}
+
+	/**
+	 * Convert the object into something JSON serializable.
+	 *
+	 * @return array
+	 */
+	public function jsonSerialize()
+	{
+		$this->loadOnce();
+
+		return $this->getUnderlyingCollection()->jsonSerialize();
+	}
+
+	/**
+	 * Get the collection of items as JSON.
+	 *
+	 * @param  int $options
+	 * @return string
+	 */
+	public function toJson($options = 0)
+	{
+		$this->loadOnce();
+
+		return $this->getUnderlyingCollection()->toJson();
+	}
+
+	/**
+	 * Get an iterator for the items.
+	 *
+	 * @return \ArrayIterator
+	 */
+	public function getIterator()
+	{
+		$this->loadOnce();
+
+		return $this->getUnderlyingCollection()->getIterator();
+	}
+
+
+	/**
+	 * @param  $method
+	 * @param  $parameters
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		if (!$this->isLoaded()) {
+			$this->loadOnce();
+		}
+
+		return call_user_func_array([$this->loadedCollection, $method], $parameters);
+	}
 }

src/System/Proxies/ProxyInterface.php

Indentation +12 added lines, -12 removed lines

@@ -5,17 +5,17 @@
 
 interface ProxyInterface
 {
-    /**
-     * Convert a proxy into the underlying related Object
-     *
-     * @return Mappable|\Analogue\ORM\EntityCollection
-     */
-    public function load();
+	/**
+	 * Convert a proxy into the underlying related Object
+	 *
+	 * @return Mappable|\Analogue\ORM\EntityCollection
+	 */
+	public function load();
 
-    /**
-     * Return true if the underlying relation has been lazy loaded
-     *
-     * @return boolean
-     */
-    public function isLoaded();
+	/**
+	 * Return true if the underlying relation has been lazy loaded
+	 *
+	 * @return boolean
+	 */
+	public function isLoaded();
 }

src/System/Proxies/Proxy.php

Indentation +72 added lines, -72 removed lines

@@ -7,87 +7,87 @@
 
 abstract class Proxy implements ProxyInterface
 {
-    /**
-     * The name of the relationship method handled by the proxy.
-     *
-     * @var string
-     */
-    protected $relation;
+	/**
+	 * The name of the relationship method handled by the proxy.
+	 *
+	 * @var string
+	 */
+	protected $relation;
 
-    /**
-     * Reference to parent entity object
-     *
-     * @var \Analogue\ORM\System\InternallyMappable
-     */
-    protected $parentEntity;
+	/**
+	 * Reference to parent entity object
+	 *
+	 * @var \Analogue\ORM\System\InternallyMappable
+	 */
+	protected $parentEntity;
 
-    /**
-     * Lazy loaded relation flag
-     *
-     * @var boolean
-     */
-    protected $loaded = false;
+	/**
+	 * Lazy loaded relation flag
+	 *
+	 * @var boolean
+	 */
+	protected $loaded = false;
 
-    /**
-     * @param mixed  $parentEntity
-     * @param string $relation     relationship method handled by the proxy.
-     */
-    public function __construct($parentEntity, $relation)
-    {
-        $this->parentEntity = $parentEntity;
+	/**
+	 * @param mixed  $parentEntity
+	 * @param string $relation     relationship method handled by the proxy.
+	 */
+	public function __construct($parentEntity, $relation)
+	{
+		$this->parentEntity = $parentEntity;
 
-        $this->relation = $relation;
-    }
+		$this->relation = $relation;
+	}
 
-    /**
-     * Call the relationship method on the underlying entity map
-     *
-     * @throws MappingException
-     * @return mixed
-     */
-    public function load()
-    {
-        $entities = $this->query($this->parentEntity, $this->relation)->getResults($this->relation);
+	/**
+	 * Call the relationship method on the underlying entity map
+	 *
+	 * @throws MappingException
+	 * @return mixed
+	 */
+	public function load()
+	{
+		$entities = $this->query($this->parentEntity, $this->relation)->getResults($this->relation);
 
-        $this->loaded = true;
+		$this->loaded = true;
 
-        return $entities;
-    }
+		return $entities;
+	}
 
-    /**
-     * Return true if the underlying relation has been lazy loaded
-     *
-     * @return boolean
-     */
-    public function isLoaded()
-    {
-        return $this->loaded;
-    }
+	/**
+	 * Return true if the underlying relation has been lazy loaded
+	 *
+	 * @return boolean
+	 */
+	public function isLoaded()
+	{
+		return $this->loaded;
+	}
 
-    /**
-     * Return the Query Builder on the relation
-     *
-     * @param  \Analogue\ORM\System\InternallyMappable  $entity
-     * @param  string $relation
-     * @throws MappingException
-     * @return \Analogue\ORM\System\Query
-     */
-    protected function query($entity, $relation)
-    {
-        $entityMap = $this->getMapper($entity)->getEntityMap();
+	/**
+	 * Return the Query Builder on the relation
+	 *
+	 * @param  \Analogue\ORM\System\InternallyMappable  $entity
+	 * @param  string $relation
+	 * @throws MappingException
+	 * @return \Analogue\ORM\System\Query
+	 */
+	protected function query($entity, $relation)
+	{
+		$entityMap = $this->getMapper($entity)->getEntityMap();
 
-        return $entityMap->$relation($entity);
-    }
+		return $entityMap->$relation($entity);
+	}
 
-    /**
-     * Get the mapper instance for the entity
-     *
-     * @param  \Analogue\ORM\System\InternallyMappable $entity
-     * @throws MappingException
-     * @return \Analogue\ORM\System\Mapper
-     */
-    protected function getMapper($entity)
-    {
-        return Manager::getMapper($entity);
-    }
+	/**
+	 * Get the mapper instance for the entity
+	 *
+	 * @param  \Analogue\ORM\System\InternallyMappable $entity
+	 * @throws MappingException
+	 * @return \Analogue\ORM\System\Mapper
+	 */
+	protected function getMapper($entity)
+	{
+		return Manager::getMapper($entity);
+	}
 }

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 +6 added lines, -6 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() {};
             }
         }
 
@@ -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.'.');
     }
 
     /**

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 +1 added lines, -1 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';
 

src/System/MapperFactory.php

Indentation +52 added lines, -52 removed lines

@@ -13,70 +13,70 @@
  */
 class MapperFactory
 {
-    /**
-     * Manager instance
-     *
-     * @var \Analogue\ORM\System\Manager
-     */
-    protected $manager;
+	/**
+	 * Manager instance
+	 *
+	 * @var \Analogue\ORM\System\Manager
+	 */
+	protected $manager;
 
-    /**
-     * DriverManager instance
-     *
-     * @var \Analogue\ORM\Drivers\Manager
-     */
-    protected $drivers;
+	/**
+	 * DriverManager instance
+	 *
+	 * @var \Analogue\ORM\Drivers\Manager
+	 */
+	protected $drivers;
 
-    /**
-     * Event dispatcher instance
-     *
-     * @var \Illuminate\Contracts\Events\Dispatcher
-     */
-    protected $dispatcher;
+	/**
+	 * Event dispatcher instance
+	 *
+	 * @var \Illuminate\Contracts\Events\Dispatcher
+	 */
+	protected $dispatcher;
 
-    /**
-     * MapperFactory constructor.
-     * @param DriverManager $drivers
-     * @param Dispatcher    $dispatcher
-     * @param Manager       $manager
-     */
-    public function __construct(DriverManager $drivers, Dispatcher $dispatcher, Manager $manager)
-    {
-        $this->drivers = $drivers;
+	/**
+	 * MapperFactory constructor.
+	 * @param DriverManager $drivers
+	 * @param Dispatcher    $dispatcher
+	 * @param Manager       $manager
+	 */
+	public function __construct(DriverManager $drivers, Dispatcher $dispatcher, Manager $manager)
+	{
+		$this->drivers = $drivers;
 
-        $this->dispatcher = $dispatcher;
+		$this->dispatcher = $dispatcher;
 
-        $this->manager = $manager;
-    }
+		$this->manager = $manager;
+	}
 
-    /**
-     * Return a new Mapper instance
-     *
-     * @param  string    $entityClass
-     * @param  EntityMap $entityMap
-     * @return Mapper
-     */
-    public function make($entityClass, EntityMap $entityMap)
-    {
-        $driver = $entityMap->getDriver();
+	/**
+	 * Return a new Mapper instance
+	 *
+	 * @param  string    $entityClass
+	 * @param  EntityMap $entityMap
+	 * @return Mapper
+	 */
+	public function make($entityClass, EntityMap $entityMap)
+	{
+		$driver = $entityMap->getDriver();
         
-        $connection = $entityMap->getConnection();
+		$connection = $entityMap->getConnection();
 
-        $adapter = $this->drivers->getAdapter($driver, $connection);
+		$adapter = $this->drivers->getAdapter($driver, $connection);
         
-        $entityMap->setDateFormat($adapter->getDateFormat());
+		$entityMap->setDateFormat($adapter->getDateFormat());
 
-        $mapper = new Mapper($entityMap, $adapter, $this->dispatcher, $this->manager);
+		$mapper = new Mapper($entityMap, $adapter, $this->dispatcher, $this->manager);
 
-        // Fire Initializing Event
-        $mapper->fireEvent('initializing', $mapper);
+		// Fire Initializing Event
+		$mapper->fireEvent('initializing', $mapper);
         
-        // Proceed necessary parsing on the EntityMap object
-        $entityMap->initialize();
+		// Proceed necessary parsing on the EntityMap object
+		$entityMap->initialize();
 
-        // Fire Initialized Event
-        $mapper->fireEvent('initialized', $mapper);
+		// Fire Initialized Event
+		$mapper->fireEvent('initialized', $mapper);
 
-        return $mapper;
-    }
+		return $mapper;
+	}
 }