analogueorm / analogue

src/System/Wrappers/ObjectWrapper.php

Doc Comments -1 removed lines

@@ -35,7 +35,6 @@
     /**
      * Object Wrapper constructor.
      *
-     * @param mixed                  $object
      * @param Analogue\ORM\EntityMap $entityMap
      *
      * @return void

Indentation +221 added lines, -221 removed lines

@@ -10,225 +10,225 @@
  */
 class ObjectWrapper extends Wrapper
 {
-    /**
-     * Internal Representation of analogue's entity attributes.
-     *
-     * @var array
-     */
-    protected $attributes = [];
-
-    /**
-     * Object properties that are not a part of the entity attributes,
-     * but which are needed to correctly hydrate the Object.
-     *
-     * @var array
-     */
-    protected $unmanagedProperties = [];
-
-    /**
-     * The hydrator for the wrapped object.
-     *
-     * @var HydratorInterface
-     */
-    protected $hydrator;
-
-    /**
-     * Object Wrapper constructor.
-     *
-     * @param mixed                  $object
-     * @param Analogue\ORM\EntityMap $entityMap
-     *
-     * @return void
-     */
-    public function __construct($entity, $entityMap, HydratorInterface $hydrator)
-    {
-        $this->hydrator = $hydrator;
-        parent::__construct($entity, $entityMap);
-        $this->attributes = $this->dehydrate($entity);
-    }
-
-    /**
-     * Returns the wrapped entity.
-     *
-     * @return mixed
-     */
-    public function getObject()
-    {
-        $this->hydrate();
-
-        return $this->entity;
-    }
-
-    /**
-     * Extract entity attributes / properties to an array of attributes.
-     *
-     * @param mixed $entity
-     *
-     * @return array
-     */
-    protected function dehydrate($entity) : array
-    {
-        $properties = $this->hydrator->extract($entity);
-
-        $this->unmanagedProperties = array_except($properties, $this->getManagedProperties());
-
-        return $this->attributesFromProperties($properties);
-    }
-
-    /**
-     * Hydrate object's properties/attribute from the internal array representation.
-     *
-     * @return mixed
-     */
-    public function hydrate()
-    {
-        $properties = $this->propertiesFromAttributes($this->attributes) + $this->unmanagedProperties;
-        $this->hydrator->hydrate($properties, $this->entity);
-    }
-
-    /**
-     * Return properties that will be extracted from the entity.
-     *
-     * @return array
-     */
-    protected function getManagedProperties() : array
-    {
-        $properties = $this->entityMap->getProperties();
-
-        $attributesName = $this->entityMap->getAttributesArrayName();
-
-        return $attributesName == null ? $properties : array_merge($properties, [$attributesName]);
-    }
-
-    /**
-     * Convert object's properties to analogue's internal attributes representation.
-     *
-     * @param array $properties
-     *
-     * @return array
-     */
-    protected function attributesFromProperties(array $properties) : array
-    {
-        // First, we'll only keep the entities that are part of the Entity's
-        // attributes
-        $managedProperties = $this->getManagedProperties();
-
-        $properties = array_only($properties, $managedProperties);
-
-        // If the entity does not uses the attributes array to store
-        // part of its attributes, we'll directly return the properties
-        if (!$this->entityMap->usesAttributesArray()) {
-            return $properties;
-        }
-
-        $arrayName = $this->entityMap->getAttributesArrayName();
-
-        if (!array_key_exists($arrayName, $properties)) {
-            throw new MappingException("Property $arrayName not set on object of type ".$this->getEntityClass());
-        }
-
-        if (!is_array($properties[$arrayName])) {
-            throw new MappingException("Property $arrayName should be an array.");
-        }
-
-        $attributes = $properties[$arrayName];
-
-        unset($properties[$arrayName]);
-
-        return $properties + $attributes;
-    }
-
-    /**
-     * Convert internal representation of attributes to an array of properties
-     * that can hydrate the actual object.
-     *
-     * @param array $attributes
-     *
-     * @return array
-     */
-    protected function propertiesFromAttributes(array $attributes) : array
-    {
-        $attributes = $this->attributes;
-
-        // Get all managed properties
-        $propertyNames = $this->entityMap->getProperties();
-
-        $propertyAttributes = array_only($attributes, $propertyNames);
-        $attributesArray = array_except($attributes, $propertyNames);
-
-        $attributesArrayName = $this->entityMap->getAttributesArrayName();
-
-        if ($attributesArrayName) {
-            $propertyAttributes[$attributesArrayName] = $attributesArray;
-        }
-
-        return $propertyAttributes;
-    }
-
-    /**
-     * Method used by the mapper to set the object
-     * attribute raw values (hydration).
-     *
-     * @param array $attributes
-     *
-     * @return void
-     */
-    public function setEntityAttributes(array $attributes)
-    {
-        $this->attributes = $attributes;
-    }
-
-    /**
-     * Method used by the mapper to get the
-     * raw object's values.
-     *
-     * @return array
-     */
-    public function getEntityAttributes() : array
-    {
-        return $this->attributes;
-    }
-
-    /**
-     * Method used by the mapper to set raw
-     * key-value pair.
-     *
-     * @param string $key
-     * @param string $value
-     *
-     * @return void
-     */
-    public function setEntityAttribute($key, $value)
-    {
-        $this->attributes[$key] = $value;
-    }
-
-    /**
-     * 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)) {
-            return $this->attributes[$key];
-        } else {
-            return;
-        }
-    }
-
-    /**
-     * Test if a given attribute exists.
-     *
-     * @param string $key
-     *
-     * @return bool
-     */
-    public function hasAttribute($key) : bool
-    {
-        return array_key_exists($key, $this->attributes) ? true : false;
-    }
+	/**
+	 * Internal Representation of analogue's entity attributes.
+	 *
+	 * @var array
+	 */
+	protected $attributes = [];
+
+	/**
+	 * Object properties that are not a part of the entity attributes,
+	 * but which are needed to correctly hydrate the Object.
+	 *
+	 * @var array
+	 */
+	protected $unmanagedProperties = [];
+
+	/**
+	 * The hydrator for the wrapped object.
+	 *
+	 * @var HydratorInterface
+	 */
+	protected $hydrator;
+
+	/**
+	 * Object Wrapper constructor.
+	 *
+	 * @param mixed                  $object
+	 * @param Analogue\ORM\EntityMap $entityMap
+	 *
+	 * @return void
+	 */
+	public function __construct($entity, $entityMap, HydratorInterface $hydrator)
+	{
+		$this->hydrator = $hydrator;
+		parent::__construct($entity, $entityMap);
+		$this->attributes = $this->dehydrate($entity);
+	}
+
+	/**
+	 * Returns the wrapped entity.
+	 *
+	 * @return mixed
+	 */
+	public function getObject()
+	{
+		$this->hydrate();
+
+		return $this->entity;
+	}
+
+	/**
+	 * Extract entity attributes / properties to an array of attributes.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @return array
+	 */
+	protected function dehydrate($entity) : array
+	{
+		$properties = $this->hydrator->extract($entity);
+
+		$this->unmanagedProperties = array_except($properties, $this->getManagedProperties());
+
+		return $this->attributesFromProperties($properties);
+	}
+
+	/**
+	 * Hydrate object's properties/attribute from the internal array representation.
+	 *
+	 * @return mixed
+	 */
+	public function hydrate()
+	{
+		$properties = $this->propertiesFromAttributes($this->attributes) + $this->unmanagedProperties;
+		$this->hydrator->hydrate($properties, $this->entity);
+	}
+
+	/**
+	 * Return properties that will be extracted from the entity.
+	 *
+	 * @return array
+	 */
+	protected function getManagedProperties() : array
+	{
+		$properties = $this->entityMap->getProperties();
+
+		$attributesName = $this->entityMap->getAttributesArrayName();
+
+		return $attributesName == null ? $properties : array_merge($properties, [$attributesName]);
+	}
+
+	/**
+	 * Convert object's properties to analogue's internal attributes representation.
+	 *
+	 * @param array $properties
+	 *
+	 * @return array
+	 */
+	protected function attributesFromProperties(array $properties) : array
+	{
+		// First, we'll only keep the entities that are part of the Entity's
+		// attributes
+		$managedProperties = $this->getManagedProperties();
+
+		$properties = array_only($properties, $managedProperties);
+
+		// If the entity does not uses the attributes array to store
+		// part of its attributes, we'll directly return the properties
+		if (!$this->entityMap->usesAttributesArray()) {
+			return $properties;
+		}
+
+		$arrayName = $this->entityMap->getAttributesArrayName();
+
+		if (!array_key_exists($arrayName, $properties)) {
+			throw new MappingException("Property $arrayName not set on object of type ".$this->getEntityClass());
+		}
+
+		if (!is_array($properties[$arrayName])) {
+			throw new MappingException("Property $arrayName should be an array.");
+		}
+
+		$attributes = $properties[$arrayName];
+
+		unset($properties[$arrayName]);
+
+		return $properties + $attributes;
+	}
+
+	/**
+	 * Convert internal representation of attributes to an array of properties
+	 * that can hydrate the actual object.
+	 *
+	 * @param array $attributes
+	 *
+	 * @return array
+	 */
+	protected function propertiesFromAttributes(array $attributes) : array
+	{
+		$attributes = $this->attributes;
+
+		// Get all managed properties
+		$propertyNames = $this->entityMap->getProperties();
+
+		$propertyAttributes = array_only($attributes, $propertyNames);
+		$attributesArray = array_except($attributes, $propertyNames);
+
+		$attributesArrayName = $this->entityMap->getAttributesArrayName();
+
+		if ($attributesArrayName) {
+			$propertyAttributes[$attributesArrayName] = $attributesArray;
+		}
+
+		return $propertyAttributes;
+	}
+
+	/**
+	 * Method used by the mapper to set the object
+	 * attribute raw values (hydration).
+	 *
+	 * @param array $attributes
+	 *
+	 * @return void
+	 */
+	public function setEntityAttributes(array $attributes)
+	{
+		$this->attributes = $attributes;
+	}
+
+	/**
+	 * Method used by the mapper to get the
+	 * raw object's values.
+	 *
+	 * @return array
+	 */
+	public function getEntityAttributes() : array
+	{
+		return $this->attributes;
+	}
+
+	/**
+	 * Method used by the mapper to set raw
+	 * key-value pair.
+	 *
+	 * @param string $key
+	 * @param string $value
+	 *
+	 * @return void
+	 */
+	public function setEntityAttribute($key, $value)
+	{
+		$this->attributes[$key] = $value;
+	}
+
+	/**
+	 * 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)) {
+			return $this->attributes[$key];
+		} else {
+			return;
+		}
+	}
+
+	/**
+	 * Test if a given attribute exists.
+	 *
+	 * @param string $key
+	 *
+	 * @return bool
+	 */
+	public function hasAttribute($key) : bool
+	{
+		return array_key_exists($key, $this->attributes) ? true : false;
+	}
 }

src/MagicSetters.php

Indentation +23 added lines, -23 removed lines

@@ -7,28 +7,28 @@
  */
 trait MagicSetters
 {
-    /**
-     * Dynamically set attributes on the entity.
-     *
-     * @param string $key
-     * @param mixed  $value
-     *
-     * @return void
-     */
-    public function __set($key, $value)
-    {
-        $this->attributes[$key] = $value;
-    }
+	/**
+	 * Dynamically set attributes on the entity.
+	 *
+	 * @param string $key
+	 * @param mixed  $value
+	 *
+	 * @return void
+	 */
+	public function __set($key, $value)
+	{
+		$this->attributes[$key] = $value;
+	}
 
-    /**
-     * Unset an attribute on the entity.
-     *
-     * @param string $key
-     *
-     * @return void
-     */
-    public function __unset($key)
-    {
-        unset($this->attributes[$key]);
-    }
+	/**
+	 * Unset an attribute on the entity.
+	 *
+	 * @param string $key
+	 *
+	 * @return void
+	 */
+	public function __unset($key)
+	{
+		unset($this->attributes[$key]);
+	}
 }

src/Commands/Command.php

Indentation +24 added lines, -24 removed lines

@@ -7,32 +7,32 @@
 
 abstract class Command
 {
-    /**
-     * The aggregated entity on which the command is executed.
-     *
-     * @var \Analogue\ORM\System\Aggregate
-     */
-    protected $aggregate;
+	/**
+	 * The aggregated entity on which the command is executed.
+	 *
+	 * @var \Analogue\ORM\System\Aggregate
+	 */
+	protected $aggregate;
 
-    /**
-     * Query Builder instance.
-     *
-     * @var \Illuminate\Database\Query\Builder
-     */
-    protected $query;
+	/**
+	 * Query Builder instance.
+	 *
+	 * @var \Illuminate\Database\Query\Builder
+	 */
+	protected $query;
 
-    /**
-     * Command constructor.
-     *
-     * @param Aggregate                                                 $aggregate
-     * @param QueryAdapter|\Analogue\ORM\Drivers\IlluminateQueryAdapter $query
-     */
-    public function __construct(Aggregate $aggregate, Builder $query)
-    {
-        $this->aggregate = $aggregate;
+	/**
+	 * Command constructor.
+	 *
+	 * @param Aggregate                                                 $aggregate
+	 * @param QueryAdapter|\Analogue\ORM\Drivers\IlluminateQueryAdapter $query
+	 */
+	public function __construct(Aggregate $aggregate, Builder $query)
+	{
+		$this->aggregate = $aggregate;
 
-        $this->query = $query->from($aggregate->getEntityMap()->getTable());
-    }
+		$this->query = $query->from($aggregate->getEntityMap()->getTable());
+	}
 
-    abstract public function execute();
+	abstract public function execute();
 }

src/Commands/Delete.php

Indentation +26 added lines, -26 removed lines

@@ -6,39 +6,39 @@
 
 class Delete extends Command
 {
-    /**
-     * Execute the Delete Statement.
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return false|void
-     */
-    public function execute()
-    {
-        $aggregate = $this->aggregate;
+	/**
+	 * Execute the Delete Statement.
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return false|void
+	 */
+	public function execute()
+	{
+		$aggregate = $this->aggregate;
 
-        $entity = $aggregate->getEntityObject();
+		$entity = $aggregate->getEntityObject();
 
-        $mapper = $aggregate->getMapper();
+		$mapper = $aggregate->getMapper();
 
-        if ($mapper->fireEvent('deleting', $entity) === false) {
-            return false;
-        }
+		if ($mapper->fireEvent('deleting', $entity) === false) {
+			return false;
+		}
 
-        $keyName = $aggregate->getEntityMap()->getKeyName();
+		$keyName = $aggregate->getEntityMap()->getKeyName();
 
-        $id = $this->aggregate->getEntityId();
+		$id = $this->aggregate->getEntityId();
 
-        if (is_null($id)) {
-            throw new MappingException('Executed a delete command on an entity with "null" as primary key');
-        }
+		if (is_null($id)) {
+			throw new MappingException('Executed a delete command on an entity with "null" as primary key');
+		}
 
-        $this->query->where($keyName, '=', $id)->delete();
+		$this->query->where($keyName, '=', $id)->delete();
 
-        $mapper->fireEvent('deleted', $entity, false);
+		$mapper->fireEvent('deleted', $entity, false);
 
-        // Once the Entity is successfully deleted, we'll just set the primary key to null.
-        $aggregate->setEntityAttribute($keyName, null);
-    }
+		// Once the Entity is successfully deleted, we'll just set the primary key to null.
+		$aggregate->setEntityAttribute($keyName, null);
+	}
 }

src/Commands/Store.php

Indentation +240 added lines, -240 removed lines

@@ -14,247 +14,247 @@
  */
 class Store extends Command
 {
-    /**
-     * Persist the entity in the database.
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return false|mixed
-     */
-    public function execute()
-    {
-        $entity = $this->aggregate->getEntityObject();
-
-        $mapper = $this->aggregate->getMapper();
-
-        if ($mapper->fireEvent('storing', $entity) === false) {
-            return false;
-        }
-
-        $this->preStoreProcess();
-
-        /*
+	/**
+	 * Persist the entity in the database.
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return false|mixed
+	 */
+	public function execute()
+	{
+		$entity = $this->aggregate->getEntityObject();
+
+		$mapper = $this->aggregate->getMapper();
+
+		if ($mapper->fireEvent('storing', $entity) === false) {
+			return false;
+		}
+
+		$this->preStoreProcess();
+
+		/*
          * We will test the entity for existence
          * and run a creation if it doesn't exists
          */
-        if (!$this->aggregate->exists()) {
-            if ($mapper->fireEvent('creating', $entity) === false) {
-                return false;
-            }
-
-            $this->insert();
-
-            $mapper->fireEvent('created', $entity, false);
-        } elseif ($this->aggregate->isDirty()) {
-            if ($mapper->fireEvent('updating', $entity) === false) {
-                return false;
-            }
-            $this->update();
-
-            $mapper->fireEvent('updated', $entity, false);
-        }
-
-        $this->postStoreProcess();
-
-        $mapper->fireEvent('stored', $entity, false);
-
-        // Then we need to hydrate the actual entity
-        $this->aggregate->hydrate();
-
-        return $entity;
-    }
-
-    /**
-     * Run all operations that have to occur before actually
-     * storing the entity.
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    protected function preStoreProcess()
-    {
-        // Create any related object that doesn't exist in the database.
-        $localRelationships = $this->aggregate->getEntityMap()->getLocalRelationships();
-
-        $this->createRelatedEntities($localRelationships);
-
-        // Now we can sync the related collections
-        $this->aggregate->syncRelationships($localRelationships);
-    }
-
-    /**
-     * Check for existence and create non-existing related entities.
-     *
-     * @param  array
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    protected function createRelatedEntities($relations)
-    {
-        $entitiesToCreate = $this->aggregate->getNonExistingRelated($relations);
-
-        foreach ($entitiesToCreate as $aggregate) {
-            $this->createStoreCommand($aggregate)->execute();
-        }
-    }
-
-    /**
-     * Create a new store command.
-     *
-     * @param Aggregate $aggregate
-     *
-     * @return Store
-     */
-    protected function createStoreCommand(Aggregate $aggregate)
-    {
-        // We gotta retrieve the corresponding query adapter to use.
-        $mapper = $aggregate->getMapper();
-
-        return new self($aggregate, $mapper->newQueryBuilder());
-    }
-
-    /**
-     * Run all operations that have to occur after the entity
-     * is stored.
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    protected function postStoreProcess()
-    {
-        $aggregate = $this->aggregate;
-
-        // Create any related object that doesn't exist in the database.
-        $foreignRelationships = $aggregate->getEntityMap()->getForeignRelationships();
-
-        $this->createRelatedEntities($foreignRelationships);
-
-        // Update any pivot tables that has been modified.
-        $aggregate->updatePivotRecords();
-
-        // Update any dirty relationship. This include relationships that already exists, have
-        // dirty attributes / newly created related entities / dirty related entities.
-        $dirtyRelatedAggregates = $aggregate->getDirtyRelationships();
-
-        foreach ($dirtyRelatedAggregates as $related) {
-            $this->createStoreCommand($related)->execute();
-        }
-
-        // Now we can sync the related collections
-        //
-        // TODO (note) : not sute this check is needed, as we can assume
-        // the aggregate exists in the Post Store Process
-        if ($this->aggregate->exists()) {
-            $this->aggregate->syncRelationships($foreignRelationships);
-        }
-
-        // TODO be move it to the wrapper class
-        // so it's the same code for the entity builder
-        $aggregate->setProxies();
-
-        // Update Entity Cache
-        $aggregate->getMapper()->getEntityCache()->refresh($aggregate);
-    }
-
-    /**
-     * Update Related Entities which attributes have
-     * been modified.
-     *
-     * @return void
-     */
-    protected function updateDirtyRelated()
-    {
-        $relations = $this->entityMap->getRelationships();
-        $attributes = $this->getAttributes();
-
-        foreach ($relations as $relation) {
-            if (!array_key_exists($relation, $attributes)) {
-                continue;
-            }
-
-            $value = $attributes[$relation];
-
-            if ($value == null) {
-                continue;
-            }
-
-            if ($value instanceof EntityProxy) {
-                continue;
-            }
-
-            if ($value instanceof CollectionProxy && $value->isLoaded()) {
-                $value = $value->getUnderlyingCollection();
-            }
-            if ($value instanceof CollectionProxy && !$value->isLoaded()) {
-                foreach ($value->getAddedItems() as $entity) {
-                    $this->updateEntityIfDirty($entity);
-                }
-                continue;
-            }
-
-            if ($value instanceof EntityCollection) {
-                foreach ($value as $entity) {
-                    if (!$this->createEntityIfNotExists($entity)) {
-                        $this->updateEntityIfDirty($entity);
-                    }
-                }
-                continue;
-            }
-            if ($value instanceof Mappable) {
-                $this->updateEntityIfDirty($value);
-                continue;
-            }
-        }
-    }
-
-    /**
-     * Execute an insert statement on the database.
-     *
-     * @return void
-     */
-    protected function insert()
-    {
-        $aggregate = $this->aggregate;
-
-        $attributes = $aggregate->getRawAttributes();
-
-        $keyName = $aggregate->getEntityMap()->getKeyName();
-
-        // Check if the primary key is defined in the attributes
-        if (array_key_exists($keyName, $attributes) && $attributes[$keyName] != null) {
-            $this->query->insert($attributes);
-        } else {
-            $sequence = $aggregate->getEntityMap()->getSequence();
-
-            $id = $this->query->insertGetId($attributes, $sequence);
-
-            $aggregate->setEntityAttribute($keyName, $id);
-        }
-    }
-
-    /**
-     * Run an update statement on the entity.
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    protected function update()
-    {
-        $query = $this->query;
-
-        $keyName = $this->aggregate->getEntityKey();
-
-        $query = $query->where($keyName, '=', $this->aggregate->getEntityId());
-
-        $dirtyAttributes = $this->aggregate->getDirtyRawAttributes();
-
-        if (count($dirtyAttributes) > 0) {
-            $query->update($dirtyAttributes);
-        }
-    }
+		if (!$this->aggregate->exists()) {
+			if ($mapper->fireEvent('creating', $entity) === false) {
+				return false;
+			}
+
+			$this->insert();
+
+			$mapper->fireEvent('created', $entity, false);
+		} elseif ($this->aggregate->isDirty()) {
+			if ($mapper->fireEvent('updating', $entity) === false) {
+				return false;
+			}
+			$this->update();
+
+			$mapper->fireEvent('updated', $entity, false);
+		}
+
+		$this->postStoreProcess();
+
+		$mapper->fireEvent('stored', $entity, false);
+
+		// Then we need to hydrate the actual entity
+		$this->aggregate->hydrate();
+
+		return $entity;
+	}
+
+	/**
+	 * Run all operations that have to occur before actually
+	 * storing the entity.
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return void
+	 */
+	protected function preStoreProcess()
+	{
+		// Create any related object that doesn't exist in the database.
+		$localRelationships = $this->aggregate->getEntityMap()->getLocalRelationships();
+
+		$this->createRelatedEntities($localRelationships);
+
+		// Now we can sync the related collections
+		$this->aggregate->syncRelationships($localRelationships);
+	}
+
+	/**
+	 * Check for existence and create non-existing related entities.
+	 *
+	 * @param  array
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return void
+	 */
+	protected function createRelatedEntities($relations)
+	{
+		$entitiesToCreate = $this->aggregate->getNonExistingRelated($relations);
+
+		foreach ($entitiesToCreate as $aggregate) {
+			$this->createStoreCommand($aggregate)->execute();
+		}
+	}
+
+	/**
+	 * Create a new store command.
+	 *
+	 * @param Aggregate $aggregate
+	 *
+	 * @return Store
+	 */
+	protected function createStoreCommand(Aggregate $aggregate)
+	{
+		// We gotta retrieve the corresponding query adapter to use.
+		$mapper = $aggregate->getMapper();
+
+		return new self($aggregate, $mapper->newQueryBuilder());
+	}
+
+	/**
+	 * Run all operations that have to occur after the entity
+	 * is stored.
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return void
+	 */
+	protected function postStoreProcess()
+	{
+		$aggregate = $this->aggregate;
+
+		// Create any related object that doesn't exist in the database.
+		$foreignRelationships = $aggregate->getEntityMap()->getForeignRelationships();
+
+		$this->createRelatedEntities($foreignRelationships);
+
+		// Update any pivot tables that has been modified.
+		$aggregate->updatePivotRecords();
+
+		// Update any dirty relationship. This include relationships that already exists, have
+		// dirty attributes / newly created related entities / dirty related entities.
+		$dirtyRelatedAggregates = $aggregate->getDirtyRelationships();
+
+		foreach ($dirtyRelatedAggregates as $related) {
+			$this->createStoreCommand($related)->execute();
+		}
+
+		// Now we can sync the related collections
+		//
+		// TODO (note) : not sute this check is needed, as we can assume
+		// the aggregate exists in the Post Store Process
+		if ($this->aggregate->exists()) {
+			$this->aggregate->syncRelationships($foreignRelationships);
+		}
+
+		// TODO be move it to the wrapper class
+		// so it's the same code for the entity builder
+		$aggregate->setProxies();
+
+		// Update Entity Cache
+		$aggregate->getMapper()->getEntityCache()->refresh($aggregate);
+	}
+
+	/**
+	 * Update Related Entities which attributes have
+	 * been modified.
+	 *
+	 * @return void
+	 */
+	protected function updateDirtyRelated()
+	{
+		$relations = $this->entityMap->getRelationships();
+		$attributes = $this->getAttributes();
+
+		foreach ($relations as $relation) {
+			if (!array_key_exists($relation, $attributes)) {
+				continue;
+			}
+
+			$value = $attributes[$relation];
+
+			if ($value == null) {
+				continue;
+			}
+
+			if ($value instanceof EntityProxy) {
+				continue;
+			}
+
+			if ($value instanceof CollectionProxy && $value->isLoaded()) {
+				$value = $value->getUnderlyingCollection();
+			}
+			if ($value instanceof CollectionProxy && !$value->isLoaded()) {
+				foreach ($value->getAddedItems() as $entity) {
+					$this->updateEntityIfDirty($entity);
+				}
+				continue;
+			}
+
+			if ($value instanceof EntityCollection) {
+				foreach ($value as $entity) {
+					if (!$this->createEntityIfNotExists($entity)) {
+						$this->updateEntityIfDirty($entity);
+					}
+				}
+				continue;
+			}
+			if ($value instanceof Mappable) {
+				$this->updateEntityIfDirty($value);
+				continue;
+			}
+		}
+	}
+
+	/**
+	 * Execute an insert statement on the database.
+	 *
+	 * @return void
+	 */
+	protected function insert()
+	{
+		$aggregate = $this->aggregate;
+
+		$attributes = $aggregate->getRawAttributes();
+
+		$keyName = $aggregate->getEntityMap()->getKeyName();
+
+		// Check if the primary key is defined in the attributes
+		if (array_key_exists($keyName, $attributes) && $attributes[$keyName] != null) {
+			$this->query->insert($attributes);
+		} else {
+			$sequence = $aggregate->getEntityMap()->getSequence();
+
+			$id = $this->query->insertGetId($attributes, $sequence);
+
+			$aggregate->setEntityAttribute($keyName, $id);
+		}
+	}
+
+	/**
+	 * Run an update statement on the entity.
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return void
+	 */
+	protected function update()
+	{
+		$query = $this->query;
+
+		$keyName = $this->aggregate->getEntityKey();
+
+		$query = $query->where($keyName, '=', $this->aggregate->getEntityId());
+
+		$dirtyAttributes = $this->aggregate->getDirtyRawAttributes();
+
+		if (count($dirtyAttributes) > 0) {
+			$query->update($dirtyAttributes);
+		}
+	}
 }

src/MagicGetters.php

Indentation +46 added lines, -46 removed lines

@@ -4,54 +4,54 @@
 
 trait MagicGetters
 {
-    /**
-     * Contains the entity's attributes.
-     *
-     * @var array
-     */
-    protected $attributes = [];
+	/**
+	 * Contains the entity's attributes.
+	 *
+	 * @var array
+	 */
+	protected $attributes = [];
 
-    /**
-     * Dynamically retrieve attributes on the entity.
-     *
-     * @param string $key
-     *
-     * @return mixed
-     */
-    public function __get($key)
-    {
-        // When using mixed mapping, we will check
-        // for a class property corresponding to
-        // the attribute's key first.
-        //
-        // Note : this may raise issues as we may grant
-        // access to unwanted properties, like class dependencies.
-        //
-        // -> Solution would be to access the entityMap's $attributes, but we
-        // have to do this in a very efficient way.
-        //
-        // Manager::getEntityMap(get_class($this))->hasProperty()
-        //
-        // We could do the casting to array / json the same way, and it would
+	/**
+	 * Dynamically retrieve attributes on the entity.
+	 *
+	 * @param string $key
+	 *
+	 * @return mixed
+	 */
+	public function __get($key)
+	{
+		// When using mixed mapping, we will check
+		// for a class property corresponding to
+		// the attribute's key first.
+		//
+		// Note : this may raise issues as we may grant
+		// access to unwanted properties, like class dependencies.
+		//
+		// -> Solution would be to access the entityMap's $attributes, but we
+		// have to do this in a very efficient way.
+		//
+		// Manager::getEntityMap(get_class($this))->hasProperty()
+		//
+		// We could do the casting to array / json the same way, and it would
 
-        if (property_exists($this, $key)) {
-            return $this->$key;
-        }
+		if (property_exists($this, $key)) {
+			return $this->$key;
+		}
 
-        if (array_key_exists($key, $this->attributes)) {
-            return $this->attributes[$key];
-        }
-    }
+		if (array_key_exists($key, $this->attributes)) {
+			return $this->attributes[$key];
+		}
+	}
 
-    /**
-     * Determine if an attribute exists on the entity.
-     *
-     * @param string $key
-     *
-     * @return bool
-     */
-    public function __isset($key)
-    {
-        return array_key_exists($key, $this->attributes) || property_exists($this, $key);
-    }
+	/**
+	 * Determine if an attribute exists on the entity.
+	 *
+	 * @param string $key
+	 *
+	 * @return bool
+	 */
+	public function __isset($key)
+	{
+		return array_key_exists($key, $this->attributes) || property_exists($this, $key);
+	}
 }

src/AnalogueServiceProvider.php

Indentation +42 added lines, -42 removed lines

@@ -13,58 +13,58 @@
  */
 class AnalogueServiceProvider extends ServiceProvider
 {
-    /**
-     * Indicates if loading of the provider is deferred.
-     *
-     * @var bool
-     */
-    protected $defer = false;
+	/**
+	 * Indicates if loading of the provider is deferred.
+	 *
+	 * @var bool
+	 */
+	protected $defer = false;
 
-    public function boot()
-    {
-        //
-    }
+	public function boot()
+	{
+		//
+	}
 
-    /**
-     * Register the service provider.
-     *
-     * @return void
-     */
-    public function register()
-    {
-        $this->app->singleton('analogue', function ($app) {
-            $db = $app['db'];
+	/**
+	 * Register the service provider.
+	 *
+	 * @return void
+	 */
+	public function register()
+	{
+		$this->app->singleton('analogue', function ($app) {
+			$db = $app['db'];
 
-            $connectionProvider = new IlluminateConnectionProvider($db);
+			$connectionProvider = new IlluminateConnectionProvider($db);
 
-            $illuminate = new IlluminateDriver($connectionProvider);
+			$illuminate = new IlluminateDriver($connectionProvider);
 
-            $driverManager = new DriverManager();
+			$driverManager = new DriverManager();
 
-            $driverManager->addDriver($illuminate);
+			$driverManager->addDriver($illuminate);
 
-            $event = $app->make('events');
+			$event = $app->make('events');
 
-            $manager = new Manager($driverManager, $event);
+			$manager = new Manager($driverManager, $event);
 
-            $manager->registerPlugin(\Analogue\ORM\Plugins\Timestamps\TimestampsPlugin::class);
-            $manager->registerPlugin(\Analogue\ORM\Plugins\SoftDeletes\SoftDeletesPlugin::class);
+			$manager->registerPlugin(\Analogue\ORM\Plugins\Timestamps\TimestampsPlugin::class);
+			$manager->registerPlugin(\Analogue\ORM\Plugins\SoftDeletes\SoftDeletesPlugin::class);
 
-            return $manager;
-        });
+			return $manager;
+		});
 
-        $this->app->bind(Manager::class, function ($app) {
-            return $app->make('analogue');
-        });
-    }
+		$this->app->bind(Manager::class, function ($app) {
+			return $app->make('analogue');
+		});
+	}
 
-    /**
-     * Get the services provided by the provider.
-     *
-     * @return array
-     */
-    public function provides()
-    {
-        return ['analogue'];
-    }
+	/**
+	 * Get the services provided by the provider.
+	 *
+	 * @return array
+	 */
+	public function provides()
+	{
+		return ['analogue'];
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -32,7 +32,7 @@ 
      */
     public function register()
     {
-        $this->app->singleton('analogue', function ($app) {
+        $this->app->singleton('analogue', function($app) {
             $db = $app['db'];
 
             $connectionProvider = new IlluminateConnectionProvider($db);
@@ -53,7 +53,7 @@ 
             return $manager;
         });
 
-        $this->app->bind(Manager::class, function ($app) {
+        $this->app->bind(Manager::class, function($app) {
             return $app->make('analogue');
         });
     }

src/Plugins/AnaloguePluginInterface.php

Indentation +12 added lines, -12 removed lines

@@ -4,17 +4,17 @@
 
 interface AnaloguePluginInterface
 {
-    /**
-     * Boot the plugin.
-     *
-     * @return void
-     */
-    public function register();
+	/**
+	 * Boot the plugin.
+	 *
+	 * @return void
+	 */
+	public function register();
 
-    /**
-     * Get custom events provided by the plugin.
-     *
-     * @return array
-     */
-    public function getCustomEvents();
+	/**
+	 * Get custom events provided by the plugin.
+	 *
+	 * @return array
+	 */
+	public function getCustomEvents();
 }

src/Plugins/AnaloguePlugin.php

Indentation +27 added lines, -27 removed lines

@@ -6,34 +6,34 @@
 
 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();
 }