analogueorm / analogue

src/Relationships/Relationship.php

Indentation +429 added lines, -429 removed lines

@@ -19,433 +19,433 @@
  */
 abstract class Relationship
 {
-    /**
-     * The mapper instance for the related entity
-     *
-     * @var Mapper
-     */
-    protected $relatedMapper;
-
-    /**
-     * The Analogue Query Builder instance.
-     *
-     * @var Query
-     */
-    protected $query;
-
-    /**
-     * The parent entity proxy instance.
-     *
-     * @var InternallyMappable
-     */
-    protected $parent;
-
-    /**
-     * The parent entity map
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $parentMap;
-
-    /**
-     * The Parent Mapper instance
-     *
-     * @var Mapper
-     */
-    protected $parentMapper;
-
-    /**
-     * The related entity instance.
-     *
-     * @var object
-     */
-    protected $related;
-
-    /**
-     * The related entity Map
-     * @var \Analogue\ORM\EntityMap
-     */
-    protected $relatedMap;
-
-    /**
-     * Indicate if the parent entity hold the key for the relation.
-     *
-     * @var boolean
-     */
-    protected static $ownForeignKey = false;
-
-    /**
-     * Indicate if the relationships use a pivot table.*
-     *
-     * @var boolean
-     */
-    protected static $hasPivot = false;
-
-    /**
-     * Indicates if the relation is adding constraints.
-     *
-     * @var bool
-     */
-    protected static $constraints = true;
-
-    /**
-     * Wrapper factory
-     *
-     * @var \Analogue\ORM\System\Wrappers\Factory
-     */
-    protected $factory;
-
-    /**
-     * Create a new relation instance.
-     *
-     * @param  Mapper   $mapper
-     * @param  Mappable $parent
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     */
-    public function __construct(Mapper $mapper, $parent)
-    {
-        $this->relatedMapper = $mapper;
-
-        $this->query = $mapper->getQuery();
-
-        $this->factory = new Factory;
-
-        $this->parent = $this->factory->make($parent);
-
-        $this->parentMapper = $mapper->getManager()->getMapper($parent);
-
-        $this->parentMap = $this->parentMapper->getEntityMap();
-
-        $this->related = $this->query->getEntityInstance();
-
-        $this->relatedMap = $mapper->getEntityMap();
-
-        $this->addConstraints();
-    }
-
-    /**
-     * @param $related
-     * @return mixed
-     */
-    abstract public function attachTo($related);
-
-    /**
-     * @param $related
-     * @return mixed
-     */
-    abstract public function detachFrom($related);
-
-    /**
-     * Indicate if the parent entity hold the foreign key for relation.
-     *
-     * @return boolean
-     */
-    public function ownForeignKey()
-    {
-        return static::$ownForeignKey;
-    }
-
-    /**
-     * Indicate if the relationship uses a pivot table
-     *
-     * @return boolean
-     */
-    public function hasPivot()
-    {
-        return static::$hasPivot;
-    }
-
-    /**
-     * Set the base constraints on the relation query.
-     *
-     * @return void
-     */
-    abstract public function addConstraints();
-
-    /**
-     * Set the constraints for an eager load of the relation.
-     *
-     * @param  array $models
-     * @return void
-     */
-    abstract public function addEagerConstraints(array $models);
-
-    /**
-     * Initialize the relation on a set of models.
-     *
-     * @param  array  $models
-     * @param  string $relation
-     * @return array
-     */
-    abstract public function initRelation(array $models, $relation);
-
-    /**
-     * Match the eagerly loaded results to their parents.
-     *
-     * @param  array            $entities
-     * @param  EntityCollection $results
-     * @param  string           $relation
-     * @return array
-     */
-    abstract public function match(array $entities, EntityCollection $results, $relation);
-
-    /**
-     * Get the results of the relationship.
-     *
-     * @param string $relation relation name in parent's entity map
-     * @return mixed
-     */
-    abstract public function getResults($relation);
-
-    /**
-     * Get the relationship for eager loading.
-     *
-     * @return EntityCollection
-     */
-    public function getEager()
-    {
-        return $this->get();
-    }
-
-    /**
-     * Add the constraints for a relationship count query.
-     *
-     * @param  Query $query
-     * @param  Query $parent
-     * @return Query
-     */
-    public function getRelationCountQuery(Query $query, Query $parent)
-    {
-        $query->select(new Expression('count(*)'));
-
-        $key = $this->wrap($this->getQualifiedParentKeyName());
-
-        return $query->where($this->getHasCompareKey(), '=', new Expression($key));
-    }
-
-    /**
-     * Run a callback with constraints disabled on the relation.
-     *
-     * @param  Closure $callback
-     * @return mixed
-     */
-    public static function noConstraints(Closure $callback)
-    {
-        static::$constraints = false;
-
-        // When resetting the relation where clause, we want to shift the first element
-        // off of the bindings, leaving only the constraints that the developers put
-        // as "extra" on the relationships, and not original relation constraints.
-        $results = call_user_func($callback);
-
-        static::$constraints = true;
-
-        return $results;
-    }
-
-    /**
-     * Get all of the primary keys for an array of entities.
-     *
-     * @param  array  $entities
-     * @param  string $key
-     * @return array
-     */
-    protected function getKeys(array $entities, $key = null)
-    {
-        if (is_null($key)) {
-            $key = $this->relatedMap->getKeyName();
-        }
-
-        $host = $this;
-
-        return array_unique(array_values(array_map(function ($value) use ($key, $host) {
-            if (!$value instanceof InternallyMappable) {
-                $value = $host->factory->make($value);
-            }
-
-            return $value->getEntityAttribute($key);
-
-        }, $entities)));
-    }
-
-    /**
-     * Get the underlying query for the relation.
-     *
-     * @return Query
-     */
-    public function getQuery()
-    {
-        return $this->query;
-    }
-
-    /**
-     * Get the base query builder
-     *
-     * @return \Analogue\ORM\Drivers\QueryAdapter
-     */
-    public function getBaseQuery()
-    {
-        return $this->query->getQuery();
-    }
-
-    /**
-     * Get the parent model of the relation.
-     *
-     * @return InternallyMappable
-     */
-    public function getParent()
-    {
-        return $this->parent;
-    }
-
-    /**
-     * Get the fully qualified parent key name.
-     *
-     * @return string
-     */
-    protected function getQualifiedParentKeyName()
-    {
-        return $this->parent->getQualifiedKeyName();
-    }
-
-    /**
-     * Get the related entity of the relation.
-     *
-     * @return \Analogue\ORM\Entity
-     */
-    public function getRelated()
-    {
-        return $this->related;
-    }
-
-    /**
-     * Get the related mapper for the relation
-     *
-     * @return Mapper
-     */
-    public function getRelatedMapper()
-    {
-        return $this->relatedMapper;
-    }
-
-
-    /**
-     * Get the name of the "created at" column.
-     *
-     * @return string
-     */
-    public function createdAt()
-    {
-        return $this->parentMap->getCreatedAtColumn();
-    }
-
-    /**
-     * Get the name of the "updated at" column.
-     *
-     * @return string
-     */
-    public function updatedAt()
-    {
-        return $this->parentMap->getUpdatedAtColumn();
-    }
-
-    /**
-     * Get the name of the related model's "updated at" column.
-     *
-     * @return string
-     */
-    public function relatedUpdatedAt()
-    {
-        return $this->related->getUpdatedAtColumn();
-    }
-
-    /**
-     * Wrap the given value with the parent query's grammar.
-     *
-     * @param  string $value
-     * @return string
-     */
-    public function wrap($value)
-    {
-        return $this->parentMapper->getQuery()->getQuery()->getGrammar()->wrap($value);
-    }
-
-    /**
-     * Get a fresh timestamp
-     *
-     * @return Carbon
-     */
-    protected function freshTimestamp()
-    {
-        return new Carbon;
-    }
-
-    /**
-     * Cache the link between parent and related
-     * into the mapper's Entity Cache.
-     *
-     * @param  EntityCollection|Mappable $results  result of the relation query
-     * @param  string                    $relation name of the relation method on the parent entity
-     * @return void
-     */
-    protected function cacheRelation($results, $relation)
-    {
-        $cache = $this->parentMapper->getEntityCache();
-
-        $cache->cacheLoadedRelationResult($this->parent, $relation, $results, $this);
-    }
-
-    /**
-     * Return Pivot attributes when available on a relationship
-     *
-     * @return array
-     */
-    public function getPivotAttributes()
-    {
-        return [];
-    }
-
-    /**
-     * Get a combo type.primaryKey
-     *
-     * @param  Mappable $entity
-     * @return string
-     */
-    protected function getEntityHash(Mappable $entity)
-    {
-        $class = get_class($entity);
-
-        $keyName = Mapper::getMapper($class)->getEntityMap()->getKeyName();
-
-        return $class . '.' . $entity->getEntityAttribute($keyName);
-    }
-
-    /**
-     * Run synchronization content if needed by the
-     * relation type.
-     *
-     * @param  array $actualContent
-     * @return void
-     */
-    public function sync(array $actualContent)
-    {
-        //
-    }
-
-    /**
-     * Handle dynamic method calls to the relationship.
-     *
-     * @param  string $method
-     * @param  array  $parameters
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        $result = call_user_func_array([$this->query, $method], $parameters);
-
-        if ($result === $this->query) {
-            return $this;
-        }
-
-        return $result;
-    }
+	/**
+	 * The mapper instance for the related entity
+	 *
+	 * @var Mapper
+	 */
+	protected $relatedMapper;
+
+	/**
+	 * The Analogue Query Builder instance.
+	 *
+	 * @var Query
+	 */
+	protected $query;
+
+	/**
+	 * The parent entity proxy instance.
+	 *
+	 * @var InternallyMappable
+	 */
+	protected $parent;
+
+	/**
+	 * The parent entity map
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $parentMap;
+
+	/**
+	 * The Parent Mapper instance
+	 *
+	 * @var Mapper
+	 */
+	protected $parentMapper;
+
+	/**
+	 * The related entity instance.
+	 *
+	 * @var object
+	 */
+	protected $related;
+
+	/**
+	 * The related entity Map
+	 * @var \Analogue\ORM\EntityMap
+	 */
+	protected $relatedMap;
+
+	/**
+	 * Indicate if the parent entity hold the key for the relation.
+	 *
+	 * @var boolean
+	 */
+	protected static $ownForeignKey = false;
+
+	/**
+	 * Indicate if the relationships use a pivot table.*
+	 *
+	 * @var boolean
+	 */
+	protected static $hasPivot = false;
+
+	/**
+	 * Indicates if the relation is adding constraints.
+	 *
+	 * @var bool
+	 */
+	protected static $constraints = true;
+
+	/**
+	 * Wrapper factory
+	 *
+	 * @var \Analogue\ORM\System\Wrappers\Factory
+	 */
+	protected $factory;
+
+	/**
+	 * Create a new relation instance.
+	 *
+	 * @param  Mapper   $mapper
+	 * @param  Mappable $parent
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 */
+	public function __construct(Mapper $mapper, $parent)
+	{
+		$this->relatedMapper = $mapper;
+
+		$this->query = $mapper->getQuery();
+
+		$this->factory = new Factory;
+
+		$this->parent = $this->factory->make($parent);
+
+		$this->parentMapper = $mapper->getManager()->getMapper($parent);
+
+		$this->parentMap = $this->parentMapper->getEntityMap();
+
+		$this->related = $this->query->getEntityInstance();
+
+		$this->relatedMap = $mapper->getEntityMap();
+
+		$this->addConstraints();
+	}
+
+	/**
+	 * @param $related
+	 * @return mixed
+	 */
+	abstract public function attachTo($related);
+
+	/**
+	 * @param $related
+	 * @return mixed
+	 */
+	abstract public function detachFrom($related);
+
+	/**
+	 * Indicate if the parent entity hold the foreign key for relation.
+	 *
+	 * @return boolean
+	 */
+	public function ownForeignKey()
+	{
+		return static::$ownForeignKey;
+	}
+
+	/**
+	 * Indicate if the relationship uses a pivot table
+	 *
+	 * @return boolean
+	 */
+	public function hasPivot()
+	{
+		return static::$hasPivot;
+	}
+
+	/**
+	 * Set the base constraints on the relation query.
+	 *
+	 * @return void
+	 */
+	abstract public function addConstraints();
+
+	/**
+	 * Set the constraints for an eager load of the relation.
+	 *
+	 * @param  array $models
+	 * @return void
+	 */
+	abstract public function addEagerConstraints(array $models);
+
+	/**
+	 * Initialize the relation on a set of models.
+	 *
+	 * @param  array  $models
+	 * @param  string $relation
+	 * @return array
+	 */
+	abstract public function initRelation(array $models, $relation);
+
+	/**
+	 * Match the eagerly loaded results to their parents.
+	 *
+	 * @param  array            $entities
+	 * @param  EntityCollection $results
+	 * @param  string           $relation
+	 * @return array
+	 */
+	abstract public function match(array $entities, EntityCollection $results, $relation);
+
+	/**
+	 * Get the results of the relationship.
+	 *
+	 * @param string $relation relation name in parent's entity map
+	 * @return mixed
+	 */
+	abstract public function getResults($relation);
+
+	/**
+	 * Get the relationship for eager loading.
+	 *
+	 * @return EntityCollection
+	 */
+	public function getEager()
+	{
+		return $this->get();
+	}
+
+	/**
+	 * Add the constraints for a relationship count query.
+	 *
+	 * @param  Query $query
+	 * @param  Query $parent
+	 * @return Query
+	 */
+	public function getRelationCountQuery(Query $query, Query $parent)
+	{
+		$query->select(new Expression('count(*)'));
+
+		$key = $this->wrap($this->getQualifiedParentKeyName());
+
+		return $query->where($this->getHasCompareKey(), '=', new Expression($key));
+	}
+
+	/**
+	 * Run a callback with constraints disabled on the relation.
+	 *
+	 * @param  Closure $callback
+	 * @return mixed
+	 */
+	public static function noConstraints(Closure $callback)
+	{
+		static::$constraints = false;
+
+		// When resetting the relation where clause, we want to shift the first element
+		// off of the bindings, leaving only the constraints that the developers put
+		// as "extra" on the relationships, and not original relation constraints.
+		$results = call_user_func($callback);
+
+		static::$constraints = true;
+
+		return $results;
+	}
+
+	/**
+	 * Get all of the primary keys for an array of entities.
+	 *
+	 * @param  array  $entities
+	 * @param  string $key
+	 * @return array
+	 */
+	protected function getKeys(array $entities, $key = null)
+	{
+		if (is_null($key)) {
+			$key = $this->relatedMap->getKeyName();
+		}
+
+		$host = $this;
+
+		return array_unique(array_values(array_map(function ($value) use ($key, $host) {
+			if (!$value instanceof InternallyMappable) {
+				$value = $host->factory->make($value);
+			}
+
+			return $value->getEntityAttribute($key);
+
+		}, $entities)));
+	}
+
+	/**
+	 * Get the underlying query for the relation.
+	 *
+	 * @return Query
+	 */
+	public function getQuery()
+	{
+		return $this->query;
+	}
+
+	/**
+	 * Get the base query builder
+	 *
+	 * @return \Analogue\ORM\Drivers\QueryAdapter
+	 */
+	public function getBaseQuery()
+	{
+		return $this->query->getQuery();
+	}
+
+	/**
+	 * Get the parent model of the relation.
+	 *
+	 * @return InternallyMappable
+	 */
+	public function getParent()
+	{
+		return $this->parent;
+	}
+
+	/**
+	 * Get the fully qualified parent key name.
+	 *
+	 * @return string
+	 */
+	protected function getQualifiedParentKeyName()
+	{
+		return $this->parent->getQualifiedKeyName();
+	}
+
+	/**
+	 * Get the related entity of the relation.
+	 *
+	 * @return \Analogue\ORM\Entity
+	 */
+	public function getRelated()
+	{
+		return $this->related;
+	}
+
+	/**
+	 * Get the related mapper for the relation
+	 *
+	 * @return Mapper
+	 */
+	public function getRelatedMapper()
+	{
+		return $this->relatedMapper;
+	}
+
+
+	/**
+	 * Get the name of the "created at" column.
+	 *
+	 * @return string
+	 */
+	public function createdAt()
+	{
+		return $this->parentMap->getCreatedAtColumn();
+	}
+
+	/**
+	 * Get the name of the "updated at" column.
+	 *
+	 * @return string
+	 */
+	public function updatedAt()
+	{
+		return $this->parentMap->getUpdatedAtColumn();
+	}
+
+	/**
+	 * Get the name of the related model's "updated at" column.
+	 *
+	 * @return string
+	 */
+	public function relatedUpdatedAt()
+	{
+		return $this->related->getUpdatedAtColumn();
+	}
+
+	/**
+	 * Wrap the given value with the parent query's grammar.
+	 *
+	 * @param  string $value
+	 * @return string
+	 */
+	public function wrap($value)
+	{
+		return $this->parentMapper->getQuery()->getQuery()->getGrammar()->wrap($value);
+	}
+
+	/**
+	 * Get a fresh timestamp
+	 *
+	 * @return Carbon
+	 */
+	protected function freshTimestamp()
+	{
+		return new Carbon;
+	}
+
+	/**
+	 * Cache the link between parent and related
+	 * into the mapper's Entity Cache.
+	 *
+	 * @param  EntityCollection|Mappable $results  result of the relation query
+	 * @param  string                    $relation name of the relation method on the parent entity
+	 * @return void
+	 */
+	protected function cacheRelation($results, $relation)
+	{
+		$cache = $this->parentMapper->getEntityCache();
+
+		$cache->cacheLoadedRelationResult($this->parent, $relation, $results, $this);
+	}
+
+	/**
+	 * Return Pivot attributes when available on a relationship
+	 *
+	 * @return array
+	 */
+	public function getPivotAttributes()
+	{
+		return [];
+	}
+
+	/**
+	 * Get a combo type.primaryKey
+	 *
+	 * @param  Mappable $entity
+	 * @return string
+	 */
+	protected function getEntityHash(Mappable $entity)
+	{
+		$class = get_class($entity);
+
+		$keyName = Mapper::getMapper($class)->getEntityMap()->getKeyName();
+
+		return $class . '.' . $entity->getEntityAttribute($keyName);
+	}
+
+	/**
+	 * Run synchronization content if needed by the
+	 * relation type.
+	 *
+	 * @param  array $actualContent
+	 * @return void
+	 */
+	public function sync(array $actualContent)
+	{
+		//
+	}
+
+	/**
+	 * Handle dynamic method calls to the relationship.
+	 *
+	 * @param  string $method
+	 * @param  array  $parameters
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		$result = call_user_func_array([$this->query, $method], $parameters);
+
+		if ($result === $this->query) {
+			return $this;
+		}
+
+		return $result;
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -257,7 +257,7 @@ 
 
         $host = $this;
 
-        return array_unique(array_values(array_map(function ($value) use ($key, $host) {
+        return array_unique(array_values(array_map(function($value) use ($key, $host) {
             if (!$value instanceof InternallyMappable) {
                 $value = $host->factory->make($value);
             }
@@ -416,7 +416,7 @@ 
 
         $keyName = Mapper::getMapper($class)->getEntityMap()->getKeyName();
 
-        return $class . '.' . $entity->getEntityAttribute($keyName);
+        return $class.'.'.$entity->getEntityAttribute($keyName);
     }
 
     /**

src/Commands/Store.php

Indentation +221 added lines, -221 removed lines

@@ -14,235 +14,235 @@
  */
 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();
-
-        /**
-         * 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);
-        }
+	/**
+	 * 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);
+		}
         
-        /**
-         * We'll only run an update if the entity
-         * is actually dirty
-         */
-        if ($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);
-
-        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);
-    }
-
-    /**
-     * 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 Store($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();
-        }
-
-        if ($this->aggregate->exists()) {
-            $this->aggregate->syncRelationships();
-        }
-        // This should be move 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();
+		/**
+		 * We'll only run an update if the entity
+		 * is actually dirty
+		 */
+		if ($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);
+
+		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);
+	}
+
+	/**
+	 * 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 Store($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();
+		}
+
+		if ($this->aggregate->exists()) {
+			$this->aggregate->syncRelationships();
+		}
+		// This should be move 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();
+		$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();
+		// 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);
+			$id = $this->query->insertGetId($attributes, $sequence);
 
-            $aggregate->setEntityAttribute($keyName, $id);
-        }
-    }
+			$aggregate->setEntityAttribute($keyName, $id);
+		}
+	}
 
-    /**
-     * Run an update statement on the entity
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    protected function update()
-    {
-        $query = $this->query;
+	/**
+	 * Run an update statement on the entity
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return void
+	 */
+	protected function update()
+	{
+		$query = $this->query;
 
-        $keyName = $this->aggregate->getEntityKey();
+		$keyName = $this->aggregate->getEntityKey();
 
-        $query = $query->where($keyName, '=', $this->aggregate->getEntityId());
+		$query = $query->where($keyName, '=', $this->aggregate->getEntityId());
 
-        $dirtyAttributes = $this->aggregate->getDirtyRawAttributes();
+		$dirtyAttributes = $this->aggregate->getDirtyRawAttributes();
 
-        if (count($dirtyAttributes) > 0) {
-            $query->update($dirtyAttributes);
-        }
-    }
+		if (count($dirtyAttributes) > 0) {
+			$query->update($dirtyAttributes);
+		}
+	}
 }

src/Commands/Delete.php

Indentation +29 added lines, -29 removed lines

@@ -6,38 +6,38 @@
 
 class Delete extends Command
 {
-    /**
-     * Execute the Delete Statement
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     * @return false|void
-     */
-    public function execute()
-    {
-        $aggregate = $this->aggregate;
-
-        $entity = $aggregate->getEntityObject();
-
-        $mapper = $aggregate->getMapper();
-
-        if ($mapper->fireEvent('deleting', $entity) === false) {
-            return false;
-        }
-
-        $keyName = $aggregate->getEntityMap()->getKeyName();
+	/**
+	 * Execute the Delete Statement
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 * @return false|void
+	 */
+	public function execute()
+	{
+		$aggregate = $this->aggregate;
+
+		$entity = $aggregate->getEntityObject();
+
+		$mapper = $aggregate->getMapper();
+
+		if ($mapper->fireEvent('deleting', $entity) === false) {
+			return false;
+		}
+
+		$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/Command.php

Indentation +23 added lines, -23 removed lines

@@ -7,31 +7,31 @@
 
 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, QueryAdapter $query)
-    {
-        $this->aggregate = $aggregate;
+	/**
+	 * Command constructor.
+	 * @param Aggregate $aggregate
+	 * @param QueryAdapter|\Analogue\ORM\Drivers\IlluminateQueryAdapter $query
+	 */
+	public function __construct(Aggregate $aggregate, QueryAdapter $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/ValueObject.php

Indentation +152 added lines, -152 removed lines

@@ -11,158 +11,158 @@
 
 class ValueObject implements Mappable, ArrayAccess, Jsonable, JsonSerializable, Arrayable
 {
-    use MappableTrait;
-
-    /**
-     * Dynamically retrieve attributes on the entity.
-     *
-     * @param  string $key
-     * @return mixed
-     */
-    public function __get($key)
-    {
-        return $this->attributes[$key];
-    }
-
-    /**
-     * Dynamically set attributes on the entity.
-     *
-     * @param  string $key
-     * @param  mixed  $value
-     * @return void
-     */
-    public function __set($key, $value)
-    {
-        $this->attributes[$key] = $value;
-    }
-
-    /**
-     * Determine if an attribute exists on the entity.
-     *
-     * @param  string $key
-     * @return bool
-     */
-    public function __isset($key)
-    {
-        return array_key_exists($key, $this->attributes);
-    }
-
-    /**
-     * Unset an attribute on the entity.
-     *
-     * @param  string $key
-     * @return void
-     */
-    public function __unset($key)
-    {
-        unset($this->attributes[$key]);
-    }
+	use MappableTrait;
+
+	/**
+	 * Dynamically retrieve attributes on the entity.
+	 *
+	 * @param  string $key
+	 * @return mixed
+	 */
+	public function __get($key)
+	{
+		return $this->attributes[$key];
+	}
+
+	/**
+	 * Dynamically set attributes on the entity.
+	 *
+	 * @param  string $key
+	 * @param  mixed  $value
+	 * @return void
+	 */
+	public function __set($key, $value)
+	{
+		$this->attributes[$key] = $value;
+	}
+
+	/**
+	 * Determine if an attribute exists on the entity.
+	 *
+	 * @param  string $key
+	 * @return bool
+	 */
+	public function __isset($key)
+	{
+		return array_key_exists($key, $this->attributes);
+	}
+
+	/**
+	 * Unset an attribute on the entity.
+	 *
+	 * @param  string $key
+	 * @return void
+	 */
+	public function __unset($key)
+	{
+		unset($this->attributes[$key]);
+	}
 
     
-    /**
-     * Determine if the given attribute exists.
-     *
-     * @param  mixed $offset
-     * @return bool
-     */
-    public function offsetExists($offset)
-    {
-        return isset($this->$offset);
-    }
-
-    /**
-     * Get the value for a given offset.
-     *
-     * @param  mixed $offset
-     * @return mixed
-     */
-    public function offsetGet($offset)
-    {
-        return $this->$offset;
-    }
-
-    /**
-     * Set the value for a given offset.
-     *
-     * @param  mixed $offset
-     * @param  mixed $value
-     * @return void
-     */
-    public function offsetSet($offset, $value)
-    {
-        $this->$offset = $value;
-    }
-
-    /**
-     * Unset the value for a given offset.
-     *
-     * @param  mixed $offset
-     * @return void
-     */
-    public function offsetUnset($offset)
-    {
-        unset($this->$offset);
-    }
-
-    /**
-     * Convert the object into something JSON serializable.
-     *
-     * @return array
-     */
-    public function jsonSerialize()
-    {
-        return $this->toArray();
-    }
-
-    /**
-     * Convert the entity instance to JSON.
-     *
-     * @param  int $options
-     * @return string
-     */
-    public function toJson($options = 0)
-    {
-        return json_encode($this->toArray(), $options);
-    }
-
-    /**
-     * Convert Mappable object to array;
-     *
-     * @return array
-     */
-    public function toArray()
-    {
-        return $this->attributesToArray($this->attributes);
-    }
-
-    /**
-     * Transform the Object to array/json,
-     *
-     * @param  array $sourceAttributes
-     * @return array
-     */
-    protected function attributesToArray(array $sourceAttributes)
-    {
-        $attributes = [];
-
-        foreach ($sourceAttributes as $key => $attribute) {
-            // If the attribute is a proxy, and hasn't be loaded, we discard
-            // it from the returned set.
-            if ($attribute instanceof ProxyInterface && !$attribute->isLoaded()) {
-                continue;
-            }
-
-            if ($attribute instanceof Carbon) {
-                $attributes[$key] = $attribute->__toString();
-                continue;
-            }
-
-            if ($attribute instanceof Arrayable) {
-                $attributes[$key] = $attribute->toArray();
-            } else {
-                $attributes[$key] = $attribute;
-            }
-        }
-        return $attributes;
-    }
+	/**
+	 * Determine if the given attribute exists.
+	 *
+	 * @param  mixed $offset
+	 * @return bool
+	 */
+	public function offsetExists($offset)
+	{
+		return isset($this->$offset);
+	}
+
+	/**
+	 * Get the value for a given offset.
+	 *
+	 * @param  mixed $offset
+	 * @return mixed
+	 */
+	public function offsetGet($offset)
+	{
+		return $this->$offset;
+	}
+
+	/**
+	 * Set the value for a given offset.
+	 *
+	 * @param  mixed $offset
+	 * @param  mixed $value
+	 * @return void
+	 */
+	public function offsetSet($offset, $value)
+	{
+		$this->$offset = $value;
+	}
+
+	/**
+	 * Unset the value for a given offset.
+	 *
+	 * @param  mixed $offset
+	 * @return void
+	 */
+	public function offsetUnset($offset)
+	{
+		unset($this->$offset);
+	}
+
+	/**
+	 * Convert the object into something JSON serializable.
+	 *
+	 * @return array
+	 */
+	public function jsonSerialize()
+	{
+		return $this->toArray();
+	}
+
+	/**
+	 * Convert the entity instance to JSON.
+	 *
+	 * @param  int $options
+	 * @return string
+	 */
+	public function toJson($options = 0)
+	{
+		return json_encode($this->toArray(), $options);
+	}
+
+	/**
+	 * Convert Mappable object to array;
+	 *
+	 * @return array
+	 */
+	public function toArray()
+	{
+		return $this->attributesToArray($this->attributes);
+	}
+
+	/**
+	 * Transform the Object to array/json,
+	 *
+	 * @param  array $sourceAttributes
+	 * @return array
+	 */
+	protected function attributesToArray(array $sourceAttributes)
+	{
+		$attributes = [];
+
+		foreach ($sourceAttributes as $key => $attribute) {
+			// If the attribute is a proxy, and hasn't be loaded, we discard
+			// it from the returned set.
+			if ($attribute instanceof ProxyInterface && !$attribute->isLoaded()) {
+				continue;
+			}
+
+			if ($attribute instanceof Carbon) {
+				$attributes[$key] = $attribute->__toString();
+				continue;
+			}
+
+			if ($attribute instanceof Arrayable) {
+				$attributes[$key] = $attribute->toArray();
+			} else {
+				$attributes[$key] = $attribute;
+			}
+		}
+		return $attributes;
+	}
 }

src/Plugins/SoftDeletes/Restore.php

Indentation +25 added lines, -25 removed lines

@@ -6,36 +6,36 @@
 
 class Restore extends Command
 {
-    /**
-     * @throws \InvalidArgumentException
-     *
-     * @return false|mixed
-     */
-    public function execute()
-    {
-        $aggregate = $this->aggregate;
-        $entity = $aggregate->getEntityObject();
-        $mapper = $aggregate->getMapper();
-        $entityMap = $mapper->getEntityMap();
-
-        if ($mapper->fireEvent('restoring', $entity) === false) {
-            return false;
-        }
-
-        $keyName = $entityMap->getKeyName();
+	/**
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return false|mixed
+	 */
+	public function execute()
+	{
+		$aggregate = $this->aggregate;
+		$entity = $aggregate->getEntityObject();
+		$mapper = $aggregate->getMapper();
+		$entityMap = $mapper->getEntityMap();
+
+		if ($mapper->fireEvent('restoring', $entity) === false) {
+			return false;
+		}
+
+		$keyName = $entityMap->getKeyName();
         
-        $query = $this->query->where($keyName, '=', $aggregate->getEntityAttribute($keyName));
+		$query = $this->query->where($keyName, '=', $aggregate->getEntityAttribute($keyName));
 
-        $deletedAtColumn = $entityMap->getQualifiedDeletedAtColumn();
+		$deletedAtColumn = $entityMap->getQualifiedDeletedAtColumn();
 
-        $query->update([$deletedAtColumn => null]);
+		$query->update([$deletedAtColumn => null]);
         
-        $aggregate->setEntityAttribute($deletedAtColumn, null);
+		$aggregate->setEntityAttribute($deletedAtColumn, null);
         
-        $mapper->fireEvent('restored', $entity, false);
+		$mapper->fireEvent('restored', $entity, false);
 
-        $mapper->getEntityCache()->refresh($aggregate);
+		$mapper->getEntityCache()->refresh($aggregate);
 
-        return $entity;
-    }
+		return $entity;
+	}
 }

src/Plugins/SoftDeletes/SoftDeletesPlugin.php

Indentation +66 added lines, -66 removed lines

@@ -13,80 +13,80 @@
  */
 class SoftDeletesPlugin extends AnaloguePlugin
 {
-    /**
-     * Register the plugin
-     *
-     * @throws \Exception
-     * @return void
-     */
-    public function register()
-    {
-        $host = $this;
-
-        // Hook any mapper init and check the mapping include soft deletes.
-        $this->manager->registerGlobalEvent('initialized', function (Mapper $mapper) use ($host) {
-            $entityMap = $mapper->getEntityMap();
-
-            if ($entityMap->usesSoftDeletes()) {
-                $host->registerSoftDelete($mapper);
-            }
-
-        });
-    }
-
-    /**
-     * By hooking to the mapper initialization event, we can extend it
-     * with the softDelete capacity.
-     *
-     * @param  \Analogue\ORM\System\Mapper $mapper
-     * @throws \Analogue\ORM\Exceptions\MappingException
-     * @return bool|void
-     */
-    protected function registerSoftDelete(Mapper $mapper)
-    {
-        $entityMap = $mapper->getEntityMap();
-
-        // Add Scopes
-        $mapper->addGlobalScope(new SoftDeletingScope);
-
-        $host = $this;
-
-        // Register 'deleting' events
-        $mapper->registerEvent('deleting', function ($entity) use ($entityMap, $host) {
+	/**
+	 * Register the plugin
+	 *
+	 * @throws \Exception
+	 * @return void
+	 */
+	public function register()
+	{
+		$host = $this;
+
+		// Hook any mapper init and check the mapping include soft deletes.
+		$this->manager->registerGlobalEvent('initialized', function (Mapper $mapper) use ($host) {
+			$entityMap = $mapper->getEntityMap();
+
+			if ($entityMap->usesSoftDeletes()) {
+				$host->registerSoftDelete($mapper);
+			}
+
+		});
+	}
+
+	/**
+	 * By hooking to the mapper initialization event, we can extend it
+	 * with the softDelete capacity.
+	 *
+	 * @param  \Analogue\ORM\System\Mapper $mapper
+	 * @throws \Analogue\ORM\Exceptions\MappingException
+	 * @return bool|void
+	 */
+	protected function registerSoftDelete(Mapper $mapper)
+	{
+		$entityMap = $mapper->getEntityMap();
+
+		// Add Scopes
+		$mapper->addGlobalScope(new SoftDeletingScope);
+
+		$host = $this;
+
+		// Register 'deleting' events
+		$mapper->registerEvent('deleting', function ($entity) use ($entityMap, $host) {
             
-            // Convert Entity into an EntityWrapper
-            $factory = new Factory;
+			// Convert Entity into an EntityWrapper
+			$factory = new Factory;
 
-            $wrappedEntity = $factory->make($entity);
+			$wrappedEntity = $factory->make($entity);
 
-            $deletedAtField = $entityMap->getQualifiedDeletedAtColumn();
+			$deletedAtField = $entityMap->getQualifiedDeletedAtColumn();
 
-            if (!is_null($wrappedEntity->getEntityAttribute($deletedAtField))) {
-                return true;
-            } else {
-                $time = new Carbon;
+			if (!is_null($wrappedEntity->getEntityAttribute($deletedAtField))) {
+				return true;
+			} else {
+				$time = new Carbon;
 
-                $wrappedEntity->setEntityAttribute($deletedAtField, $time);
+				$wrappedEntity->setEntityAttribute($deletedAtField, $time);
 
-                $plainObject = $wrappedEntity->getObject();
-                $host->manager->mapper(get_class($plainObject))->store($plainObject);
+				$plainObject = $wrappedEntity->getObject();
+				$host->manager->mapper(get_class($plainObject))->store($plainObject);
 
-                return false;
-            }
+				return false;
+			}
 
-        });
+		});
 
-        // Register RestoreCommand
-        $mapper->addCustomCommand('Analogue\ORM\Plugins\SoftDeletes\Restore');
-    }
+		// Register RestoreCommand
+		$mapper->addCustomCommand('Analogue\ORM\Plugins\SoftDeletes\Restore');
+	}
 
-    /**
-     * Get custom events provided by the plugin
-     *
-     * @return string[]
-     */
-    public function getCustomEvents()
-    {
-        return ['restoring', 'restored'];
-    }
+	/**
+	 * Get custom events provided by the plugin
+	 *
+	 * @return string[]
+	 */
+	public function getCustomEvents()
+	{
+		return ['restoring', 'restored'];
+	}
 }

Spacing +2 added lines, -2 removed lines

@@ -24,7 +24,7 @@ 
         $host = $this;
 
         // Hook any mapper init and check the mapping include soft deletes.
-        $this->manager->registerGlobalEvent('initialized', function (Mapper $mapper) use ($host) {
+        $this->manager->registerGlobalEvent('initialized', function(Mapper $mapper) use ($host) {
             $entityMap = $mapper->getEntityMap();
 
             if ($entityMap->usesSoftDeletes()) {
@@ -52,7 +52,7 @@ 
         $host = $this;
 
         // Register 'deleting' events
-        $mapper->registerEvent('deleting', function ($entity) use ($entityMap, $host) {
+        $mapper->registerEvent('deleting', function($entity) use ($entityMap, $host) {
             
             // Convert Entity into an EntityWrapper
             $factory = new Factory;

src/Plugins/Timestamps/TimestampsPlugin.php

Indentation +39 added lines, -39 removed lines

@@ -12,55 +12,55 @@
  */
 class TimestampsPlugin extends AnaloguePlugin
 {
-    /**
-     * Register the plugin
-     *
-     * @throws \Exception
-     * @return void
-     */
-    public function register()
-    {
-        $this->manager->registerGlobalEvent('initialized', function (Mapper $mapper) {
-            $entityMap = $mapper->getEntityMap();
+	/**
+	 * Register the plugin
+	 *
+	 * @throws \Exception
+	 * @return void
+	 */
+	public function register()
+	{
+		$this->manager->registerGlobalEvent('initialized', function (Mapper $mapper) {
+			$entityMap = $mapper->getEntityMap();
 
-            if ($entityMap->usesTimestamps()) {
-                $mapper->registerEvent('creating', function ($entity) use ($entityMap) {
+			if ($entityMap->usesTimestamps()) {
+				$mapper->registerEvent('creating', function ($entity) use ($entityMap) {
 
-                    $factory = new Factory;
-                    $wrappedEntity = $factory->make($entity);
+					$factory = new Factory;
+					$wrappedEntity = $factory->make($entity);
 
-                    $createdAtField = $entityMap->getCreatedAtColumn();
-                    $updatedAtField = $entityMap->getUpdatedAtColumn();
+					$createdAtField = $entityMap->getCreatedAtColumn();
+					$updatedAtField = $entityMap->getUpdatedAtColumn();
 
-                    $time = new Carbon;
+					$time = new Carbon;
 
-                    $wrappedEntity->setEntityAttribute($createdAtField, $time);
-                    $wrappedEntity->setEntityAttribute($updatedAtField, $time);
+					$wrappedEntity->setEntityAttribute($createdAtField, $time);
+					$wrappedEntity->setEntityAttribute($updatedAtField, $time);
 
-                });
+				});
 
-                $mapper->registerEvent('updating', function ($entity) use ($entityMap) {
+				$mapper->registerEvent('updating', function ($entity) use ($entityMap) {
 
-                    $factory = new Factory;
-                    $wrappedEntity = $factory->make($entity);
+					$factory = new Factory;
+					$wrappedEntity = $factory->make($entity);
 
-                    $updatedAtField = $entityMap->getUpdatedAtColumn();
+					$updatedAtField = $entityMap->getUpdatedAtColumn();
 
-                    $time = new Carbon;
+					$time = new Carbon;
 
-                    $wrappedEntity->setEntityAttribute($updatedAtField, $time);
-                });
-            }
-        });
-    }
+					$wrappedEntity->setEntityAttribute($updatedAtField, $time);
+				});
+			}
+		});
+	}
 
-    /**
-     * Get custom events provided by the plugin
-     *
-     * @return array
-     */
-    public function getCustomEvents()
-    {
-        return [];
-    }
+	/**
+	 * Get custom events provided by the plugin
+	 *
+	 * @return array
+	 */
+	public function getCustomEvents()
+	{
+		return [];
+	}
 }

Spacing +3 added lines, -3 removed lines

@@ -20,11 +20,11 @@ 
      */
     public function register()
     {
-        $this->manager->registerGlobalEvent('initialized', function (Mapper $mapper) {
+        $this->manager->registerGlobalEvent('initialized', function(Mapper $mapper) {
             $entityMap = $mapper->getEntityMap();
 
             if ($entityMap->usesTimestamps()) {
-                $mapper->registerEvent('creating', function ($entity) use ($entityMap) {
+                $mapper->registerEvent('creating', function($entity) use ($entityMap) {
 
                     $factory = new Factory;
                     $wrappedEntity = $factory->make($entity);
@@ -39,7 +39,7 @@ 
 
                 });
 
-                $mapper->registerEvent('updating', function ($entity) use ($entityMap) {
+                $mapper->registerEvent('updating', function($entity) use ($entityMap) {
 
                     $factory = new Factory;
                     $wrappedEntity = $factory->make($entity);

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