LaravelDoctrine\Fluent\Relations\AbstractRelation

Complexity

Total Complexity

13

Size/Duplication

Total Lines	167
Duplicated Lines	15.57 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	5
Bugs	0	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
	createAssociation()	0	1	?
A	getBuilder()	0	4	1
A	getAssociation()	0	4	1
A	getNamingStrategy()	0	4	1
A	__construct()	0	8	1
A	cascade()	14	14	3
A	fetch()	12	12	2
A	cache()	0	13	1
A	build()	0	6	1
A	__call()	0	10	2

<?php

namespace LaravelDoctrine\Fluent\Relations;

use BadMethodCallException;
use Doctrine\ORM\Mapping\Builder\AssociationBuilder;
use Doctrine\ORM\Mapping\Builder\ClassMetadataBuilder;
use Doctrine\ORM\Mapping\NamingStrategy;
use InvalidArgumentException;
use LaravelDoctrine\Fluent\Builders\Traits\Queueable;

/**
 * @method $this orphanRemoval()
 * @method $this cascadeAll()
 * @method $this cascadePersist()
 * @method $this cascadeRemove()
 * @method $this cascadeMerge()
 * @method $this cascadeDetach()
 * @method $this cascadeRefresh()
 * @method $this fetchExtraLazy()
 * @method $this fetchEager()
 * @method $this fetchLazy()
 */
abstract class AbstractRelation implements Relation
{
    use Queueable {
        build as buildQueued;
    }

    /**
     * @var string
     */
    protected $relation;

    /**
     * @var string
     */
    protected $entity;

    /**
     * @var NamingStrategy
     */
    protected $namingStrategy;

    /**
     * @var ClassMetadataBuilder
     */
    protected $builder;

    /**
     * @var AssociationBuilder
     */
    protected $association;

    /**
     * @param ClassMetadataBuilder $builder
     * @param NamingStrategy       $namingStrategy
     * @param string               $relation
     * @param string               $entity
     */
    public function __construct(ClassMetadataBuilder $builder, NamingStrategy $namingStrategy, $relation, $entity)
    {
        $this->entity         = $entity;
        $this->builder        = $builder;
        $this->relation       = $relation;
        $this->namingStrategy = $namingStrategy;
        $this->association    = $this->createAssociation($builder, $relation, $entity);
    }

    /**
     * @param ClassMetadataBuilder $builder
     * @param string               $relation
     * @param string               $entity
     *
     * @return AssociationBuilder
     */
    abstract protected function createAssociation(ClassMetadataBuilder $builder, $relation, $entity);

    /**
     * @param string[] $cascade one of "persist", "remove", "merge", "detach", "refresh" or "ALL"
     *
     * @return $this
     */
    public function cascade(array $cascade)
    {
        foreach ($cascade as $name) {
            $method = 'cascade' . studly_case(strtolower($name));

            if (!method_exists($this->association, $method)) {
                throw new InvalidArgumentException('Cascade [' . $name . '] does not exist');
            }

            $this->{$method}();
        }

        return $this;
    }

    /**
     * @param string $strategy one of "LAZY", "EAGER", "EXTRA_LAZY"
     *
     * @return $this
     */
    public function fetch($strategy)
    {
        $method = 'fetch' . studly_case(strtolower($strategy));

        if (!method_exists($this->association, $method)) {
            throw new InvalidArgumentException('Fetch [' . $strategy . '] does not exist');
        }

        $this->{$method}();

        return $this;
    }

    /**
     * @return ClassMetadataBuilder
     */
    public function getBuilder()
    {
        return $this->builder;
    }

    /**
     * @return AssociationBuilder
     */
    public function getAssociation()
    {
        return $this->association;
    }

    /**
     * @param string      $usage
     * @param string|null $region
     *
     * @return AssociationBuilder
     */
    public function cache($usage = 'READ_ONLY', $region = null)
    {
        $cache = new AssociationCache(
            $this->builder->getClassMetadata(),
            $this->relation,
            $usage,
            $region
        );

        $this->queue($cache);

        return $this;
    }

    /**
     * Execute the build process for all queued buildables
     */
    public function build()
    {
        $this->getAssociation()->build();

        $this->buildQueued();
    }

    /**
     * Magic call method works as a proxy for the Doctrine associationBuilder
     *
     * @param string $method
     * @param array  $args
     *
     * @throws BadMethodCallException
     * @return $this
     */
    public function __call($method, $args)
    {
        if (method_exists($this->getAssociation(), $method)) {
            call_user_func_array([$this->getAssociation(), $method], $args);

            return $this;
        }

        throw new BadMethodCallException("Relation method [{$method}] does not exist.");
    }

    /**
     * @return NamingStrategy
     */
    public function getNamingStrategy()
    {
        return $this->namingStrategy;
    }
}