LaravelDoctrine\Fluent\FluentDriver

Complexity

Total Complexity

15

Size/Duplication

Total Lines	151
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getAllClassNames()	0	4	1
A	isTransient()	0	6	2
A	getFluent()	0	4	1
A	__construct()	0	9	1
A	loadMetadataForClass()	0	6	1
A	addMappings()	0	6	2
A	addMapping()	0	6	2
A	getMappers()	0	4	1
A	setFluentFactory()	0	4	1
A	createMapping()	0	14	3

<?php

namespace LaravelDoctrine\Fluent;

use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
use Doctrine\ORM\Mapping\Builder\ClassMetadataBuilder;
use Doctrine\ORM\Mapping\MappingException;
use InvalidArgumentException;
use LaravelDoctrine\Fluent\Builders\Builder;
use LaravelDoctrine\Fluent\Mappers\MapperSet;

class FluentDriver implements MappingDriver
{
    /**
     * @var MapperSet
     */
    protected $mappers;

    /**
     * @var callable
     */
    protected $fluentFactory;

    /**
     * Initializes a new FluentDriver that will load given Mapping classes / objects.
     *
     * @param string[]|Mapping[] $mappings
     */
    public function __construct(array $mappings = [])
    {
        $this->fluentFactory = function (ClassMetadata $metadata) {
            return new Builder(new ClassMetadataBuilder($metadata));
        };

        $this->mappers = new MapperSet();
        $this->addMappings($mappings);
    }

    /**
     * Loads the metadata for the specified class into the provided container.
     *
     * @param string        $className
     * @param ClassMetadata $metadata
     */
    public function loadMetadataForClass($className, ClassMetadata $metadata)
    {
        $this->mappers->getMapperFor($className)->map(
            $this->getFluent($metadata)
        );
    }

    /**
     * Gets the names of all mapped classes known to this driver.
     *
     * @throws MappingException
     *
     * @return string[] The names of all mapped classes known to this driver.
     */
    public function getAllClassNames()
    {
        return $this->mappers->getClassNames();
    }

    /**
     * Returns whether the class with the specified name should have its metadata loaded.
     * This is only the case if it is either mapped as an Entity or a MappedSuperclass.
     *
     * @param string $className
     *
     * @return bool
     */
    public function isTransient($className)
    {
        return
            !$this->mappers->hasMapperFor($className) ||
            $this->mappers->getMapperFor($className)->isTransient();
    }

    /**
     * Adds an array of mapping classes / objects to the driver.
     *
     * @param string[]|Mapping[] $mappings
     *
     * @throws MappingException
     * @throws InvalidArgumentException
     */
    public function addMappings(array $mappings = [])
    {
        foreach ($mappings as $mapping) {
            $this->addMapping($mapping);
        }
    }

    /**
     * @param string|Mapping $mapping
     *
     * @throws MappingException
     * @throws InvalidArgumentException
     *
     * @return void
     */
    public function addMapping($mapping)
    {
        $this->mappers->add($mapping instanceof Mapping ?
            $mapping : $this->createMapping($mapping)
        );
    }

    /**
     * @return MapperSet
     */
    public function getMappers()
    {
        return $this->mappers;
    }

    /**
     * Override the default Fluent factory method with a custom one.
     * Use this to implement your own Fluent builder.
     * The method will receive a ClassMetadata object as its only argument.
     *
     * @param callable $factory
     */
    public function setFluentFactory(callable $factory)
    {
        $this->fluentFactory = $factory;
    }

    /**
     * @param ClassMetadata $metadata
     *
     * @return Fluent
     */
    protected function getFluent(ClassMetadata $metadata)
    {
        return call_user_func($this->fluentFactory, $metadata);
    }

    /**
     * Create a mapping object from a mapping class, assuming an empty constructor.
     *
     * @param string $class
     *
     * @throws InvalidArgumentException
     *
     * @return Mapping
     */
    protected function createMapping($class)
    {
        if (!class_exists($class)) {
            throw new InvalidArgumentException("Mapping class [{$class}] does not exist");
        }

        $mapping = new $class();

        if (!$mapping instanceof Mapping) {
            throw new InvalidArgumentException("Mapping class [{$class}] should implement ".Mapping::class);
        }

        return $mapping;
    }
}