ManyToMany::addAggregate() - Code Metrics - Inspection of "Added support for deep entity creation using $mapp..." - siriusphp/orm - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — dev_2x ( 241dab...1e248d )

by Adrian

created 2020-11-29 17:17 UTC

ManyToMany::addAggregate() A

↳ Parent: ManyToMany

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	2
c	0
b	0
f	0
dl	0
loc	5
rs	10
cc	1
nc	1
nop	2

<?php
declare(strict_types=1);

namespace Sirius\Orm\Blueprint\Relation;

use Sirius\Orm\Blueprint\Mapper;
use Sirius\Orm\Blueprint\Relation;
use Sirius\Orm\Helpers\Inflector;
use Sirius\Orm\Relation\RelationConfig;

class ManyToMany extends Relation
{
    protected $type = RelationConfig::TYPE_MANY_TO_MANY;

    protected $foreignKey = 'id';

    protected $throughTable;

    protected $throughTableAlias;

    protected $throughGuards = [];

    protected $throughColumns = [];

    protected $throughNativeColumn = '';

    protected $throughForeignColumn = '';

    protected $aggregates = [];

    public function setMapper(Mapper $mapper): Relation
    {
        $this->nativeKey = $mapper->getPrimaryKey();
        parent::setMapper($mapper);
        $this->maybeSetAdditionalProperties();

        return $this;
    }

    public function setForeignMapper($foreignMapper): Relation
    {
        parent::setForeignMapper($foreignMapper);
        $this->maybeSetAdditionalProperties();

        return $this;
    }

    public function getObservers(): array
    {
        $observer = $this->getObserver()->with($this);
        $observer = $this->getObserver()->/** @scrutinizer ignore-call */ with($this);

        return [
            $this->getMapper()->getName() . '_base_entity'        => [$observer],
            $this->getForeignMapper() . '_base_entity' => [$observer]
        ];
    }

    protected function maybeSetAdditionalProperties()
    {
        if ( ! $this->mapper || ! $this->foreignMapper) {
            return;
        }

        if ( ! $this->throughTable) {
            $tablePrefix = $this->mapper->getTableAlias() ?
                str_replace($this->mapper->getTable(), '', $this->mapper->getTableAlias())
                : '';

            $tables = [$this->mapper->getTableAlias() ?: $this->mapper->getTable(), $this->foreignMapper];
            sort($tables);

            $this->throughTable = $tablePrefix . implode('_', $tables);

            if ($tablePrefix) {
                $this->throughTableAlias = implode('_', $tables);
            }
        }

        if ( ! $this->throughNativeColumn) {
            $this->throughNativeColumn = Inflector::singularize($this->mapper->getName()) . '_id';
        }

        if ( ! $this->throughForeignColumn) {
            $this->throughForeignColumn = Inflector::singularize($this->foreignMapper) . '_id';
        }
    }

    public function addAggregate($name, $aggregate)
    {
        $this->aggregates[$name] = $aggregate;

        return $this;
    }

    /**
     * @return mixed
     */
    public function getThroughTable()
    {
        return $this->throughTable;
    }

    /**
     * @param mixed $throughTable
     *
     * @return ManyToMany
     */
    public function setThroughTable(string $throughTable)
    {
        $this->throughTable = $throughTable;

        return $this;
    }

    /**
     * @return mixed
     */
    public function getThroughTableAlias()
    {
        return $this->throughTableAlias;
    }

    /**
     * @param mixed $throughTableAlias
     *
     * @return ManyToMany
     */
    public function setThroughTableAlias($throughTableAlias)
    {
        $this->throughTableAlias = $throughTableAlias;

        return $this;
    }

    /**
     * @return array
     */
    public function getThroughGuards(): array
    {
        return $this->throughGuards;
    }

    /**
     * @param array $throughGuards
     *
     * @return ManyToMany
     */
    public function setThroughGuards(array $throughGuards): ManyToMany
    {
        $this->throughGuards = $throughGuards;

        return $this;
    }

    /**
     * @return array
     */
    public function getThroughColumns(): array
    {
        return $this->throughColumns;
    }

    /**
     * Pairs of column name (from table) and attribute name (in the linked model)
     *
     * @param array $throughColumns
     *
     * @return ManyToMany
     */
    public function setThroughColumns(array $throughColumns): ManyToMany
    {
        $this->throughColumns = $throughColumns;

        $this->maybeSetAdditionalProperties();

        return $this;
    }

    /**
     * @return string
     */
    public function getThroughNativeColumn(): string
    {
        return $this->throughNativeColumn;
    }

    /**
     * @param string $throughNativeColumn
     *
     * @return ManyToMany
     */
    public function setThroughNativeColumn(string $throughNativeColumn): ManyToMany
    {
        $this->throughNativeColumn = $throughNativeColumn;

        return $this;
    }

    /**
     * @return string
     */
    public function getThroughForeignColumn(): string
    {
        return $this->throughForeignColumn;
    }

    /**
     * @param string $throughForeignColumn
     *
     * @return ManyToMany
     */
    public function setThroughForeignColumn(string $throughForeignColumn): ManyToMany
    {
        $this->throughForeignColumn = $throughForeignColumn;

        return $this;
    }


}


siriusphp / orm

Push — dev_2x ( 241dab...1e248d )

ManyToMany::addAggregate() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like