analogueorm / analogue

src/System/CachedRelationship.php

Indentation +58 added lines, -58 removed lines

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

src/System/Wrappers/EntityWrapper.php

Indentation +68 added lines, -68 removed lines

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

src/System/Wrappers/Factory.php

Indentation +21 added lines, -21 removed lines

@@ -7,27 +7,27 @@
 
 class Factory
 {
-    /**
-     * Build the wrapper corresponding to the object's type
-     *
-     * @param  mixed $object
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     * @return Wrapper
-     */
-    public function make($object)
-    {
-        $manager = Manager::getInstance();
+	/**
+	 * Build the wrapper corresponding to the object's type
+	 *
+	 * @param  mixed $object
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 * @return Wrapper
+	 */
+	public function make($object)
+	{
+		$manager = Manager::getInstance();
 
-        if ($manager->isValueObject($object)) {
-            $entityMap = $manager->getValueMap($object);
-        } else {
-            $entityMap = $manager->mapper($object)->getEntityMap();
-        }
+		if ($manager->isValueObject($object)) {
+			$entityMap = $manager->getValueMap($object);
+		} else {
+			$entityMap = $manager->mapper($object)->getEntityMap();
+		}
 
-        if ($object instanceof Mappable) {
-            return new EntityWrapper($object, $entityMap);
-        } else {
-            return new PlainObjectWrapper($object, $entityMap);
-        }
-    }
+		if ($object instanceof Mappable) {
+			return new EntityWrapper($object, $entityMap);
+		} else {
+			return new PlainObjectWrapper($object, $entityMap);
+		}
+	}
 }

src/System/Wrappers/PlainObjectWrapper.php

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;
             }

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);
-
-        parent::__construct($popoEntity, $entityMap);
-
-        $this->attributeList = $this->getAttributeList();
-    }
-
-    /**
-     * Get Compiled Attributes (key, attributes, embed, relations)
-     *
-     * @return array
-     */
-    protected function getAttributeList()
-    {
-        return  $this->entityMap->getCompiledAttributes();
-    }
-
-    /**
-     * Extract Attributes from a Plain Php Object
-     *
-     * @return array $attributes
-     */
-    protected function extract()
-    {
-        $properties = $this->getMappedProperties();
-
-        $attributes = [];
-
-        foreach ($properties as $property) {
-            $name = $property->getName();
-
-            if ($property->isPublic()) {
-                $attributes[$name] = $this->entity->$name;
-            } else {
-                $property->setAccessible(true);
+	/**
+	 * The list of attributes for the managed entity
+	 *
+	 * @var array
+	 */
+	protected $attributeList;
+
+	/**
+	 * The reflection class for the managed entity
+	 *
+	 * @var ReflectionClass
+	 */
+	protected $reflection;
+
+	/**
+	 * PlainObjectWrapper constructor.
+	 * @param $popoEntity
+	 * @param $entityMap
+	 */
+	public function __construct($popoEntity, $entityMap)
+	{
+		$this->reflection = new ReflectionClass($popoEntity);
+
+		parent::__construct($popoEntity, $entityMap);
+
+		$this->attributeList = $this->getAttributeList();
+	}
+
+	/**
+	 * Get Compiled Attributes (key, attributes, embed, relations)
+	 *
+	 * @return array
+	 */
+	protected function getAttributeList()
+	{
+		return  $this->entityMap->getCompiledAttributes();
+	}
+
+	/**
+	 * Extract Attributes from a Plain Php Object
+	 *
+	 * @return array $attributes
+	 */
+	protected function extract()
+	{
+		$properties = $this->getMappedProperties();
+
+		$attributes = [];
+
+		foreach ($properties as $property) {
+			$name = $property->getName();
+
+			if ($property->isPublic()) {
+				$attributes[$name] = $this->entity->$name;
+			} else {
+				$property->setAccessible(true);
     
-                $attributes[$name] = $property->getValue($this->entity);
-            }
-        }
-
-        return $attributes;
-    }
-
-    /**
-     * @return \ReflectionProperty[]
-     */
-    protected function getMappedProperties()
-    {
-        $objectProperties = $this->reflection->getProperties();
-
-        $attributeList = $this->getAttributeList();
-
-        // We need to filter out properties that could belong to the object
-        // and which are not intended to be handled by the ORM
-        return array_filter($objectProperties, function (\ReflectionProperty $item) use ($attributeList) {
-            if (in_array($item->getName(), $attributeList)) {
-                return true;
-            }
-        });
-    }
-
-    /**
-     * @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;
+		}
+	}
 }

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/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;
+	}
 }

src/System/EntityBuilder.php

Indentation +185 added lines, -185 removed lines

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

Spacing +3 added lines, -3 removed lines

@@ -152,13 +152,13 @@
         $valueObject = $this->mapper->getManager()->getValueObjectInstance($valueClass);
 
         foreach ($embeddedAttributes as $key) {
-            $prefix = snake_case(class_basename($valueClass)) . '_';
+            $prefix = snake_case(class_basename($valueClass)).'_';
 
             $voWrapper = $this->factory->make($valueObject);
 
-            $voWrapper->setEntityAttribute($key, $attributes[$prefix . $key]);
+            $voWrapper->setEntityAttribute($key, $attributes[$prefix.$key]);
             
-            unset($attributes[$prefix . $key]);
+            unset($attributes[$prefix.$key]);
         }
         
         $attributes[$localKey] = $valueObject;