Analogue\ORM\System\Manager

Complexity

Total Complexity

56

Size/Duplication

Total Lines	553
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	9

Importance

Changes	29
Bugs	6	Features	8

27 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	getMapper()	0	4	1
A	mapper()	0	17	3
B	resolveEntityClass()	0	26	6
A	getInverseMorphMap()	0	4	2
A	buildMapper()	0	23	2
A	isRegisteredEntity()	0	8	2
A	isTraversable()	0	4	2
A	setStrictMode()	0	4	1
A	getEntityMapInstanceFor()	0	14	3
A	getNewEntityMap()	0	4	1
A	getInstance()	0	4	1
A	getDriverManager()	0	4	1
A	repository()	0	15	3
A	isValueObject()	0	8	2
A	registerPlugin()	0	9	1
A	registerGlobalEvent()	0	8	2
A	store()	0	4	1
A	delete()	0	4	1
A	query()	0	4	1
A	globalQuery()	0	4	1
A	morphMap()	0	6	1
A	getMorphMap()	0	6	2
C	register()	0	33	7
A	getValueMap()	0	17	3
A	registerValueObject()	0	16	4
A	getValueObjectInstance()	0	6	1

<?php

namespace Analogue\ORM\System;

use Analogue\ORM\Entity;
use Analogue\ORM\Plugins\AnaloguePluginInterface;
use Analogue\ORM\ValueMap;
use Exception;
use Analogue\ORM\EntityMap;
use Analogue\ORM\Repository;
use Illuminate\Support\Collection;
use Analogue\ORM\System\Wrappers\Wrapper;
use Illuminate\Contracts\Events\Dispatcher;
use Analogue\ORM\Exceptions\MappingException;
use Analogue\ORM\Drivers\Manager as DriverManager;
use Analogue\ORM\Exceptions\EntityMapNotFoundException;

/**
 * This class is the entry point for registering Entities and
 * instansiating Mappers
 */
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;

    /**
     * Available Analogue Events
     *
     * @var array
     */
    protected $events = [
        'initializing',
        'initialized',
        'store',
        'stored',
        'creating',
        'created',
        'updating',
        'updated',
        'deleting',
        'deleted',
    ];

    /**
     * If strictMode is set to true, Manager will throw
     * an exception if no entityMap class are registered
     * for a given entity class.
     * 
     * @var boolean
     */
    protected $strictMode = true;

    /**
     * @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
     * @throws \InvalidArgumentException
     */
    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
     *
     * @throws \InvalidArgumentException
     */
    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         $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|Entity $entity
     * @return boolean
     */
    public function isRegisteredEntity($entity)
    {
        if (!is_string($entity)) {
            $entity = get_class($entity);
        }

        return array_key_exists($entity, $this->entityClasses);
    }

    /**
     * Return true if an object is an array or iterator
     *
     * @param  mixed $argument
     * @return boolean
     */
    public function isTraversable($argument)
    {
        return $argument instanceof \Traversable || is_array($argument);
    }

    /**
     * Set strict mode for entityMap instantiation
     * 
     * @param boolean $mode
     */
    public function setStrictMode($mode)
    {
        $this->strictMode = $mode;
    }

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

        $entityMap->setManager($this);

        $this->entityClasses[$entity] = $entityMap;
    }

    /**
     * Get the entity map instance for a custom entity
     *
     * @param  string $entity
     * @return \Analogue\ORM\Mappable
     * @throws EntityMapNotFoundException
     */
    protected function getEntityMapInstanceFor($entity)
    {
        if (class_exists($entity . 'Map')) {
            $map = $entity . 'Map';
            $map = new $map;
        } else {
            if ($this->strictMode) {
                throw new EntityMapNotFoundException("No EntityMap registered for $entity");
            }
            $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);
        }

        /** @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) {
            $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)
    {
        /** @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 (!in_array($event, $this->events, false)) {
            throw new \LogicException("Analogue : Event $event doesn't exist");
        }

        $this->eventDispatcher->listen("analogue.{$event}.*", $callback);
    }

    /**
     * Shortcut to Mapper store
     *
     * @param  mixed $entity
     * @throws MappingException
     * @return mixed
     * @throws \InvalidArgumentException
     */
    public function store($entity)
    {
        return $this->mapper($entity)->store($entity);
    }

    /**
     * Shortcut to Mapper delete
     *
     * @param  mixed $entity
     * @throws MappingException
     * @return \Illuminate\Support\Collection|null
     * @throws \InvalidArgumentException
     */
    public function delete($entity)
    {
        return $this->mapper($entity)->delete($entity);
    }

    /**
     * Shortcut to Mapper query
     *
     * @param  mixed $entity
     * @throws MappingException
     * @return Query
     * @throws \InvalidArgumentException
     */
    public function query($entity)
    {
        return $this->mapper($entity)->query();
    }

    /**
     * Shortcut to Mapper Global Query
     *
     * @param  mixed $entity
     * @throws MappingException
     * @return Query
     * @throws \InvalidArgumentException
     */
    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;
    }
}