analogueorm / analogue

src/System/Manager.php

Doc Comments +3 added lines, -3 removed lines

@@ -117,7 +117,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
      * @return Mapper
@@ -215,7 +215,7 @@ 
     /**
      * Check if the entity is already registered
      *
-     * @param  string|object $entity
+     * @param  string $entity
      * @return boolean
      */
     public function isRegisteredEntity($entity)
@@ -230,7 +230,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
      * @return void

Indentation +504 added lines, -504 removed lines

@@ -15,508 +15,508 @@
  */
 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
-     */
-    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;
-
-    /**
-     * Available Analogue Events
-     *
-     * @var array
-     */
-    protected $events = [
-        'initializing',
-        'initialized',
-        'store',
-        'stored',
-        'creating',
-        'created',
-        'updating',
-        'updated',
-        'deleting',
-        'deleted',
-    ];
-
-    /**
-     * @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
-     * @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
-     * @return string
-     */
-    protected function resolveEntityClass($entity)
-    {
-        switch (true) {
-            case Support::isTraversable($entity):
-                if (!count($entity)) {
-                    throw new \InvalidArgumentException('Length of Entity collection must be greater than 0');
-                }
-
-                $firstEntityItem = ($entity instanceof \Iterator || $entity instanceof \IteratorAggregate)
-                    ? $entity->current()
-                    : current($entity);
-
-                return $this->resolveEntityClass($firstEntityItem);
-
-            case is_object($entity):
-                return get_class($entity);
-
-            case !is_string($entity):
-                throw new \InvalidArgumentException('Invalid mapper Entity type');
-                break;
-        }
-
-        return $entity;
-    }
-
-    /**
-     * @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         $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.
-
-        $mapper->getEntityMap()->boot();
-
-        return $mapper;
-    }
-
-    /**
-     * Check if the entity is already registered
-     *
-     * @param  string|object $entity
-     * @return boolean
-     */
-    public function isRegisteredEntity($entity)
-    {
-        if (!is_string($entity)) {
-            $entity = get_class($entity);
-        }
-
-        return array_key_exists($entity, $this->entityClasses);
-    }
-
-    /**
-     * 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 (is_null($entityMap)) {
-            $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);
-
-        $entityMap->setManager($this);
-
-        $this->entityClasses[$entity] = $entityMap;
-    }
-
-    /**
-     * Get the entity map instance for a custom entity
-     *
-     * @param  string $entity
-     * @return \Analogue\ORM\Mappable
-     */
-    protected function getEntityMapInstanceFor($entity)
-    {
-        if (class_exists($entity . 'Map')) {
-            $map = $entity . 'Map';
-            $map = new $map;
-        } else {
-            // Generate an EntityMap object
-            $map = $this->getNewEntityMap();
-        }
-
-        return $map;
-    }
-
-    /**
-     * 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 boolean
-     */
-    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);
-        }
-        $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 (is_null($valueMap)) {
-            $valueMap = $valueObject . 'Map';
-        }
-
-        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;
-    }
-
-    /**
-     * Register Analogue Plugin
-     *
-     * @param  string $plugin class
-     * @return void
-     */
-    public function registerPlugin($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 \Exception
-     * @return void
-     */
-    public function registerGlobalEvent($event, $callback)
-    {
-        if (!in_array($event, $this->events)) {
-            throw new \Exception("Analogue : Event $event doesn't exist");
-        }
-        $this->eventDispatcher->listen("analogue.{$event}.*", $callback);
-    }
-
-    /**
-     * Shortcut to Mapper store
-     *
-     * @param  mixed $entity
-     * @throws MappingException
-     * @return mixed
-     */
-    public function store($entity)
-    {
-        return $this->mapper($entity)->store($entity);
-    }
-
-    /**
-     * Shortcut to Mapper delete
-     *
-     * @param  mixed $entity
-     * @throws MappingException
-     * @return \Illuminate\Support\Collection|null
-     */
-    public function delete($entity)
-    {
-        return $this->mapper($entity)->delete($entity);
-    }
-
-    /**
-     * Shortcut to Mapper query
-     *
-     * @param  mixed $entity
-     * @throws MappingException
-     * @return Query
-     */
-    public function query($entity)
-    {
-        return $this->mapper($entity)->query();
-    }
-
-    /**
-     * Shortcut to Mapper Global Query
-     *
-     * @param  mixed $entity
-     * @throws MappingException
-     * @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);
-
-        return $key !== false ? $key : $class;
-    }
+	/**
+	 * 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
+	 */
+	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;
+
+	/**
+	 * Available Analogue Events
+	 *
+	 * @var array
+	 */
+	protected $events = [
+		'initializing',
+		'initialized',
+		'store',
+		'stored',
+		'creating',
+		'created',
+		'updating',
+		'updated',
+		'deleting',
+		'deleted',
+	];
+
+	/**
+	 * @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
+	 * @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
+	 * @return string
+	 */
+	protected function resolveEntityClass($entity)
+	{
+		switch (true) {
+			case Support::isTraversable($entity):
+				if (!count($entity)) {
+					throw new \InvalidArgumentException('Length of Entity collection must be greater than 0');
+				}
+
+				$firstEntityItem = ($entity instanceof \Iterator || $entity instanceof \IteratorAggregate)
+					? $entity->current()
+					: current($entity);
+
+				return $this->resolveEntityClass($firstEntityItem);
+
+			case is_object($entity):
+				return get_class($entity);
+
+			case !is_string($entity):
+				throw new \InvalidArgumentException('Invalid mapper Entity type');
+				break;
+		}
+
+		return $entity;
+	}
+
+	/**
+	 * @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         $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.
+
+		$mapper->getEntityMap()->boot();
+
+		return $mapper;
+	}
+
+	/**
+	 * Check if the entity is already registered
+	 *
+	 * @param  string|object $entity
+	 * @return boolean
+	 */
+	public function isRegisteredEntity($entity)
+	{
+		if (!is_string($entity)) {
+			$entity = get_class($entity);
+		}
+
+		return array_key_exists($entity, $this->entityClasses);
+	}
+
+	/**
+	 * 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 (is_null($entityMap)) {
+			$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);
+
+		$entityMap->setManager($this);
+
+		$this->entityClasses[$entity] = $entityMap;
+	}
+
+	/**
+	 * Get the entity map instance for a custom entity
+	 *
+	 * @param  string $entity
+	 * @return \Analogue\ORM\Mappable
+	 */
+	protected function getEntityMapInstanceFor($entity)
+	{
+		if (class_exists($entity . 'Map')) {
+			$map = $entity . 'Map';
+			$map = new $map;
+		} else {
+			// Generate an EntityMap object
+			$map = $this->getNewEntityMap();
+		}
+
+		return $map;
+	}
+
+	/**
+	 * 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 boolean
+	 */
+	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);
+		}
+		$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 (is_null($valueMap)) {
+			$valueMap = $valueObject . 'Map';
+		}
+
+		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;
+	}
+
+	/**
+	 * Register Analogue Plugin
+	 *
+	 * @param  string $plugin class
+	 * @return void
+	 */
+	public function registerPlugin($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 \Exception
+	 * @return void
+	 */
+	public function registerGlobalEvent($event, $callback)
+	{
+		if (!in_array($event, $this->events)) {
+			throw new \Exception("Analogue : Event $event doesn't exist");
+		}
+		$this->eventDispatcher->listen("analogue.{$event}.*", $callback);
+	}
+
+	/**
+	 * Shortcut to Mapper store
+	 *
+	 * @param  mixed $entity
+	 * @throws MappingException
+	 * @return mixed
+	 */
+	public function store($entity)
+	{
+		return $this->mapper($entity)->store($entity);
+	}
+
+	/**
+	 * Shortcut to Mapper delete
+	 *
+	 * @param  mixed $entity
+	 * @throws MappingException
+	 * @return \Illuminate\Support\Collection|null
+	 */
+	public function delete($entity)
+	{
+		return $this->mapper($entity)->delete($entity);
+	}
+
+	/**
+	 * Shortcut to Mapper query
+	 *
+	 * @param  mixed $entity
+	 * @throws MappingException
+	 * @return Query
+	 */
+	public function query($entity)
+	{
+		return $this->mapper($entity)->query();
+	}
+
+	/**
+	 * Shortcut to Mapper Global Query
+	 *
+	 * @param  mixed $entity
+	 * @throws MappingException
+	 * @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);
+
+		return $key !== false ? $key : $class;
+	}
 }

src/System/Mapper.php

Indentation +550 added lines, -550 removed lines

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

src/System/Support.php

Indentation +10 added lines, -10 removed lines

@@ -7,14 +7,14 @@
  */
 class Support
 {
-    /**
-     * Return true if an object is an array or iterator
-     *
-     * @param  mixed $argument
-     * @return boolean
-     */
-    public static function isTraversable($argument)
-    {
-        return $argument instanceof \Traversable || is_array($argument);
-    }
+	/**
+	 * Return true if an object is an array or iterator
+	 *
+	 * @param  mixed $argument
+	 * @return boolean
+	 */
+	public static function isTraversable($argument)
+	{
+		return $argument instanceof \Traversable || is_array($argument);
+	}
 }