analogueorm / analogue

src/AnalogueServiceProvider.php

Doc Comments +1 added lines, -1 removed lines

@@ -56,7 +56,7 @@
     /**
      * Get the services provided by the provider.
      *
-     * @return array
+     * @return string[]
      */
     public function provides()
     {

Spacing +2 added lines, -2 removed lines

@@ -36,7 +36,7 @@ 
     {
         // Experimenting autoloading proxies
 
-        $this->app->singleton('analogue', function ($app) {
+        $this->app->singleton('analogue', function($app) {
             $db = $app['db'];
 
             $connectionProvider = new IlluminateConnectionProvider($db);
@@ -75,7 +75,7 @@ 
             return $manager;
         });
 
-        $this->app->bind(Manager::class, function ($app) {
+        $this->app->bind(Manager::class, function($app) {
             return $app->make('analogue');
         });
     }

Indentation +56 added lines, -56 removed lines

@@ -15,79 +15,79 @@
  */
 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()
-    {
-        // Experimenting autoloading proxies
+	/**
+	 * Register the service provider.
+	 *
+	 * @return void
+	 */
+	public function register()
+	{
+		// Experimenting autoloading proxies
 
-        $this->app->singleton('analogue', function ($app) {
-            $db = $app['db'];
+		$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);
 
-            // If the cache is pre laravel 5.5, it doesn't implements PSR-16, so we'll skip it.
-            $cache = $app->make(CacheRepository::class);
+			// If the cache is pre laravel 5.5, it doesn't implements PSR-16, so we'll skip it.
+			$cache = $app->make(CacheRepository::class);
 
-            if ($cache instanceof CacheInterface) {
-                $manager->setCache($cache);
-            }
+			if ($cache instanceof CacheInterface) {
+				$manager->setCache($cache);
+			}
 
-            $proxyPath = storage_path('framework/analogue/proxies');
+			$proxyPath = storage_path('framework/analogue/proxies');
 
-            if (!file_exists($proxyPath)) {
-                mkdir($proxyPath, 0777, true);
-            }
+			if (!file_exists($proxyPath)) {
+				mkdir($proxyPath, 0777, true);
+			}
 
-            $proxyConfig = new \ProxyManager\Configuration();
-            $proxyConfig->setProxiesTargetDir($proxyPath);
-            spl_autoload_register($proxyConfig->getProxyAutoloader());
+			$proxyConfig = new \ProxyManager\Configuration();
+			$proxyConfig->setProxiesTargetDir($proxyPath);
+			spl_autoload_register($proxyConfig->getProxyAutoloader());
 
-            $manager->setProxyPath($proxyPath);
+			$manager->setProxyPath($proxyPath);
 
-            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'];
+	}
 }

src/Plugins/SoftDeletes/SoftDeletingScope.php

Spacing +2 added lines, -2 removed lines

@@ -73,7 +73,7 @@ 
      */
     protected function addWithTrashed(Query $query)
     {
-        $query->macro('withTrashed', function (Query $query) {
+        $query->macro('withTrashed', function(Query $query) {
             $this->remove($query);
 
             return $query;
@@ -88,7 +88,7 @@ 
      */
     protected function addOnlyTrashed(Query $query)
     {
-        $query->macro('onlyTrashed', function (Query $query) {
+        $query->macro('onlyTrashed', function(Query $query) {
             $this->remove($query);
 
             $query->getQuery()->whereNotNull($query->getMapper()->getEntityMap()->getQualifiedDeletedAtColumn());

Indentation +103 added lines, -103 removed lines

@@ -7,107 +7,107 @@
 
 class SoftDeletingScope implements ScopeInterface
 {
-    /**
-     * All of the extensions to be added to the builder.
-     *
-     * @var array
-     */
-    protected $extensions = [
-        'WithTrashed',
-        'OnlyTrashed',
-    ];
-
-    /**
-     * {@inheritdoc}
-     */
-    public function apply(Query $query)
-    {
-        $entityMap = $query->getMapper()->getEntityMap();
-
-        $query->whereNull($entityMap->getQualifiedDeletedAtColumn());
-
-        $this->extend($query);
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function remove(Query $query)
-    {
-        $column = $query->getMapper()->getEntityMap()->getQualifiedDeletedAtColumn();
-
-        $query = $query->getQuery();
-
-        foreach ((array) $query->wheres as $key => $where) {
-            // If the where clause is a soft delete date constraint, we will remove it from
-            // the query and reset the keys on the wheres. This allows this developer to
-            // include deleted model in a relationship result set that is lazy loaded.
-            if ($this->isSoftDeleteConstraint($where, $column)) {
-                unset($query->wheres[$key]);
-
-                $query->wheres = array_values($query->wheres);
-            }
-        }
-    }
-
-    /**
-     * Extend the query builder with the needed functions.
-     *
-     * @param \Analogue\ORM\System\Query $query
-     *
-     * @return void
-     */
-    public function extend(Query $query)
-    {
-        foreach ($this->extensions as $extension) {
-            $this->{"add{$extension}"}($query);
-        }
-    }
-
-    /**
-     * Add the with-trashed extension to the builder.
-     *
-     * @param \Analogue\ORM\System\Query $query
-     *
-     * @return void
-     */
-    protected function addWithTrashed(Query $query)
-    {
-        $query->macro('withTrashed', function (Query $query) {
-            $this->remove($query);
-
-            return $query;
-        });
-    }
-
-    /**
-     * Add the only-trashed extension to the builder.
-     *
-     * @param \Analogue\ORM\System\Query $query
-     *
-     * @return void
-     */
-    protected function addOnlyTrashed(Query $query)
-    {
-        $query->macro('onlyTrashed', function (Query $query) {
-            $this->remove($query);
-
-            $query->getQuery()->whereNotNull($query->getMapper()->getEntityMap()->getQualifiedDeletedAtColumn());
-
-            return $query;
-        });
-    }
-
-    /**
-     * Determine if the given where clause is a soft delete constraint.
-     *
-     * @param array  $where
-     * @param string $column
-     *
-     * @return bool
-     */
-    protected function isSoftDeleteConstraint(array $where, $column)
-    {
-        return $where['type'] == 'Null' && $where['column'] == $column;
-    }
+	/**
+	 * All of the extensions to be added to the builder.
+	 *
+	 * @var array
+	 */
+	protected $extensions = [
+		'WithTrashed',
+		'OnlyTrashed',
+	];
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function apply(Query $query)
+	{
+		$entityMap = $query->getMapper()->getEntityMap();
+
+		$query->whereNull($entityMap->getQualifiedDeletedAtColumn());
+
+		$this->extend($query);
+	}
+
+	/**
+	 * {@inheritdoc}
+	 */
+	public function remove(Query $query)
+	{
+		$column = $query->getMapper()->getEntityMap()->getQualifiedDeletedAtColumn();
+
+		$query = $query->getQuery();
+
+		foreach ((array) $query->wheres as $key => $where) {
+			// If the where clause is a soft delete date constraint, we will remove it from
+			// the query and reset the keys on the wheres. This allows this developer to
+			// include deleted model in a relationship result set that is lazy loaded.
+			if ($this->isSoftDeleteConstraint($where, $column)) {
+				unset($query->wheres[$key]);
+
+				$query->wheres = array_values($query->wheres);
+			}
+		}
+	}
+
+	/**
+	 * Extend the query builder with the needed functions.
+	 *
+	 * @param \Analogue\ORM\System\Query $query
+	 *
+	 * @return void
+	 */
+	public function extend(Query $query)
+	{
+		foreach ($this->extensions as $extension) {
+			$this->{"add{$extension}"}($query);
+		}
+	}
+
+	/**
+	 * Add the with-trashed extension to the builder.
+	 *
+	 * @param \Analogue\ORM\System\Query $query
+	 *
+	 * @return void
+	 */
+	protected function addWithTrashed(Query $query)
+	{
+		$query->macro('withTrashed', function (Query $query) {
+			$this->remove($query);
+
+			return $query;
+		});
+	}
+
+	/**
+	 * Add the only-trashed extension to the builder.
+	 *
+	 * @param \Analogue\ORM\System\Query $query
+	 *
+	 * @return void
+	 */
+	protected function addOnlyTrashed(Query $query)
+	{
+		$query->macro('onlyTrashed', function (Query $query) {
+			$this->remove($query);
+
+			$query->getQuery()->whereNotNull($query->getMapper()->getEntityMap()->getQualifiedDeletedAtColumn());
+
+			return $query;
+		});
+	}
+
+	/**
+	 * Determine if the given where clause is a soft delete constraint.
+	 *
+	 * @param array  $where
+	 * @param string $column
+	 *
+	 * @return bool
+	 */
+	protected function isSoftDeleteConstraint(array $where, $column)
+	{
+		return $where['type'] == 'Null' && $where['column'] == $column;
+	}
 }

src/Exceptions/EntityMapNotFoundException.php

Indentation +1 added lines, -1 removed lines

@@ -6,5 +6,5 @@
 
 class EntityMapNotFoundException extends RuntimeException
 {
-    //
+	//
 }

src/ValueMap.php

Doc Comments +2 added lines, -2 removed lines

@@ -71,7 +71,7 @@ 
     }
 
     /**
-     * @param $class
+     * @param string $class
      */
     public function setClass($class)
     {
@@ -79,7 +79,7 @@ 
     }
 
     /**
-     * @return mixed
+     * @return string
      */
     public function getClass()
     {

Indentation +80 added lines, -80 removed lines

@@ -7,97 +7,97 @@
  */
 class ValueMap
 {
-    /**
-     * @var string
-     */
-    protected $name;
+	/**
+	 * @var string
+	 */
+	protected $name;
 
-    /**
-     * @var string
-     */
-    protected $class;
+	/**
+	 * @var string
+	 */
+	protected $class;
 
-    /**
-     * @var array
-     */
-    protected $embeddables = [];
+	/**
+	 * @var array
+	 */
+	protected $embeddables = [];
 
-    /**
-     * @var array
-     */
-    protected $attributes = [];
+	/**
+	 * @var array
+	 */
+	protected $attributes = [];
 
-    /**
-     * @var array
-     */
-    protected $properties = [];
+	/**
+	 * @var array
+	 */
+	protected $properties = [];
 
-    protected $arrayName = null;
+	protected $arrayName = null;
 
-    /**
-     * @return array
-     */
-    public function getAttributes()
-    {
-        return $this->attributes;
-    }
+	/**
+	 * @return array
+	 */
+	public function getAttributes()
+	{
+		return $this->attributes;
+	}
 
-    /**
-     * [getAttributesArrayName description].
-     *
-     * @return [type] [description]
-     */
-    public function getAttributesArrayName()
-    {
-        return $this->arrayName;
-    }
+	/**
+	 * [getAttributesArrayName description].
+	 *
+	 * @return [type] [description]
+	 */
+	public function getAttributesArrayName()
+	{
+		return $this->arrayName;
+	}
 
-    public function usesAttributesArray()
-    {
-        return $this->arrayName != null;
-    }
+	public function usesAttributesArray()
+	{
+		return $this->arrayName != null;
+	}
 
-    /**
-     * @return array
-     */
-    public function getProperties()
-    {
-        return $this->properties;
-    }
+	/**
+	 * @return array
+	 */
+	public function getProperties()
+	{
+		return $this->properties;
+	}
 
-    /**
-     * @return array
-     */
-    public function getEmbeddables()
-    {
-        return $this->embeddables;
-    }
+	/**
+	 * @return array
+	 */
+	public function getEmbeddables()
+	{
+		return $this->embeddables;
+	}
 
-    /**
-     * @param $class
-     */
-    public function setClass($class)
-    {
-        $this->class = $class;
-    }
+	/**
+	 * @param $class
+	 */
+	public function setClass($class)
+	{
+		$this->class = $class;
+	}
 
-    /**
-     * @return mixed
-     */
-    public function getClass()
-    {
-        return $this->class;
-    }
+	/**
+	 * @return mixed
+	 */
+	public function getClass()
+	{
+		return $this->class;
+	}
 
-    /**
-     * @return string
-     */
-    public function getName()
-    {
-        if (isset($this->name)) {
-            return $this->name;
-        } else {
-            return class_basename($this);
-        }
-    }
+	/**
+	 * @return string
+	 */
+	public function getName()
+	{
+		if (isset($this->name)) {
+			return $this->name;
+		} else {
+			return class_basename($this);
+		}
+	}
 }

src/System/Manager.php

Doc Comments +3 added lines, -3 removed lines

@@ -143,7 +143,7 @@ 
      * Create a mapper for a given entity.
      *
      * @param \Analogue\ORM\Mappable|string|array|\Traversable $entity
-     * @param mixed                                            $entityMap
+     * @param null|EntityMap                                            $entityMap
      *
      * @throws MappingException
      * @throws \InvalidArgumentException
@@ -251,7 +251,7 @@ 
     /**
      * Check if the entity is already registered.
      *
-     * @param string|Entity $entity
+     * @param string $entity
      *
      * @return bool
      */
@@ -333,7 +333,7 @@ 
     /**
      * Register an entity.
      *
-     * @param string|\Analogue\ORM\Mappable $entity    entity's class name
+     * @param string $entity    entity's class name
      * @param string|EntityMap              $entityMap map's class name
      *
      * @throws MappingException

Indentation +793 added lines, -793 removed lines

@@ -21,797 +21,797 @@
  */
 class Manager
 {
-    /**
-     * Manager instance.
-     *
-     * @var Manager
-     */
-    protected static $instance;
-
-    /**
-     * Driver Manager.
-     *
-     * @var \Analogue\ORM\Drivers\Manager
-     */
-    protected $drivers;
-
-    /**
-     * Registered entity classes and corresponding map objects.
-     *
-     * @var array
-     */
-    protected $entityClasses = [];
-
-    /**
-     * Key value store of ValueObject Classes and corresponding map classes.
-     *
-     * @var array|ValueMap[]
-     */
-    protected $valueClasses = [];
-
-    /**
-     * Morph map.
-     */
-    protected $morphMap = [];
-
-    /**
-     * Loaded Mappers.
-     *
-     * @var array
-     */
-    protected $mappers = [];
-
-    /**
-     * Loaded Repositories.
-     *
-     * @var array
-     */
-    protected $repositories = [];
-
-    /**
-     * Event dispatcher instance.
-     *
-     * @var \Illuminate\Contracts\Events\Dispatcher
-     */
-    protected $eventDispatcher;
-
-    /**
-     * Optionnal Cache implementation.
-     *
-     * @var CacheInterface
-     */
-    protected $cache = null;
-
-    /**
-     * Available Analogue Events.
-     *
-     * @var array
-     */
-    protected $events = [
-        'initializing' => \Analogue\ORM\Events\Initializing::class,
-        'initialized'  => \Analogue\ORM\Events\Initialized::class,
-        'storing'      => \Analogue\ORM\Events\Storing::class,
-        'stored'       => \Analogue\ORM\Events\Stored::class,
-        'creating'     => \Analogue\ORM\Events\Creating::class,
-        'created'      => \Analogue\ORM\Events\Created::class,
-        'updating'     => \Analogue\ORM\Events\Updating::class,
-        'updated'      => \Analogue\ORM\Events\Updated::class,
-        'deleting'     => \Analogue\ORM\Events\Deleting::class,
-        'deleted'      => \Analogue\ORM\Events\Deleted::class,
-    ];
-
-    /**
-     * If strictMode is set to true, Manager will throw
-     * an exception if no entityMap class are registered
-     * for a given entity class.
-     *
-     * @var bool
-     */
-    protected $strictMode = true;
-
-    /**
-     * We can add namespaces in this array where the manager
-     * will look for when auto registering entityMaps.
-     *
-     * @var array
-     */
-    protected $customMapNamespaces = [];
-
-    /**
-     * Path where generated proxy classes are stored.
-     *
-     * @var string
-     */
-    protected $proxyPath;
-
-    /**
-     * @param \Analogue\ORM\Drivers\Manager $driverManager
-     * @param Dispatcher                    $event
-     */
-    public function __construct(DriverManager $driverManager, Dispatcher $event)
-    {
-        $this->drivers = $driverManager;
-
-        $this->eventDispatcher = $event;
-
-        static::$instance = $this;
-    }
-
-    /**
-     * Create a mapper for a given entity (static alias).
-     *
-     * @param \Analogue\ORM\Mappable|string $entity
-     * @param null|EntityMap                $entityMap
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return Mapper
-     */
-    public static function getMapper($entity, $entityMap = null)
-    {
-        return static::$instance->mapper($entity, $entityMap);
-    }
-
-    /**
-     * Create a mapper for a given entity.
-     *
-     * @param \Analogue\ORM\Mappable|string|array|\Traversable $entity
-     * @param mixed                                            $entityMap
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return Mapper
-     */
-    public function mapper($entity, $entityMap = null)
-    {
-        if ($entity instanceof Wrapper) {
-            throw new MappingException('Tried to instantiate mapper on wrapped Entity');
-        }
-
-        $entity = $this->resolveEntityClass($entity);
-
-        $entity = $this->getInverseMorphMap($entity);
-
-        // Return existing mapper instance if exists.
-        if (array_key_exists($entity, $this->mappers)) {
-            return $this->mappers[$entity];
-        } else {
-            return $this->buildMapper($entity, $entityMap);
-        }
-    }
-
-    /**
-     * This method resolve entity class from mappable instances or iterators.
-     *
-     * @param \Analogue\ORM\Mappable|string|array|\Traversable $entity
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return string
-     */
-    protected function resolveEntityClass($entity)
-    {
-        // We first check if the entity is traversable and we'll resolve
-        // the entity based on the first item of the object.
-        if ($this->isTraversable($entity)) {
-            if (!count($entity)) {
-                throw new \InvalidArgumentException('Length of Entity collection must be greater than 0');
-            }
-
-            $firstEntityItem = ($entity instanceof \Iterator)
-                ? $entity->current()
-                : current($entity);
-
-            return $this->resolveEntityClass($firstEntityItem);
-        }
-
-        if (is_object($entity)) {
-            return get_class($entity);
-        }
-
-        if (is_string($entity)) {
-            return $entity;
-        }
-
-        throw new \InvalidArgumentException('Invalid entity type');
-    }
-
-    /**
-     * @param string $key
-     *
-     * @return string
-     */
-    public function getInverseMorphMap($key)
-    {
-        return array_key_exists($key, $this->morphMap) ? $this->morphMap[$key] : $key;
-    }
-
-    /**
-     * Build a new Mapper instance for a given Entity.
-     *
-     * @param string $entity
-     * @param mixed  $entityMap
-     *
-     * @throws MappingException
-     *
-     * @return Mapper
-     */
-    protected function buildMapper($entity, $entityMap)
-    {
-        // If an EntityMap hasn't been manually registered by the user
-        // register it at runtime.
-        if (!$this->isRegisteredEntity($entity)) {
-            $this->register($entity, $entityMap);
-        }
-
-        $entityMap = $this->entityClasses[$entity];
-
-        $factory = new MapperFactory($this->drivers, $this->eventDispatcher, $this);
-
-        $mapper = $factory->make($entity, $entityMap);
-
-        $this->mappers[$entity] = $mapper;
-
-        // At this point we can safely call the boot() method on the entityMap as
-        // the mapper is now instantiated & registered within the manager.
-
-        if (!$entityMap->isBooted()) {
-            $entityMap->boot();
-        }
-
-        // If a cache is defined, use it to store the entityMap
-        if ($this->cache !== null && !$this->cache->has($entityMap->getClass()) && !$this->isAnonymous($entityMap)) {
-            $this->cache->set($entityMap->getClass(), serialize($entityMap), 1440);
-        }
-
-        return $mapper;
-    }
-
-    /**
-     * Check if an Object is an anonymous class instance.
-     *
-     * @param mixed $class
-     *
-     * @return bool
-     */
-    protected function isAnonymous($class) : bool
-    {
-        $instance = new ReflectionClass($class);
-
-        return $instance->isAnonymous();
-    }
-
-    /**
-     * Check if the entity is already registered.
-     *
-     * @param string|Entity $entity
-     *
-     * @return bool
-     */
-    public function isRegisteredEntity($entity)
-    {
-        if (!is_string($entity)) {
-            $entity = get_class($entity);
-        }
-
-        return array_key_exists($entity, $this->entityClasses);
-    }
-
-    /**
-     * Return an array containing registered entities & entityMap instances.
-     *
-     * @return array
-     */
-    public function getRegisteredEntities()
-    {
-        return $this->entityClasses;
-    }
-
-    /**
-     * Check if a value class is already registered.
-     *
-     * @param string|\stdClass $object
-     *
-     * @return bool
-     */
-    public function isRegisteredValueObject($object)
-    {
-        if (!is_string($object)) {
-            $object = get_class($object);
-        }
-
-        return array_key_exists($object, $this->valueClasses);
-    }
-
-    /**
-     * Return true if an object is an array or iterator.
-     *
-     * @param mixed $argument
-     *
-     * @return bool
-     */
-    public function isTraversable($argument)
-    {
-        return $argument instanceof \Traversable || is_array($argument);
-    }
-
-    /**
-     * Set strict mode for entityMap instantiation.
-     *
-     * @param bool $mode
-     */
-    public function setStrictMode($mode)
-    {
-        $this->strictMode = $mode;
-    }
-
-    /**
-     * Define a generated proxy class path.
-     *
-     * @param string $path
-     */
-    public function setProxyPath(string $path)
-    {
-        $this->proxyPath = $path;
-    }
-
-    /**
-     * Return proxy path if defined.
-     *
-     * @return string|null
-     */
-    public function getProxyPath()
-    {
-        return $this->proxyPath;
-    }
-
-    /**
-     * Register a namespace in where Analogue
-     * will scan for EntityMaps & ValueMaps.
-     *
-     * @param string $namespace
-     *
-     * @return void
-     */
-    public function registerMapNamespace($namespace)
-    {
-        // Add a trailing antislash to namespace if not present
-        if (substr('testers', -1) != '\\') {
-            $namespace = $namespace.'\\';
-        }
-
-        $this->customMapNamespaces[] = $namespace;
-    }
-
-    /**
-     * Register an entity.
-     *
-     * @param string|\Analogue\ORM\Mappable $entity    entity's class name
-     * @param string|EntityMap              $entityMap map's class name
-     *
-     * @throws MappingException
-     *
-     * @return void
-     */
-    public function register($entity, $entityMap = null)
-    {
-        // If an object is provider, get the class name from it
-        if (!is_string($entity)) {
-            $entity = get_class($entity);
-        }
-
-        if ($this->isRegisteredEntity($entity)) {
-            throw new MappingException("Entity $entity is already registered.");
-        }
-
-        if (!class_exists($entity)) {
-            throw new MappingException("Class $entity does not exists");
-        }
-
-        if ($entityMap === null) {
-            $entityMap = $this->getEntityMapInstanceFor($entity);
-        }
-
-        if (is_string($entityMap)) {
-            $entityMap = new $entityMap();
-        }
-
-        if (!$entityMap instanceof EntityMap) {
-            throw new MappingException(get_class($entityMap).' must be an instance of EntityMap.');
-        }
-
-        $entityMap->setClass($entity);
-
-        $this->entityClasses[$entity] = $entityMap;
-    }
-
-    /**
-     * Get the entity map instance for a custom entity.
-     *
-     * @param string $entity
-     *
-     * @return \Analogue\ORM\EntityMap
-     */
-    protected function getEntityMapInstanceFor($entity)
-    {
-        // First, we'll try to load the entity map from cache, to
-        // save from time consuming parsing of the relationships
-        $entityMap = $this->getEntityMapInstanceFromCache($entity);
-
-        if ($entityMap !== null) {
-            return $entityMap;
-        }
-
-        if (class_exists($entity.'Map')) {
-            $map = $entity.'Map';
-            $map = new $map();
-
-            return $map;
-        }
-
-        if ($map = $this->getMapFromNamespaces($entity)) {
-            return $map;
-        }
-
-        if ($this->strictMode) {
-            throw new EntityMapNotFoundException("No Map registered for $entity");
-        }
-
-        $map = $this->getNewEntityMap();
-
-        return $map;
-    }
-
-    /**
-     * Get Entity Map instance from cache.
-     *
-     * @param string $entityClass
-     *
-     * @return EntityMap|null
-     */
-    protected function getEntityMapInstanceFromCache(string $entityClass)
-    {
-        if ($this->cache == null) {
-            return;
-        }
-
-        if ($this->cache->has($entityClass)) {
-            return unserialize($this->cache->get($entityClass));
-        }
-    }
-
-    /**
-     * Scan through registered custom namespace
-     * for an Entity/ValueMap.
-     *
-     * @param string $class
-     *
-     * @return ValueMap|EntityMap|bool
-     */
-    protected function getMapFromNamespaces($class)
-    {
-        foreach ($this->customMapNamespaces as $namespace) {
-            if ($map = $this->findMapInNamespace($class, $namespace)) {
-                return $map;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * Look in a custom namespace for an Entity/ValueMap.
-     *
-     * @param string $class
-     * @param string $namespace
-     *
-     * @return ValueMap|EntityMap|bool
-     */
-    protected function findMapInNamespace($class, $namespace)
-    {
-        $parts = explode('\\', $class);
-
-        $baseClass = $parts[count($parts) - 1];
-
-        $expectedClass = $namespace.$baseClass.'Map';
-
-        if (class_exists($expectedClass)) {
-            return new $expectedClass();
-        }
-
-        return false;
-    }
-
-    /**
-     * Dynamically create an entity map for a custom entity class.
-     *
-     * @return EntityMap
-     */
-    protected function getNewEntityMap()
-    {
-        return new EntityMap();
-    }
-
-    /**
-     * Return the Singleton instance of the manager.
-     *
-     * @return Manager
-     */
-    public static function getInstance()
-    {
-        return static::$instance;
-    }
-
-    /**
-     * Return the Driver Manager's instance.
-     *
-     * @return \Analogue\ORM\Drivers\Manager
-     */
-    public function getDriverManager()
-    {
-        return $this->drivers;
-    }
-
-    /**
-     * Get the Repository instance for the given Entity.
-     *
-     * @param \Analogue\ORM\Mappable|string $entity
-     *
-     * @throws \InvalidArgumentException
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\Repository
-     */
-    public function repository($entity)
-    {
-        if (!is_string($entity)) {
-            $entity = get_class($entity);
-        }
-
-        // First we check if the repository is not already created.
-        if (array_key_exists($entity, $this->repositories)) {
-            return $this->repositories[$entity];
-        }
-
-        $this->repositories[$entity] = new Repository($this->mapper($entity));
-
-        return $this->repositories[$entity];
-    }
-
-    /**
-     * Return true is the object is registered as value object.
-     *
-     * @param mixed $object
-     *
-     * @return bool
-     */
-    public function isValueObject($object)
-    {
-        if (!is_string($object)) {
-            $object = get_class($object);
-        }
-
-        return array_key_exists($object, $this->valueClasses);
-    }
-
-    /**
-     * Get the Value Map for a given Value Object Class.
-     *
-     * @param string $valueObject
-     *
-     * @throws MappingException
-     *
-     * @return \Analogue\ORM\ValueMap
-     */
-    public function getValueMap($valueObject)
-    {
-        if (!is_string($valueObject)) {
-            $valueObject = get_class($valueObject);
-        }
-
-        if (!array_key_exists($valueObject, $this->valueClasses)) {
-            $this->registerValueObject($valueObject);
-        }
-
-        /** @var ValueMap $valueMap */
-        $valueMap = new $this->valueClasses[$valueObject]();
-
-        $valueMap->setClass($valueObject);
-
-        return $valueMap;
-    }
-
-    /**
-     * Register a Value Object.
-     *
-     * @param string $valueObject
-     * @param string $valueMap
-     *
-     * @throws MappingException
-     *
-     * @return void
-     */
-    public function registerValueObject($valueObject, $valueMap = null)
-    {
-        if (!is_string($valueObject)) {
-            $valueObject = get_class($valueObject);
-        }
-
-        if ($valueMap === null) {
-
-            // First, we'll look into registered namespaces for Entity Maps,
-            // if any. Then we'll fallback to the same namespace of the object
-            if (!$valueMap = $this->getMapFromNamespaces($valueObject)) {
-                $valueMap = $valueObject.'Map';
-            } else {
-                $valueMap = get_class($valueMap);
-            }
-        }
-
-        if (!class_exists($valueMap)) {
-            throw new MappingException("$valueMap doesn't exists");
-        }
-
-        $this->valueClasses[$valueObject] = $valueMap;
-    }
-
-    /**
-     * Instantiate a new Value Object instance.
-     *
-     * @param string $valueObject
-     *
-     * @return \Analogue\ORM\ValueObject
-     */
-    public function getValueObjectInstance($valueObject)
-    {
-        $prototype = unserialize(sprintf('O:%d:"%s":0:{}', strlen($valueObject), $valueObject));
-
-        return $prototype;
-    }
-
-    /**
-     * Set an application cache.
-     *
-     * @param \Psr\SimpleCache\CacheInterface $cache
-     */
-    public function setCache(CacheInterface $cache)
-    {
-        $this->cache = $cache;
-    }
-
-    /**
-     * Register Analogue Plugin.
-     *
-     * @param string $plugin class
-     *
-     * @return void
-     */
-    public function registerPlugin($plugin)
-    {
-        /** @var AnaloguePluginInterface $plugin */
-        $plugin = new $plugin($this);
-
-        $this->events = array_merge($this->events, $plugin->getCustomEvents());
-
-        $plugin->register();
-    }
-
-    /**
-     * Register event listeners that will be fired regardless the type
-     * of the entity.
-     *
-     * @param string   $event
-     * @param \Closure $callback
-     *
-     * @throws \LogicException
-     *
-     * @return void
-     */
-    public function registerGlobalEvent($event, $callback)
-    {
-        if (!array_key_exists($event, $this->events)) {
-            throw new \LogicException("Analogue : Event $event doesn't exist");
-        }
-
-        $this->eventDispatcher->listen("analogue.{$event}.*", $callback);
-        //$this->eventDispatcher->listen($this->events[$event], $callback);
-    }
-
-    /**
-     * Shortcut to Mapper store.
-     *
-     * @param mixed $entity
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return mixed
-     */
-    public function store($entity)
-    {
-        return $this->mapper($entity)->store($entity);
-    }
-
-    /**
-     * Shortcut to Mapper delete.
-     *
-     * @param mixed $entity
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return \Traversable|array
-     */
-    public function delete($entity)
-    {
-        return $this->mapper($entity)->delete($entity);
-    }
-
-    /**
-     * Shortcut to Mapper query.
-     *
-     * @param mixed $entity
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return Query
-     */
-    public function query($entity)
-    {
-        return $this->mapper($entity)->query();
-    }
-
-    /**
-     * Shortcut to Mapper Global Query.
-     *
-     * @param mixed $entity
-     *
-     * @throws MappingException
-     * @throws \InvalidArgumentException
-     *
-     * @return Query
-     */
-    public function globalQuery($entity)
-    {
-        return $this->mapper($entity)->globalQuery();
-    }
-
-    /**
-     * @param array $morphMap
-     *
-     * @return $this
-     */
-    public function morphMap(array $morphMap)
-    {
-        $this->morphMap = $morphMap;
-
-        return $this;
-    }
-
-    /**
-     * @param string $class
-     *
-     * @return mixed
-     */
-    public function getMorphMap($class)
-    {
-        $key = array_search($class, $this->morphMap, false);
-
-        return $key !== false ? $key : $class;
-    }
-
-    /**
-     * Clear all the cached entities within all mappers.
-     *
-     * @return void
-     */
-    public function clearCache()
-    {
-        array_map(function ($mapper) {
-            $mapper->clearCache();
-        }, $this->mappers);
-    }
+	/**
+	 * Manager instance.
+	 *
+	 * @var Manager
+	 */
+	protected static $instance;
+
+	/**
+	 * Driver Manager.
+	 *
+	 * @var \Analogue\ORM\Drivers\Manager
+	 */
+	protected $drivers;
+
+	/**
+	 * Registered entity classes and corresponding map objects.
+	 *
+	 * @var array
+	 */
+	protected $entityClasses = [];
+
+	/**
+	 * Key value store of ValueObject Classes and corresponding map classes.
+	 *
+	 * @var array|ValueMap[]
+	 */
+	protected $valueClasses = [];
+
+	/**
+	 * Morph map.
+	 */
+	protected $morphMap = [];
+
+	/**
+	 * Loaded Mappers.
+	 *
+	 * @var array
+	 */
+	protected $mappers = [];
+
+	/**
+	 * Loaded Repositories.
+	 *
+	 * @var array
+	 */
+	protected $repositories = [];
+
+	/**
+	 * Event dispatcher instance.
+	 *
+	 * @var \Illuminate\Contracts\Events\Dispatcher
+	 */
+	protected $eventDispatcher;
+
+	/**
+	 * Optionnal Cache implementation.
+	 *
+	 * @var CacheInterface
+	 */
+	protected $cache = null;
+
+	/**
+	 * Available Analogue Events.
+	 *
+	 * @var array
+	 */
+	protected $events = [
+		'initializing' => \Analogue\ORM\Events\Initializing::class,
+		'initialized'  => \Analogue\ORM\Events\Initialized::class,
+		'storing'      => \Analogue\ORM\Events\Storing::class,
+		'stored'       => \Analogue\ORM\Events\Stored::class,
+		'creating'     => \Analogue\ORM\Events\Creating::class,
+		'created'      => \Analogue\ORM\Events\Created::class,
+		'updating'     => \Analogue\ORM\Events\Updating::class,
+		'updated'      => \Analogue\ORM\Events\Updated::class,
+		'deleting'     => \Analogue\ORM\Events\Deleting::class,
+		'deleted'      => \Analogue\ORM\Events\Deleted::class,
+	];
+
+	/**
+	 * If strictMode is set to true, Manager will throw
+	 * an exception if no entityMap class are registered
+	 * for a given entity class.
+	 *
+	 * @var bool
+	 */
+	protected $strictMode = true;
+
+	/**
+	 * We can add namespaces in this array where the manager
+	 * will look for when auto registering entityMaps.
+	 *
+	 * @var array
+	 */
+	protected $customMapNamespaces = [];
+
+	/**
+	 * Path where generated proxy classes are stored.
+	 *
+	 * @var string
+	 */
+	protected $proxyPath;
+
+	/**
+	 * @param \Analogue\ORM\Drivers\Manager $driverManager
+	 * @param Dispatcher                    $event
+	 */
+	public function __construct(DriverManager $driverManager, Dispatcher $event)
+	{
+		$this->drivers = $driverManager;
+
+		$this->eventDispatcher = $event;
+
+		static::$instance = $this;
+	}
+
+	/**
+	 * Create a mapper for a given entity (static alias).
+	 *
+	 * @param \Analogue\ORM\Mappable|string $entity
+	 * @param null|EntityMap                $entityMap
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return Mapper
+	 */
+	public static function getMapper($entity, $entityMap = null)
+	{
+		return static::$instance->mapper($entity, $entityMap);
+	}
+
+	/**
+	 * Create a mapper for a given entity.
+	 *
+	 * @param \Analogue\ORM\Mappable|string|array|\Traversable $entity
+	 * @param mixed                                            $entityMap
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return Mapper
+	 */
+	public function mapper($entity, $entityMap = null)
+	{
+		if ($entity instanceof Wrapper) {
+			throw new MappingException('Tried to instantiate mapper on wrapped Entity');
+		}
+
+		$entity = $this->resolveEntityClass($entity);
+
+		$entity = $this->getInverseMorphMap($entity);
+
+		// Return existing mapper instance if exists.
+		if (array_key_exists($entity, $this->mappers)) {
+			return $this->mappers[$entity];
+		} else {
+			return $this->buildMapper($entity, $entityMap);
+		}
+	}
+
+	/**
+	 * This method resolve entity class from mappable instances or iterators.
+	 *
+	 * @param \Analogue\ORM\Mappable|string|array|\Traversable $entity
+	 *
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return string
+	 */
+	protected function resolveEntityClass($entity)
+	{
+		// We first check if the entity is traversable and we'll resolve
+		// the entity based on the first item of the object.
+		if ($this->isTraversable($entity)) {
+			if (!count($entity)) {
+				throw new \InvalidArgumentException('Length of Entity collection must be greater than 0');
+			}
+
+			$firstEntityItem = ($entity instanceof \Iterator)
+				? $entity->current()
+				: current($entity);
+
+			return $this->resolveEntityClass($firstEntityItem);
+		}
+
+		if (is_object($entity)) {
+			return get_class($entity);
+		}
+
+		if (is_string($entity)) {
+			return $entity;
+		}
+
+		throw new \InvalidArgumentException('Invalid entity type');
+	}
+
+	/**
+	 * @param string $key
+	 *
+	 * @return string
+	 */
+	public function getInverseMorphMap($key)
+	{
+		return array_key_exists($key, $this->morphMap) ? $this->morphMap[$key] : $key;
+	}
+
+	/**
+	 * Build a new Mapper instance for a given Entity.
+	 *
+	 * @param string $entity
+	 * @param mixed  $entityMap
+	 *
+	 * @throws MappingException
+	 *
+	 * @return Mapper
+	 */
+	protected function buildMapper($entity, $entityMap)
+	{
+		// If an EntityMap hasn't been manually registered by the user
+		// register it at runtime.
+		if (!$this->isRegisteredEntity($entity)) {
+			$this->register($entity, $entityMap);
+		}
+
+		$entityMap = $this->entityClasses[$entity];
+
+		$factory = new MapperFactory($this->drivers, $this->eventDispatcher, $this);
+
+		$mapper = $factory->make($entity, $entityMap);
+
+		$this->mappers[$entity] = $mapper;
+
+		// At this point we can safely call the boot() method on the entityMap as
+		// the mapper is now instantiated & registered within the manager.
+
+		if (!$entityMap->isBooted()) {
+			$entityMap->boot();
+		}
+
+		// If a cache is defined, use it to store the entityMap
+		if ($this->cache !== null && !$this->cache->has($entityMap->getClass()) && !$this->isAnonymous($entityMap)) {
+			$this->cache->set($entityMap->getClass(), serialize($entityMap), 1440);
+		}
+
+		return $mapper;
+	}
+
+	/**
+	 * Check if an Object is an anonymous class instance.
+	 *
+	 * @param mixed $class
+	 *
+	 * @return bool
+	 */
+	protected function isAnonymous($class) : bool
+	{
+		$instance = new ReflectionClass($class);
+
+		return $instance->isAnonymous();
+	}
+
+	/**
+	 * Check if the entity is already registered.
+	 *
+	 * @param string|Entity $entity
+	 *
+	 * @return bool
+	 */
+	public function isRegisteredEntity($entity)
+	{
+		if (!is_string($entity)) {
+			$entity = get_class($entity);
+		}
+
+		return array_key_exists($entity, $this->entityClasses);
+	}
+
+	/**
+	 * Return an array containing registered entities & entityMap instances.
+	 *
+	 * @return array
+	 */
+	public function getRegisteredEntities()
+	{
+		return $this->entityClasses;
+	}
+
+	/**
+	 * Check if a value class is already registered.
+	 *
+	 * @param string|\stdClass $object
+	 *
+	 * @return bool
+	 */
+	public function isRegisteredValueObject($object)
+	{
+		if (!is_string($object)) {
+			$object = get_class($object);
+		}
+
+		return array_key_exists($object, $this->valueClasses);
+	}
+
+	/**
+	 * Return true if an object is an array or iterator.
+	 *
+	 * @param mixed $argument
+	 *
+	 * @return bool
+	 */
+	public function isTraversable($argument)
+	{
+		return $argument instanceof \Traversable || is_array($argument);
+	}
+
+	/**
+	 * Set strict mode for entityMap instantiation.
+	 *
+	 * @param bool $mode
+	 */
+	public function setStrictMode($mode)
+	{
+		$this->strictMode = $mode;
+	}
+
+	/**
+	 * Define a generated proxy class path.
+	 *
+	 * @param string $path
+	 */
+	public function setProxyPath(string $path)
+	{
+		$this->proxyPath = $path;
+	}
+
+	/**
+	 * Return proxy path if defined.
+	 *
+	 * @return string|null
+	 */
+	public function getProxyPath()
+	{
+		return $this->proxyPath;
+	}
+
+	/**
+	 * Register a namespace in where Analogue
+	 * will scan for EntityMaps & ValueMaps.
+	 *
+	 * @param string $namespace
+	 *
+	 * @return void
+	 */
+	public function registerMapNamespace($namespace)
+	{
+		// Add a trailing antislash to namespace if not present
+		if (substr('testers', -1) != '\\') {
+			$namespace = $namespace.'\\';
+		}
+
+		$this->customMapNamespaces[] = $namespace;
+	}
+
+	/**
+	 * Register an entity.
+	 *
+	 * @param string|\Analogue\ORM\Mappable $entity    entity's class name
+	 * @param string|EntityMap              $entityMap map's class name
+	 *
+	 * @throws MappingException
+	 *
+	 * @return void
+	 */
+	public function register($entity, $entityMap = null)
+	{
+		// If an object is provider, get the class name from it
+		if (!is_string($entity)) {
+			$entity = get_class($entity);
+		}
+
+		if ($this->isRegisteredEntity($entity)) {
+			throw new MappingException("Entity $entity is already registered.");
+		}
+
+		if (!class_exists($entity)) {
+			throw new MappingException("Class $entity does not exists");
+		}
+
+		if ($entityMap === null) {
+			$entityMap = $this->getEntityMapInstanceFor($entity);
+		}
+
+		if (is_string($entityMap)) {
+			$entityMap = new $entityMap();
+		}
+
+		if (!$entityMap instanceof EntityMap) {
+			throw new MappingException(get_class($entityMap).' must be an instance of EntityMap.');
+		}
+
+		$entityMap->setClass($entity);
+
+		$this->entityClasses[$entity] = $entityMap;
+	}
+
+	/**
+	 * Get the entity map instance for a custom entity.
+	 *
+	 * @param string $entity
+	 *
+	 * @return \Analogue\ORM\EntityMap
+	 */
+	protected function getEntityMapInstanceFor($entity)
+	{
+		// First, we'll try to load the entity map from cache, to
+		// save from time consuming parsing of the relationships
+		$entityMap = $this->getEntityMapInstanceFromCache($entity);
+
+		if ($entityMap !== null) {
+			return $entityMap;
+		}
+
+		if (class_exists($entity.'Map')) {
+			$map = $entity.'Map';
+			$map = new $map();
+
+			return $map;
+		}
+
+		if ($map = $this->getMapFromNamespaces($entity)) {
+			return $map;
+		}
+
+		if ($this->strictMode) {
+			throw new EntityMapNotFoundException("No Map registered for $entity");
+		}
+
+		$map = $this->getNewEntityMap();
+
+		return $map;
+	}
+
+	/**
+	 * Get Entity Map instance from cache.
+	 *
+	 * @param string $entityClass
+	 *
+	 * @return EntityMap|null
+	 */
+	protected function getEntityMapInstanceFromCache(string $entityClass)
+	{
+		if ($this->cache == null) {
+			return;
+		}
+
+		if ($this->cache->has($entityClass)) {
+			return unserialize($this->cache->get($entityClass));
+		}
+	}
+
+	/**
+	 * Scan through registered custom namespace
+	 * for an Entity/ValueMap.
+	 *
+	 * @param string $class
+	 *
+	 * @return ValueMap|EntityMap|bool
+	 */
+	protected function getMapFromNamespaces($class)
+	{
+		foreach ($this->customMapNamespaces as $namespace) {
+			if ($map = $this->findMapInNamespace($class, $namespace)) {
+				return $map;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Look in a custom namespace for an Entity/ValueMap.
+	 *
+	 * @param string $class
+	 * @param string $namespace
+	 *
+	 * @return ValueMap|EntityMap|bool
+	 */
+	protected function findMapInNamespace($class, $namespace)
+	{
+		$parts = explode('\\', $class);
+
+		$baseClass = $parts[count($parts) - 1];
+
+		$expectedClass = $namespace.$baseClass.'Map';
+
+		if (class_exists($expectedClass)) {
+			return new $expectedClass();
+		}
+
+		return false;
+	}
+
+	/**
+	 * Dynamically create an entity map for a custom entity class.
+	 *
+	 * @return EntityMap
+	 */
+	protected function getNewEntityMap()
+	{
+		return new EntityMap();
+	}
+
+	/**
+	 * Return the Singleton instance of the manager.
+	 *
+	 * @return Manager
+	 */
+	public static function getInstance()
+	{
+		return static::$instance;
+	}
+
+	/**
+	 * Return the Driver Manager's instance.
+	 *
+	 * @return \Analogue\ORM\Drivers\Manager
+	 */
+	public function getDriverManager()
+	{
+		return $this->drivers;
+	}
+
+	/**
+	 * Get the Repository instance for the given Entity.
+	 *
+	 * @param \Analogue\ORM\Mappable|string $entity
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\Repository
+	 */
+	public function repository($entity)
+	{
+		if (!is_string($entity)) {
+			$entity = get_class($entity);
+		}
+
+		// First we check if the repository is not already created.
+		if (array_key_exists($entity, $this->repositories)) {
+			return $this->repositories[$entity];
+		}
+
+		$this->repositories[$entity] = new Repository($this->mapper($entity));
+
+		return $this->repositories[$entity];
+	}
+
+	/**
+	 * Return true is the object is registered as value object.
+	 *
+	 * @param mixed $object
+	 *
+	 * @return bool
+	 */
+	public function isValueObject($object)
+	{
+		if (!is_string($object)) {
+			$object = get_class($object);
+		}
+
+		return array_key_exists($object, $this->valueClasses);
+	}
+
+	/**
+	 * Get the Value Map for a given Value Object Class.
+	 *
+	 * @param string $valueObject
+	 *
+	 * @throws MappingException
+	 *
+	 * @return \Analogue\ORM\ValueMap
+	 */
+	public function getValueMap($valueObject)
+	{
+		if (!is_string($valueObject)) {
+			$valueObject = get_class($valueObject);
+		}
+
+		if (!array_key_exists($valueObject, $this->valueClasses)) {
+			$this->registerValueObject($valueObject);
+		}
+
+		/** @var ValueMap $valueMap */
+		$valueMap = new $this->valueClasses[$valueObject]();
+
+		$valueMap->setClass($valueObject);
+
+		return $valueMap;
+	}
+
+	/**
+	 * Register a Value Object.
+	 *
+	 * @param string $valueObject
+	 * @param string $valueMap
+	 *
+	 * @throws MappingException
+	 *
+	 * @return void
+	 */
+	public function registerValueObject($valueObject, $valueMap = null)
+	{
+		if (!is_string($valueObject)) {
+			$valueObject = get_class($valueObject);
+		}
+
+		if ($valueMap === null) {
+
+			// First, we'll look into registered namespaces for Entity Maps,
+			// if any. Then we'll fallback to the same namespace of the object
+			if (!$valueMap = $this->getMapFromNamespaces($valueObject)) {
+				$valueMap = $valueObject.'Map';
+			} else {
+				$valueMap = get_class($valueMap);
+			}
+		}
+
+		if (!class_exists($valueMap)) {
+			throw new MappingException("$valueMap doesn't exists");
+		}
+
+		$this->valueClasses[$valueObject] = $valueMap;
+	}
+
+	/**
+	 * Instantiate a new Value Object instance.
+	 *
+	 * @param string $valueObject
+	 *
+	 * @return \Analogue\ORM\ValueObject
+	 */
+	public function getValueObjectInstance($valueObject)
+	{
+		$prototype = unserialize(sprintf('O:%d:"%s":0:{}', strlen($valueObject), $valueObject));
+
+		return $prototype;
+	}
+
+	/**
+	 * Set an application cache.
+	 *
+	 * @param \Psr\SimpleCache\CacheInterface $cache
+	 */
+	public function setCache(CacheInterface $cache)
+	{
+		$this->cache = $cache;
+	}
+
+	/**
+	 * Register Analogue Plugin.
+	 *
+	 * @param string $plugin class
+	 *
+	 * @return void
+	 */
+	public function registerPlugin($plugin)
+	{
+		/** @var AnaloguePluginInterface $plugin */
+		$plugin = new $plugin($this);
+
+		$this->events = array_merge($this->events, $plugin->getCustomEvents());
+
+		$plugin->register();
+	}
+
+	/**
+	 * Register event listeners that will be fired regardless the type
+	 * of the entity.
+	 *
+	 * @param string   $event
+	 * @param \Closure $callback
+	 *
+	 * @throws \LogicException
+	 *
+	 * @return void
+	 */
+	public function registerGlobalEvent($event, $callback)
+	{
+		if (!array_key_exists($event, $this->events)) {
+			throw new \LogicException("Analogue : Event $event doesn't exist");
+		}
+
+		$this->eventDispatcher->listen("analogue.{$event}.*", $callback);
+		//$this->eventDispatcher->listen($this->events[$event], $callback);
+	}
+
+	/**
+	 * Shortcut to Mapper store.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return mixed
+	 */
+	public function store($entity)
+	{
+		return $this->mapper($entity)->store($entity);
+	}
+
+	/**
+	 * Shortcut to Mapper delete.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return \Traversable|array
+	 */
+	public function delete($entity)
+	{
+		return $this->mapper($entity)->delete($entity);
+	}
+
+	/**
+	 * Shortcut to Mapper query.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return Query
+	 */
+	public function query($entity)
+	{
+		return $this->mapper($entity)->query();
+	}
+
+	/**
+	 * Shortcut to Mapper Global Query.
+	 *
+	 * @param mixed $entity
+	 *
+	 * @throws MappingException
+	 * @throws \InvalidArgumentException
+	 *
+	 * @return Query
+	 */
+	public function globalQuery($entity)
+	{
+		return $this->mapper($entity)->globalQuery();
+	}
+
+	/**
+	 * @param array $morphMap
+	 *
+	 * @return $this
+	 */
+	public function morphMap(array $morphMap)
+	{
+		$this->morphMap = $morphMap;
+
+		return $this;
+	}
+
+	/**
+	 * @param string $class
+	 *
+	 * @return mixed
+	 */
+	public function getMorphMap($class)
+	{
+		$key = array_search($class, $this->morphMap, false);
+
+		return $key !== false ? $key : $class;
+	}
+
+	/**
+	 * Clear all the cached entities within all mappers.
+	 *
+	 * @return void
+	 */
+	public function clearCache()
+	{
+		array_map(function ($mapper) {
+			$mapper->clearCache();
+		}, $this->mappers);
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -810,7 +810,7 @@
      */
     public function clearCache()
     {
-        array_map(function ($mapper) {
+        array_map(function($mapper) {
             $mapper->clearCache();
         }, $this->mappers);
     }

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/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/Plugins/SoftDeletes/Restore.php

Indentation +23 added lines, -23 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();
+	/**
+	 * @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;
-        }
+		if ($mapper->fireEvent('restoring', $entity) === false) {
+			return false;
+		}
 
-        $keyName = $entityMap->getKeyName();
+		$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/Exceptions/EntityNotFoundException.php

Indentation +28 added lines, -28 removed lines

@@ -6,36 +6,36 @@
 
 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;
+	}
 }