analogueorm / analogue

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;

src/System/EntityCache.php

Indentation +298 added lines, -298 removed lines

@@ -15,304 +15,304 @@
  */
 class EntityCache
 {
-    /**
-     * Entity's raw attributes/relationships
-     *
-     * @var array
-     */
-    protected $cache = [];
-
-    /**
-     * Entity Map for the current Entity Type
-     * @var [type]
-     */
-    protected $entityMap;
-
-    /**
-     * Wrapper factory
-     *
-     * @var \Analogue\ORM\System\Wrappers\Factory
-     */
-    protected $factory;
-
-    /**
-     * Associative array containing list of pivot attributes per relationship
-     * so we don't have to call relationship method on refresh.
-     *
-     * @var array
-     */
-    protected $pivotAttributes = [];
-
-    /**
-     * EntityCache constructor.
-     * @param EntityMap $entityMap
-     */
-    public function __construct(EntityMap $entityMap)
-    {
-        $this->entityMap = $entityMap;
-
-        $this->factory = new Factory;
-    }
-
-    /**
-     * Add an array of key=>attributes representing
-     * the initial state of loaded entities.
-     *
-     * @param array $entities
-     */
-    public function add(array $entities)
-    {
-        if (count($this->cache) == 0) {
-            $this->cache = $entities;
-        } else {
-            $this->mergeCacheResults($entities);
-        }
-    }
-
-    /**
-     * Retrieve initial attributes for a single entity
-     *
-     * @param  string $id
-     * @return array
-     */
-    public function get($id)
-    {
-        if ($this->has($id)) {
-            return $this->cache[$id];
-        } else {
-            return [];
-        }
-    }
-
-    /**
-     * Check if a record for this id exists.
-     *
-     * @param  string  $id
-     * @return boolean
-     */
-    public function has($id)
-    {
-        return array_key_exists($id, $this->cache);
-    }
-
-    /**
-     * Combine new result set with existing attributes in
-     * cache.
-     *
-     * @param  array $entities
-     * @return void
-     */
-    protected function mergeCacheResults($entities)
-    {
-        foreach ($entities as $key => $entity) {
-            $this->cache[$key] = $entity;
-        }
-    }
-
-    /**
-     * Cache Relation's query result for an entity
-     *
-     * @param  mixed        $parent
-     * @param  string       $relation name of the relation
-     * @param  mixed        $results  results of the relationship's query
-     * @param  Relationship $relationship
-     * @throws MappingException
-     * @return void
-     */
-    public function cacheLoadedRelationResult($parent, $relation, $results, Relationship $relationship)
-    {
-        $keyName = $this->entityMap->getKeyName();
-
-        if (!$parent instanceof InternallyMappable) {
-            $parent = $this->factory->make($parent);
-        }
-
-        $key = $parent->getEntityAttribute($keyName);
+	/**
+	 * Entity's raw attributes/relationships
+	 *
+	 * @var array
+	 */
+	protected $cache = [];
+
+	/**
+	 * Entity Map for the current Entity Type
+	 * @var [type]
+	 */
+	protected $entityMap;
+
+	/**
+	 * Wrapper factory
+	 *
+	 * @var \Analogue\ORM\System\Wrappers\Factory
+	 */
+	protected $factory;
+
+	/**
+	 * Associative array containing list of pivot attributes per relationship
+	 * so we don't have to call relationship method on refresh.
+	 *
+	 * @var array
+	 */
+	protected $pivotAttributes = [];
+
+	/**
+	 * EntityCache constructor.
+	 * @param EntityMap $entityMap
+	 */
+	public function __construct(EntityMap $entityMap)
+	{
+		$this->entityMap = $entityMap;
+
+		$this->factory = new Factory;
+	}
+
+	/**
+	 * Add an array of key=>attributes representing
+	 * the initial state of loaded entities.
+	 *
+	 * @param array $entities
+	 */
+	public function add(array $entities)
+	{
+		if (count($this->cache) == 0) {
+			$this->cache = $entities;
+		} else {
+			$this->mergeCacheResults($entities);
+		}
+	}
+
+	/**
+	 * Retrieve initial attributes for a single entity
+	 *
+	 * @param  string $id
+	 * @return array
+	 */
+	public function get($id)
+	{
+		if ($this->has($id)) {
+			return $this->cache[$id];
+		} else {
+			return [];
+		}
+	}
+
+	/**
+	 * Check if a record for this id exists.
+	 *
+	 * @param  string  $id
+	 * @return boolean
+	 */
+	public function has($id)
+	{
+		return array_key_exists($id, $this->cache);
+	}
+
+	/**
+	 * Combine new result set with existing attributes in
+	 * cache.
+	 *
+	 * @param  array $entities
+	 * @return void
+	 */
+	protected function mergeCacheResults($entities)
+	{
+		foreach ($entities as $key => $entity) {
+			$this->cache[$key] = $entity;
+		}
+	}
+
+	/**
+	 * Cache Relation's query result for an entity
+	 *
+	 * @param  mixed        $parent
+	 * @param  string       $relation name of the relation
+	 * @param  mixed        $results  results of the relationship's query
+	 * @param  Relationship $relationship
+	 * @throws MappingException
+	 * @return void
+	 */
+	public function cacheLoadedRelationResult($parent, $relation, $results, Relationship $relationship)
+	{
+		$keyName = $this->entityMap->getKeyName();
+
+		if (!$parent instanceof InternallyMappable) {
+			$parent = $this->factory->make($parent);
+		}
+
+		$key = $parent->getEntityAttribute($keyName);
         
-        if ($results instanceof EntityCollection) {
-            $this->cacheManyRelationResults($key, $relation, $results, $relationship);
-        }
-
-        // POPO : Maybe this check isn't needed, or we have to check for stdClass
-        // instead
-        if ($results instanceof Mappable) {
-            $this->cacheSingleRelationResult($key, $relation, $results, $relationship);
-        }
-    }
-
-    /**
-     * Create a cachedRelationship instance which will hold related entity's hash and pivot attributes, if any.
-     *
-     * @param               $parentKey
-     * @param  string       $relation
-     * @param               $result
-     * @param  Relationship $relationship
-     * @throws MappingException
-     * @return CachedRelationship
-     */
-    protected function getCachedRelationship($parentKey, $relation, $result, Relationship $relationship)
-    {
-        $pivotColumns = $relationship->getPivotAttributes();
-
-        if (!array_key_exists($relation, $this->pivotAttributes)) {
-            $this->pivotAttributes[$relation] = $pivotColumns;
-        }
-
-        $wrapper = $this->factory->make($result);
-
-        $hash = $this->getEntityHash($wrapper);
-
-        if (count($pivotColumns) > 0) {
-            $pivotAttributes = [];
-            foreach ($pivotColumns as $column) {
-                $pivot = $wrapper->getEntityAttribute('pivot');
-
-                $pivotWrapper = $this->factory->make($pivot);
-
-                $pivotAttributes[$column] = $pivotWrapper->getEntityAttribute($column);
-            }
-
-            $cachedRelationship = new CachedRelationship($hash, $pivotAttributes);
-        } else {
-            $cachedRelationship = new CachedRelationship($hash);
-        }
-
-        return $cachedRelationship;
-    }
-
-    /**
-     * Cache a many relationship
-     *
-     * @param                  $parentKey
-     * @param string           $relation
-     * @param EntityCollection $results
-     * @param Relationship     $relationship
-     * @throws MappingException
-     */
-    protected function cacheManyRelationResults($parentKey, $relation, $results, Relationship $relationship)
-    {
-        $this->cache[$parentKey][$relation] = [];
-
-        foreach ($results as $result) {
-            $cachedRelationship = $this->getCachedRelationship($parentKey, $relation, $result, $relationship);
-
-            $relatedHash = $cachedRelationship->getHash();
-
-            $this->cache[$parentKey][$relation][$relatedHash] = $cachedRelationship;
-        }
-    }
-
-    /**
-     * Cache a single relationship
-     *
-     * @param              $parentKey
-     * @param string       $relation
-     * @param Mappable     $result
-     * @param Relationship $relationship
-     * @throws MappingException
-     */
-    protected function cacheSingleRelationResult($parentKey, $relation, $result, Relationship $relationship)
-    {
-        $this->cache[$parentKey][$relation] = $this->getCachedRelationship($parentKey, $relation, $result, $relationship);
-    }
-
-    /**
-     * Get Entity's Hash
-     *
-     * @param  $entity
-     * @throws MappingException
-     * @return string
-     */
-    protected function getEntityHash(InternallyMappable $entity)
-    {
-        $class = get_class($entity->getObject());
-
-        $mapper = Manager::getMapper($class);
-
-        $keyName = $mapper->getEntityMap()->getKeyName();
-
-        return $class . '.' . $entity->getEntityAttribute($keyName);
-    }
-
-    /**
-     * Refresh the cache record for an aggregated entity after a write operation
-     * @param Aggregate $entity
-     */
-    public function refresh(Aggregate $entity)
-    {
-        $this->cache[$entity->getEntityId()] = $this->transform($entity);
-    }
-
-    /**
-     * Transform an Aggregated Entity into a cache record
-     *
-     * @param  Aggregate $aggregatedEntity
-     * @throws MappingException
-     * @return array
-     */
-    protected function transform(Aggregate $aggregatedEntity)
-    {
-        $baseAttributes = $aggregatedEntity->getRawAttributes();
-
-        $relationAttributes = [];
-
-        // First we'll handle each relationships that are a one to one
-        // relation, and which will be saved as a CachedRelationship
-        // object inside the cache.
-
-        // NOTE : storing localRelationships maybe useless has we store
-        // the foreign key in the attributes already.
-
-        foreach ($this->entityMap->getSingleRelationships() as $relation) {
-            $aggregates = $aggregatedEntity->getRelationship($relation);
+		if ($results instanceof EntityCollection) {
+			$this->cacheManyRelationResults($key, $relation, $results, $relationship);
+		}
+
+		// POPO : Maybe this check isn't needed, or we have to check for stdClass
+		// instead
+		if ($results instanceof Mappable) {
+			$this->cacheSingleRelationResult($key, $relation, $results, $relationship);
+		}
+	}
+
+	/**
+	 * Create a cachedRelationship instance which will hold related entity's hash and pivot attributes, if any.
+	 *
+	 * @param               $parentKey
+	 * @param  string       $relation
+	 * @param               $result
+	 * @param  Relationship $relationship
+	 * @throws MappingException
+	 * @return CachedRelationship
+	 */
+	protected function getCachedRelationship($parentKey, $relation, $result, Relationship $relationship)
+	{
+		$pivotColumns = $relationship->getPivotAttributes();
+
+		if (!array_key_exists($relation, $this->pivotAttributes)) {
+			$this->pivotAttributes[$relation] = $pivotColumns;
+		}
+
+		$wrapper = $this->factory->make($result);
+
+		$hash = $this->getEntityHash($wrapper);
+
+		if (count($pivotColumns) > 0) {
+			$pivotAttributes = [];
+			foreach ($pivotColumns as $column) {
+				$pivot = $wrapper->getEntityAttribute('pivot');
+
+				$pivotWrapper = $this->factory->make($pivot);
+
+				$pivotAttributes[$column] = $pivotWrapper->getEntityAttribute($column);
+			}
+
+			$cachedRelationship = new CachedRelationship($hash, $pivotAttributes);
+		} else {
+			$cachedRelationship = new CachedRelationship($hash);
+		}
+
+		return $cachedRelationship;
+	}
+
+	/**
+	 * Cache a many relationship
+	 *
+	 * @param                  $parentKey
+	 * @param string           $relation
+	 * @param EntityCollection $results
+	 * @param Relationship     $relationship
+	 * @throws MappingException
+	 */
+	protected function cacheManyRelationResults($parentKey, $relation, $results, Relationship $relationship)
+	{
+		$this->cache[$parentKey][$relation] = [];
+
+		foreach ($results as $result) {
+			$cachedRelationship = $this->getCachedRelationship($parentKey, $relation, $result, $relationship);
+
+			$relatedHash = $cachedRelationship->getHash();
+
+			$this->cache[$parentKey][$relation][$relatedHash] = $cachedRelationship;
+		}
+	}
+
+	/**
+	 * Cache a single relationship
+	 *
+	 * @param              $parentKey
+	 * @param string       $relation
+	 * @param Mappable     $result
+	 * @param Relationship $relationship
+	 * @throws MappingException
+	 */
+	protected function cacheSingleRelationResult($parentKey, $relation, $result, Relationship $relationship)
+	{
+		$this->cache[$parentKey][$relation] = $this->getCachedRelationship($parentKey, $relation, $result, $relationship);
+	}
+
+	/**
+	 * Get Entity's Hash
+	 *
+	 * @param  $entity
+	 * @throws MappingException
+	 * @return string
+	 */
+	protected function getEntityHash(InternallyMappable $entity)
+	{
+		$class = get_class($entity->getObject());
+
+		$mapper = Manager::getMapper($class);
+
+		$keyName = $mapper->getEntityMap()->getKeyName();
+
+		return $class . '.' . $entity->getEntityAttribute($keyName);
+	}
+
+	/**
+	 * Refresh the cache record for an aggregated entity after a write operation
+	 * @param Aggregate $entity
+	 */
+	public function refresh(Aggregate $entity)
+	{
+		$this->cache[$entity->getEntityId()] = $this->transform($entity);
+	}
+
+	/**
+	 * Transform an Aggregated Entity into a cache record
+	 *
+	 * @param  Aggregate $aggregatedEntity
+	 * @throws MappingException
+	 * @return array
+	 */
+	protected function transform(Aggregate $aggregatedEntity)
+	{
+		$baseAttributes = $aggregatedEntity->getRawAttributes();
+
+		$relationAttributes = [];
+
+		// First we'll handle each relationships that are a one to one
+		// relation, and which will be saved as a CachedRelationship
+		// object inside the cache.
+
+		// NOTE : storing localRelationships maybe useless has we store
+		// the foreign key in the attributes already.
+
+		foreach ($this->entityMap->getSingleRelationships() as $relation) {
+			$aggregates = $aggregatedEntity->getRelationship($relation);
             
-            if (count($aggregates) == 1) {
-                $related = $aggregates[0];
-                $relationAttributes[$relation] = new CachedRelationship($related->getEntityHash());
-            }
-            if (count($aggregates) > 1) {
-                throw new MappingException("Single Relationship '$relation' contains several related entities");
-            }
-        }
-
-        // Then we'll handle the 'many' relationships and store them as
-        // an array of CachedRelationship objects.
-
-        foreach ($this->entityMap->getManyRelationships() as $relation) {
-            $aggregates = $aggregatedEntity->getRelationship($relation);
-
-            $relationAttributes[$relation] = [];
-
-            foreach ($aggregates as $aggregate) {
-                $relationAttributes[$relation][] = new CachedRelationship(
-                    $aggregate->getEntityHash(),
-                    $aggregate->getPivotAttributes()
-                );
-            }
-        }
-
-        return $baseAttributes + $relationAttributes;
-    }
-
-    /**
-     * @param                     $relation
-     * @param  InternallyMappable $entity
-     * @return array
-     */
-    protected function getPivotValues($relation, InternallyMappable $entity)
-    {
-        $values = [];
-
-        $entityAttributes = $entity->getEntityAttributes();
-
-        if (array_key_exists($relation, $this->pivotAttributes)) {
-            foreach ($this->pivotAttributes[$relation] as $attribute) {
-                if (array_key_exists($attribute, $entityAttributes)) {
-                    $values[$attribute] = $entity->getEntityAttribute('pivot')->$attribute;
-                }
-            }
-        }
-
-        return $values;
-    }
+			if (count($aggregates) == 1) {
+				$related = $aggregates[0];
+				$relationAttributes[$relation] = new CachedRelationship($related->getEntityHash());
+			}
+			if (count($aggregates) > 1) {
+				throw new MappingException("Single Relationship '$relation' contains several related entities");
+			}
+		}
+
+		// Then we'll handle the 'many' relationships and store them as
+		// an array of CachedRelationship objects.
+
+		foreach ($this->entityMap->getManyRelationships() as $relation) {
+			$aggregates = $aggregatedEntity->getRelationship($relation);
+
+			$relationAttributes[$relation] = [];
+
+			foreach ($aggregates as $aggregate) {
+				$relationAttributes[$relation][] = new CachedRelationship(
+					$aggregate->getEntityHash(),
+					$aggregate->getPivotAttributes()
+				);
+			}
+		}
+
+		return $baseAttributes + $relationAttributes;
+	}
+
+	/**
+	 * @param                     $relation
+	 * @param  InternallyMappable $entity
+	 * @return array
+	 */
+	protected function getPivotValues($relation, InternallyMappable $entity)
+	{
+		$values = [];
+
+		$entityAttributes = $entity->getEntityAttributes();
+
+		if (array_key_exists($relation, $this->pivotAttributes)) {
+			foreach ($this->pivotAttributes[$relation] as $attribute) {
+				if (array_key_exists($attribute, $entityAttributes)) {
+					$values[$attribute] = $entity->getEntityAttribute('pivot')->$attribute;
+				}
+			}
+		}
+
+		return $values;
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -231,7 +231,7 @@
 
         $keyName = $mapper->getEntityMap()->getKeyName();
 
-        return $class . '.' . $entity->getEntityAttribute($keyName);
+        return $class.'.'.$entity->getEntityAttribute($keyName);
     }
 
     /**

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->entity, $method], $parameters);
-    }
+		return call_user_func_array([$this->entity, $method], $parameters);
+	}
 }

src/EntityCollection.php

Indentation +379 added lines, -379 removed lines

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

Spacing +6 added lines, -6 removed lines

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

src/System/Mapper.php

Indentation +556 added lines, -556 removed lines

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

Spacing +2 added lines, -2 removed lines

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