LaravelDoctrine\Fluent\Builders\Builder

Complexity

Total Complexity

25

Size/Duplication

Total Lines	225
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	13

Test Coverage

Coverage

100%

Importance

Changes	26
Bugs	0	Features	9

14 Methods

Rating	Name	Duplication	Size	Complexity
A	table()	0	20	4
A	entity()	0	14	3
A	inheritance()	0	10	2
A	singleTableInheritance()	0	4	1
A	joinedTableInheritance()	0	4	1
A	index()	0	7	2
A	primary()	0	7	2
A	unique()	0	7	2
A	constraint()	0	8	1
A	embed()	0	13	1
A	override()	0	13	1
A	events()	0	8	1
A	isEmbeddedClass()	0	4	1
A	__call()	0	13	3

<?php

namespace LaravelDoctrine\Fluent\Builders;

use InvalidArgumentException;
use LaravelDoctrine\Fluent\Builders\Inheritance\Inheritance;
use LaravelDoctrine\Fluent\Builders\Inheritance\InheritanceFactory;
use LaravelDoctrine\Fluent\Builders\Overrides\Override;
use LaravelDoctrine\Fluent\Builders\Traits\Fields;
use LaravelDoctrine\Fluent\Builders\Traits\Macroable;
use LaravelDoctrine\Fluent\Builders\Traits\Queueable;
use LaravelDoctrine\Fluent\Builders\Traits\Relations;
use LaravelDoctrine\Fluent\Fluent;
use LogicException;

/**
 * @method $this array($name, callable $callback = null)
 */
class Builder extends AbstractBuilder implements Fluent
{
    use Fields, Relations, Macroable, Queueable;

    /**
     * @param string|callable $name
     * @param callable|null   $callback
     *
     * @return Table
     */
    public function table($name, callable $callback = null)
    {
        if ($this->isEmbeddedClass()) {
            throw new LogicException();
        }

        $table = new Table($this->builder);

        if (is_callable($name)) {
            $name($table);
        } else {
            $table->setName($name);
        }

        if (is_callable($callback)) {
            $callback($table);
        }

        return $table;
    }

    /**
     * @param callable|null $callback
     *
     * @return Entity
     */
    public function entity(callable $callback = null)
    {
        if ($this->isEmbeddedClass()) {
            throw new LogicException();
        }

        $entity = new Entity($this->builder, $this->namingStrategy);

        if (is_callable($callback)) {
            $callback($entity);
        }

        return $entity;
    }

    /**
     * @param string        $type
     * @param callable|null $callback
     *
     * @return Inheritance
     */
    public function inheritance($type, callable $callback = null)
    {
        $inheritance = InheritanceFactory::create($type, $this->builder);

        if (is_callable($callback)) {
            $callback($inheritance);
        }

        return $inheritance;
    }

    /**
     * @param callable|null $callback
     *
     * @return Inheritance
     */
    public function singleTableInheritance(callable $callback = null)
    {
        return $this->inheritance(Inheritance::SINGLE, $callback);
    }

    /**
     * @param callable|null $callback
     *
     * @return Inheritance
     */
    public function joinedTableInheritance(callable $callback = null)
    {
        return $this->inheritance(Inheritance::JOINED, $callback);
    }

    /**
     * @param array|string $columns
     *
     * @return Index
     */
    public function index($columns)
    {
        return $this->constraint(

The expression $this->constraint(\LaravelDoctrine\Fluent\Builders\Index::class, is_array($columns) ? $columns : func_get_args()); of type LaravelDoctrine\Fluent\Builders\Index|LaravelDoctrine\Fluent\Builders\Primary adds the type LaravelDoctrine\Fluent\Builders\Primary to the return on line 114 which is incompatible with the return type declared by the interface LaravelDoctrine\Fluent\Fluent::index of type LaravelDoctrine\Fluent\Builders\Index.

            Index::class,
            is_array($columns) ? $columns : func_get_args()
        );
    }

    /**
     * @param array|string $fields
     *
     * @return Primary
     */
    public function primary($fields)
    {
        return $this->constraint(

The expression $this->constraint(\LaravelDoctrine\Fluent\Builders\Primary::class, is_array($fields) ? $fields : func_get_args()); of type LaravelDoctrine\Fluent\Builders\Index|LaravelDoctrine\Fluent\Builders\Primary adds the type LaravelDoctrine\Fluent\Builders\Index to the return on line 127 which is incompatible with the return type declared by the interface LaravelDoctrine\Fluent\Fluent::primary of type LaravelDoctrine\Fluent\Builders\Primary.

            Primary::class,
            is_array($fields) ? $fields : func_get_args()
        );
    }

    /**
     * @param array|string $columns
     *
     * @return UniqueConstraint
     */
    public function unique($columns)
    {
        return $this->constraint(

The expression $this->constraint(\LaravelDoctrine\Fluent\Builders\UniqueConstraint::class, is_array($columns) ? $columns : func_get_args()); of type LaravelDoctrine\Fluent\Builders\Index|LaravelDoctrine\Fluent\Builders\Primary adds the type LaravelDoctrine\Fluent\Builders\Primary to the return on line 140 which is incompatible with the return type declared by the interface LaravelDoctrine\Fluent\Fluent::unique of type LaravelDoctrine\Fluent\Builders\UniqueConstraint.

            UniqueConstraint::class,
            is_array($columns) ? $columns : func_get_args()
        );
    }

    /**
     * @param string $class
     * @param array  $columns
     *
     * @return Index|Primary|UniqueConstraint
     */
    protected function constraint($class, array $columns)
    {
        $constraint = new $class($this->builder, $columns);

        $this->queue($constraint);

        return $constraint;
    }

    /**
     * @param string        $embeddable
     * @param string|null   $field
     * @param callable|null $callback
     *
     * @return Embedded
     */
    public function embed($embeddable, $field = null, callable $callback = null)
    {
        $embedded = new Embedded(
            $this->builder,
            $this->namingStrategy,
            $this->guessSingularField($embeddable, $field),
            $embeddable
        );

        $this->callbackAndQueue($embedded, $callback);

        return $embedded;
    }

    /**
     * @param string   $name
     * @param callable $callback
     *
     * @return Override
     */
    public function override($name, callable $callback)
    {
        $override = new Override(
            $this->getBuilder(),
            $this->getNamingStrategy(),
            $name,
            $callback
        );

        $this->queue($override);

        return $override;
    }

    /**
     * @param callable|null $callback
     *
     * @return LifecycleEvents
     */
    public function events(callable $callback = null)
    {
        $events = new LifecycleEvents($this->builder);

        $this->callbackAndQueue($events, $callback);

        return $events;
    }

    /**
     * @return bool
     */
    public function isEmbeddedClass()
    {
        return $this->builder->getClassMetadata()->isEmbeddedClass;
    }

    /**
     * @param string $method
     * @param array  $params
     *
     * @return mixed
     */
    public function __call($method, $params)
    {
        // Workaround for reserved keywords
        if ($method === 'array') {
            return call_user_func_array([$this, 'setArray'], $params);
        }

        if ($this->hasMacro($method)) {
            return $this->callMacro($method, $params);
        }

        throw new InvalidArgumentException('Fluent builder method [' . $method . '] does not exist');
    }
}