analogueorm / analogue

src/Plugins/AnaloguePlugin.php

Indentation +26 added lines, -26 removed lines

@@ -6,33 +6,33 @@
 
 abstract class AnaloguePlugin implements AnaloguePluginInterface
 {
-    /**
-     * Manager instance
-     *
-     * @var Manager
-     */
-    protected $manager;
+	/**
+	 * Manager instance
+	 *
+	 * @var Manager
+	 */
+	protected $manager;
 
-    /**
-     * AnaloguePlugin constructor.
-     * @param Manager $manager
-     */
-    public function __construct(Manager $manager)
-    {
-        $this->manager = $manager;
-    }
+	/**
+	 * AnaloguePlugin constructor.
+	 * @param Manager $manager
+	 */
+	public function __construct(Manager $manager)
+	{
+		$this->manager = $manager;
+	}
 
-    /**
-     * Boot the plugin
-     *
-     * @return void
-     */
-    abstract public function register();
+	/**
+	 * Boot the plugin
+	 *
+	 * @return void
+	 */
+	abstract public function register();
 
-    /**
-     * Get custom events provided by the plugin
-     *
-     * @return array
-     */
-    abstract public function getCustomEvents();
+	/**
+	 * Get custom events provided by the plugin
+	 *
+	 * @return array
+	 */
+	abstract public function getCustomEvents();
 }

src/Repository.php

Indentation +116 added lines, -116 removed lines

@@ -15,129 +15,129 @@
  */
 class Repository
 {
-    /**
-     * The mapper object for the corresponding entity
-     *
-     * @var \Analogue\ORM\System\Mapper
-     */
-    protected $mapper;
+	/**
+	 * The mapper object for the corresponding entity
+	 *
+	 * @var \Analogue\ORM\System\Mapper
+	 */
+	protected $mapper;
 
-    /**
-     * To build a repository, either provide :
-     *
-     * - Mappable object's class name as a string
-     * - Mappable object instance
-     * - Instance of mapper
-     *
-     * @param  Mapper         $mapper
-     * @param  EntityMap|null $entityMap (optional)
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     */
-    public function __construct($mapper, EntityMap $entityMap = null)
-    {
-        if ($mapper instanceof Mappable || is_string($mapper)) {
-            $this->mapper = Manager::getMapper($mapper, $entityMap);
-        } elseif ($mapper instanceof Mapper) {
-            $this->mapper = $mapper;
-        } else {
-            new InvalidArgumentException('Repository class constructor need a valid Mapper or Mappable object.');
-        }
-    }
+	/**
+	 * To build a repository, either provide :
+	 *
+	 * - Mappable object's class name as a string
+	 * - Mappable object instance
+	 * - Instance of mapper
+	 *
+	 * @param  Mapper         $mapper
+	 * @param  EntityMap|null $entityMap (optional)
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 */
+	public function __construct($mapper, EntityMap $entityMap = null)
+	{
+		if ($mapper instanceof Mappable || is_string($mapper)) {
+			$this->mapper = Manager::getMapper($mapper, $entityMap);
+		} elseif ($mapper instanceof Mapper) {
+			$this->mapper = $mapper;
+		} else {
+			new InvalidArgumentException('Repository class constructor need a valid Mapper or Mappable object.');
+		}
+	}
 
-    /**
-     * Return all Entities from database
-     *
-     * @return \Analogue\ORM\EntityCollection
-     */
-    public function all()
-    {
-        return $this->mapper->get();
-    }
+	/**
+	 * Return all Entities from database
+	 *
+	 * @return \Analogue\ORM\EntityCollection
+	 */
+	public function all()
+	{
+		return $this->mapper->get();
+	}
     
-    /**
-     * Fetch a record from the database
-     * @param  integer $id
-     * @return \Analogue\ORM\Mappable
-     */
-    public function find($id)
-    {
-        return $this->mapper->find($id);
-    }
+	/**
+	 * Fetch a record from the database
+	 * @param  integer $id
+	 * @return \Analogue\ORM\Mappable
+	 */
+	public function find($id)
+	{
+		return $this->mapper->find($id);
+	}
 
-    /**
-     * Get the first entity matching the given attributes.
-     *
-     * @param  array  $attributes
-     * @return \Analogue\ORM\Mappable|null
-     */
-    public function firstMatching(array $attributes)
-    {
-        return $this->mapper->where($attributes)->first();
-    }
+	/**
+	 * Get the first entity matching the given attributes.
+	 *
+	 * @param  array  $attributes
+	 * @return \Analogue\ORM\Mappable|null
+	 */
+	public function firstMatching(array $attributes)
+	{
+		return $this->mapper->where($attributes)->first();
+	}
 
-    /**
-     * Return all the entities matching the given attributes
-     *
-     * @param array $attributes
-     * @return \Analogue\ORM\EntityCollection
-     */
-    public function allMatching(array $attributes)
-    {
-        return $this->mapper->where($attributes)->get();
-    }
+	/**
+	 * Return all the entities matching the given attributes
+	 *
+	 * @param array $attributes
+	 * @return \Analogue\ORM\EntityCollection
+	 */
+	public function allMatching(array $attributes)
+	{
+		return $this->mapper->where($attributes)->get();
+	}
 
-    /**
-     * Return a paginator instance on the EntityCollection
-     *
-     * @param int|null $perPage number of item per page (fallback on default setup in entity map)
-     * @return \Illuminate\Pagination\LengthAwarePaginator
-     */
-    public function paginate($perPage = null)
-    {
-        return $this->mapper->paginate($perPage);
-    }
+	/**
+	 * Return a paginator instance on the EntityCollection
+	 *
+	 * @param int|null $perPage number of item per page (fallback on default setup in entity map)
+	 * @return \Illuminate\Pagination\LengthAwarePaginator
+	 */
+	public function paginate($perPage = null)
+	{
+		return $this->mapper->paginate($perPage);
+	}
 
-    /**
-     * Delete an entity or an entity collection from the database
-     *
-     * @param  Mappable|EntityCollection $entity
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     * @return \Illuminate\Support\Collection|null
-     */
-    public function delete($entity)
-    {
-        return $this->mapper->delete($entity);
-    }
+	/**
+	 * Delete an entity or an entity collection from the database
+	 *
+	 * @param  Mappable|EntityCollection $entity
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 * @return \Illuminate\Support\Collection|null
+	 */
+	public function delete($entity)
+	{
+		return $this->mapper->delete($entity);
+	}
 
-    /**
-     * Persist an entity or an entity collection in the database.
-     *
-     * @param  Mappable|EntityCollection|array $entity
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     * @return Mappable|EntityCollection|array
-     */
-    public function store($entity)
-    {
-        return $this->mapper->store($entity);
-    }
+	/**
+	 * Persist an entity or an entity collection in the database.
+	 *
+	 * @param  Mappable|EntityCollection|array $entity
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 * @return Mappable|EntityCollection|array
+	 */
+	public function store($entity)
+	{
+		return $this->mapper->store($entity);
+	}
 
-    /**
-     * Make custom mapper custom commands available in repository
-     *
-     * @param  string $method
-     * @param  array  $parameters
-     * @throws Exception
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        if ($this->mapper->hasCustomCommand($method)) {
-            call_user_func_array([$this->mapper, $method], $parameters);
-        } else {
-            throw new Exception("No method $method on " . get_class($this));
-        }
-    }
+	/**
+	 * Make custom mapper custom commands available in repository
+	 *
+	 * @param  string $method
+	 * @param  array  $parameters
+	 * @throws Exception
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		if ($this->mapper->hasCustomCommand($method)) {
+			call_user_func_array([$this->mapper, $method], $parameters);
+		} else {
+			throw new Exception("No method $method on " . get_class($this));
+		}
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -137,7 +137,7 @@
         if ($this->mapper->hasCustomCommand($method)) {
             call_user_func_array([$this->mapper, $method], $parameters);
         } else {
-            throw new Exception("No method $method on " . get_class($this));
+            throw new Exception("No method $method on ".get_class($this));
         }
     }
 }

src/Exceptions/EntityNotFoundException.php

Indentation +27 added lines, -27 removed lines

@@ -6,35 +6,35 @@
 
 class EntityNotFoundException extends RuntimeException
 {
-    /**
-     * Name of the affected Entity Map.
-     *
-     * @var string
-     */
-    protected $entity;
+	/**
+	 * Name of the affected Entity Map.
+	 *
+	 * @var string
+	 */
+	protected $entity;
 
-    /**
-     * Set the affected Entity Map.
-     *
-     * @param  string   $entity
-     * @return $this
-     */
-    public function setEntity($entity)
-    {
-        $this->entity = $entity;
+	/**
+	 * Set the affected Entity Map.
+	 *
+	 * @param  string   $entity
+	 * @return $this
+	 */
+	public function setEntity($entity)
+	{
+		$this->entity = $entity;
 
-        $this->message = "No query results for entity [{$entity}].";
+		$this->message = "No query results for entity [{$entity}].";
 
-        return $this;
-    }
+		return $this;
+	}
 
-    /**
-     * Get the affected Entity.
-     *
-     * @return string
-     */
-    public function getEntity()
-    {
-        return $this->entity;
-    }
+	/**
+	 * Get the affected Entity.
+	 *
+	 * @return string
+	 */
+	public function getEntity()
+	{
+		return $this->entity;
+	}
 }

src/System/ScopeInterface.php

Indentation +14 added lines, -14 removed lines

@@ -4,19 +4,19 @@
 
 interface ScopeInterface
 {
-    /**
-     * Apply the scope to a given Query builder.
-     *
-     * @param  \Analogue\ORM\System\Query $builder
-     * @return void
-     */
-    public function apply(Query $builder);
+	/**
+	 * Apply the scope to a given Query builder.
+	 *
+	 * @param  \Analogue\ORM\System\Query $builder
+	 * @return void
+	 */
+	public function apply(Query $builder);
 
-    /**
-     * Remove the scope from the Query builder.
-     *
-     * @param  \Analogue\ORM\System\Query $builder
-     * @return void
-     */
-    public function remove(Query $builder);
+	/**
+	 * Remove the scope from the Query builder.
+	 *
+	 * @param  \Analogue\ORM\System\Query $builder
+	 * @return void
+	 */
+	public function remove(Query $builder);
 }

src/System/CachedRelationship.php

Indentation +58 added lines, -58 removed lines

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

src/System/Wrappers/EntityWrapper.php

Indentation +68 added lines, -68 removed lines

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

src/System/Wrappers/Factory.php

Indentation +21 added lines, -21 removed lines

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

src/System/EntityBuilder.php

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;

Indentation +185 added lines, -185 removed lines

@@ -11,190 +11,190 @@
  */
 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;
-
-    /**
-     * @var array
-     */
-    protected $casts;
-
-    /**
-     * 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->getRelationshipsToProxy();
-
-        $this->factory = new Factory;
-    }
-
-    /**
-     * Convert an array of values into an entity.
-     *
-     * @param  array $result
-     * @return array
-     */
-    public function build(array $result)
-    {
-        $keyName = $this->entityMap->getKeyName();
-
-        $tmpCache = [];
-
-        $instance = $this->getWrapperInstance();
+	/**
+	 * 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;
+
+	/**
+	 * @var array
+	 */
+	protected $casts;
+
+	/**
+	 * 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->getRelationshipsToProxy();
+
+		$this->factory = new Factory;
+	}
+
+	/**
+	 * Convert an array of values into an entity.
+	 *
+	 * @param  array $result
+	 * @return array
+	 */
+	public function build(array $result)
+	{
+		$keyName = $this->entityMap->getKeyName();
+
+		$tmpCache = [];
+
+		$instance = $this->getWrapperInstance();
         
-        $tmpCache[$result[$keyName]] = $result;
-
-        // Hydrate any embedded Value Object
-        $this->hydrateValueObjects($result);
-
-        $instance->setEntityAttributes($result);
-
-        // Hydrate relationship attributes with lazyloading proxies
-        if (count($this->lazyLoads) > 0) {
-            $instance->setProxies($this->lazyLoads);
-        }
-
-        // Directly Unwrap the entity now that it has been hydrated
-        $entity = $instance->getObject();
-
-        $this->mapper->getEntityCache()->add($tmpCache);
-
-        return $entity;
-    }
-
-    /**
-     * 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]);
-
-            unset($attributes[$prefix . $key]);
-        }
-
-        $attributes[$localKey] = $valueObject;
-    }
-
-    /**
-     * Deduce the relationships for which we will build lazy loading proxies
-     *
-     * @return array
-     */
-    protected function getRelationshipsToProxy()
-    {
-        $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();
-
-        $proxyFactory = new ProxyFactory;
-
-        foreach ($this->lazyLoads as $relation) {
-            if (in_array($relation, $singleRelations)) {
-                //$proxies[$relation] = new EntityProxy($entity->getObject(), $relation);
-                $targetClass = $this->entityMap->getTargetClass($relation);
-                $proxies[$relation] = $proxyFactory->make($entity->getObject(), $relation, $targetClass);
-            }
-            if (in_array($relation, $manyRelations)) {
-                $proxies[$relation] = new CollectionProxy($entity->getObject(), $relation);
-            }
-        }
-
-        return $proxies;
-    }
+		$tmpCache[$result[$keyName]] = $result;
+
+		// Hydrate any embedded Value Object
+		$this->hydrateValueObjects($result);
+
+		$instance->setEntityAttributes($result);
+
+		// Hydrate relationship attributes with lazyloading proxies
+		if (count($this->lazyLoads) > 0) {
+			$instance->setProxies($this->lazyLoads);
+		}
+
+		// Directly Unwrap the entity now that it has been hydrated
+		$entity = $instance->getObject();
+
+		$this->mapper->getEntityCache()->add($tmpCache);
+
+		return $entity;
+	}
+
+	/**
+	 * 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]);
+
+			unset($attributes[$prefix . $key]);
+		}
+
+		$attributes[$localKey] = $valueObject;
+	}
+
+	/**
+	 * Deduce the relationships for which we will build lazy loading proxies
+	 *
+	 * @return array
+	 */
+	protected function getRelationshipsToProxy()
+	{
+		$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();
+
+		$proxyFactory = new ProxyFactory;
+
+		foreach ($this->lazyLoads as $relation) {
+			if (in_array($relation, $singleRelations)) {
+				//$proxies[$relation] = new EntityProxy($entity->getObject(), $relation);
+				$targetClass = $this->entityMap->getTargetClass($relation);
+				$proxies[$relation] = $proxyFactory->make($entity->getObject(), $relation, $targetClass);
+			}
+			if (in_array($relation, $manyRelations)) {
+				$proxies[$relation] = new CollectionProxy($entity->getObject(), $relation);
+			}
+		}
+
+		return $proxies;
+	}
 }
\ No newline at end of file

src/System/EntityCache.php

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);
     }
 
     /**

Indentation +313 added lines, -313 removed lines

@@ -15,319 +15,319 @@
  */
 class EntityCache
 {
-    /**
-     * Entity's raw attributes/relationships
-     *
-     * @var array
-     */
-    protected $cache = [];
-
-    /**
-     * Entity Map for the current Entity Type
-     * @var \Analogue\ORM\EntityMap
-     */
-    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 \Analogue\ORM\EntityMap
+	 */
+	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  string       $parentKey
-     * @param  string       $relation
-     * @param  array        $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  string       $parentKey
+	 * @param  string       $relation
+	 * @param  array        $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;
-    }
-
-    /**
-     * Get pivot attributes for a relation
-     * 
-     * @param  string             $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;
-    }
-
-    /**
-     * Clear the entity Cache. Use with caution as it could result
-     * in impredictable behaviour if the cached entities are stored
-     * after the cache clear operation. 
-     * 
-     * @return void
-     */
-    public function clear()
-    {   
-        $this->cache = [];
-        $this->pivotAttributes = [];
-    }
+			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;
+	}
+
+	/**
+	 * Get pivot attributes for a relation
+	 * 
+	 * @param  string             $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;
+	}
+
+	/**
+	 * Clear the entity Cache. Use with caution as it could result
+	 * in impredictable behaviour if the cached entities are stored
+	 * after the cache clear operation. 
+	 * 
+	 * @return void
+	 */
+	public function clear()
+	{   
+		$this->cache = [];
+		$this->pivotAttributes = [];
+	}
 }