ManyToMany::sortRelation() - Code Metrics - Inspection of "- code-style fixes" - cycle/orm - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 61bbc0...3efc91 )

by Anton
created 2021-02-12 12:24 UTC
ManyToMany::sortRelation() A

↳ Parent: ManyToMany
Complexity

Conditions	1
Paths	1
Size

Total Lines	7
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	3
nc	1
nop	2
dl	0
loc	7
rs	10
c	0
b	0
f	0
<?php

/**
 * Cycle DataMapper ORM
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

declare(strict_types=1);

namespace Cycle\ORM\Relation;

use Cycle\ORM\Command\Branch\Nil;
use Cycle\ORM\Command\Branch\Sequence;
use Cycle\ORM\Command\CommandInterface;
use Cycle\ORM\Command\ContextCarrierInterface as CC;
use Cycle\ORM\Heap\Node;
use Cycle\ORM\Heap\State;
use Cycle\ORM\Iterator;
use Cycle\ORM\ORMInterface;
use Cycle\ORM\Promise\Collection\CollectionPromiseInterface;
use Cycle\ORM\Promise\ReferenceInterface;
use Cycle\ORM\Relation;
use Cycle\ORM\Relation\Pivoted;
use Doctrine\Common\Collections\Collection;

class ManyToMany extends Relation\AbstractRelation
{

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

    /** @var string */
    protected $throughOuterKey;
    /** @var string|null */
    private $pivotEntity;

    /**
     * @param ORMInterface $orm
     * @param string       $name
     * @param string       $target
     * @param array        $schema
     */
    public function __construct(ORMInterface $orm, string $name, string $target, array $schema)
    {
        parent::__construct($orm, $name, $target, $schema);
        $this->pivotEntity = $this->schema[Relation::THROUGH_ENTITY] ?? null;
        $this->throughInnerKey = $this->schema[Relation::THROUGH_INNER_KEY] ?? null;
        $this->throughOuterKey = $this->schema[Relation::THROUGH_OUTER_KEY] ?? null;
    }

    /**
     * @inheritdoc
     */
    public function init(Node $node, array $data): array
    {
        $elements = [];
        $pivotData = new \SplObjectStorage();

        $iterator = new Iterator($this->orm, $this->target, $data);
        foreach ($iterator as $pivot => $entity) {
            if (!is_array($pivot)) {
                // skip partially selected entities (DB level filter)
                continue;
            }

            $pivotData[$entity] = $this->orm->make($this->pivotEntity, $pivot, Node::MANAGED);
            $pivotData[$entity] = $this->orm->make($this->pivotEntity, $pivot, Node::MANAGED);
            $elements[] = $entity;
        }

        return [
            new Pivoted\PivotedCollection($elements, $pivotData),
            new Pivoted\PivotedStorage($elements, $pivotData)
        ];
    }

    /**
     * @inheritdoc
     */
    public function extract($data)
    {
        if ($data instanceof CollectionPromiseInterface && !$data->isInitialized()) {
            return $data->getPromise();
        }

        if ($data instanceof Pivoted\PivotedCollectionInterface) {
            return new Pivoted\PivotedStorage($data->toArray(), $data->getPivotContext());
        }

        if ($data instanceof Collection) {
            return new Pivoted\PivotedStorage($data->toArray());
        }

        return new Pivoted\PivotedStorage();
    }

    /**
     * @inheritdoc
     */
    public function initPromise(Node $node): array
    {
        $innerKey = $this->fetchKey($node, $this->innerKey);
        if ($innerKey === null) {
            return [new Pivoted\PivotedCollection(), null];
        }

        // will take care of all the loading and scoping
        $p = new Pivoted\PivotedPromise(
            $this->orm,
            $this->target,
            $this->schema,
            $innerKey
        );

        return [new Pivoted\PivotedCollectionPromise($p), $p];
    }

    /**
     * @inheritdoc
     *
     * @param Pivoted\PivotedStorage $related
     * @param Pivoted\PivotedStorage $original
     */
    public function queue(CC $store, $entity, Node $node, $related, $original): CommandInterface
    {
        $original = $original ?? new Pivoted\PivotedStorage();

        if ($related instanceof ReferenceInterface) {

            $related = $this->resolve($related);
        }

        if ($original instanceof ReferenceInterface) {

            $original = $this->resolve($original);
        }

        $sequence = new Sequence();

        // link/sync new and existed elements
        foreach ($related->getElements() as $item) {
            $sequence->addCommand($this->link($node, $item, $related->get($item), $related));
        }

        // un-link old elements
        foreach ($original->getElements() as $item) {
            if (!$related->has($item)) {
                // todo: add support for nullable pivot entities
                $sequence->addCommand($this->orm->queueDelete($original->get($item)));
                $sequence->addCommand($this->orm->/** @scrutinizer ignore-call */ queueDelete($original->get($item)));
            }
        }

        return $sequence;
    }

    /**
     * Link two entities together and create/update pivot context.
     *
     * @param Node                   $node
     * @param object                 $related
     * @param object                 $pivot
     * @param Pivoted\PivotedStorage $storage
     * @return CommandInterface
     */
    protected function link(Node $node, $related, $pivot, Pivoted\PivotedStorage $storage): CommandInterface
    {
        $rStore = $this->orm->queueStore($related);
        $rStore = $this->orm->queueStore($related);
        $rNode = $this->getNode($related, +1);
        $this->assertValid($rNode);
        $this->assertValid(/** @scrutinizer ignore-type */ $rNode);

        if (!is_object($pivot)) {
            // first time initialization
            $pivot = $this->initPivot($node, $related, $pivot);
        }

        $pNode = $this->getNode($pivot);

        // defer the insert until pivot keys are resolved
        $pStore = $this->orm->queueStore($pivot);

        $this->forwardContext(
            $node,
            $this->innerKey,
            $pStore,
            $pNode,
            /** @scrutinizer ignore-type */ $pNode,
            $this->throughInnerKey
        );

        $this->forwardContext(
            $rNode,
            $this->outerKey,
            $pStore,
            $pNode,
            $this->throughOuterKey
        );

        $sequence = new Sequence();
        $sequence->addCommand($rStore);
        $sequence->addCommand($pStore);

        // update the link
        $storage->set($related, $pivot);

        return $sequence;
    }

    /**
     * Since many to many relation can overlap from two directions we have to properly resolve the pivot entity upon
     * it's generation. This is achieved using temporary mapping associated with each of the entity states.
     *
     * @param Node   $node
     * @param object $related
     * @param mixed  $pivot
     * @return mixed|object|null
     */
    protected function initPivot(Node $node, $related, $pivot)
    {
        [$source, $target] = $this->sortRelation($node, $this->getNode($related));
        [$source, $target] = $this->sortRelation($node, /** @scrutinizer ignore-type */ $this->getNode($related));

        if ($source->getState()->getStorage($this->pivotEntity)->contains($target)) {
            return $source->getState()->getStorage($this->pivotEntity)->offsetGet($target);
        }

        $entity = $this->orm->make($this->pivotEntity, $pivot ?? []);
        $entity = $this->orm->make(/** @scrutinizer ignore-type */ $this->pivotEntity, $pivot ?? []);

        $source->getState()->getStorage($this->pivotEntity)->offsetSet($target, $entity);

        return $entity;
    }

    /**
     * Keep only one relation branch as primary branch.
     *
     * @param Node $node
     * @param Node $related
     * @return array<Node, Node>
     */
    private function sortRelation(Node $node, Node $related): array
    {
        // always use single storage
        $list = [$node->getRole() => $node, $related->getRole() => $related];
        ksort($list);

        return array_values($list);
    }
}

cycle / orm

Push — master ( 61bbc0...3efc91 )

ManyToMany::sortRelation() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
