Cycle\ORM\Relation\Traits\HasSomeTrait

Complexity

Total Complexity

7

Size/Duplication

Total Lines	32
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	deleteChild()	0	16	5
A	applyChanges()	0	4	2

<?php

declare(strict_types=1);

namespace Cycle\ORM\Relation\Traits;

use Cycle\ORM\Transaction\Pool;
use Cycle\ORM\Transaction\Tuple;

/**
 * @internal
 */
trait HasSomeTrait
{
    /**
     * Delete original related entity of no other objects reference to it.
     */
    protected function deleteChild(Pool $pool, Tuple $tuple, object $child): Tuple
    {
        if ($this->isNullable()) {

It seems like isNullable() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $rTuple = $pool->attachStore($child, false);
            $relName = $this->getTargetRelationName();

It seems like getTargetRelationName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            // Related state
            $state = $rTuple->state;
            if (!$state->hasRelation($relName) || $state->getRelation($relName) === $tuple->entity) {
                foreach ($this->outerKeys as $outerKey) {
                    $state->register($outerKey, null);
                }
                $state->setRelation($relName, null);
            }
            return $rTuple;
        }
        return $pool->attachDelete($child, $this->isCascade());

It seems like isCascade() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Apply inner key values to related entity
     *
     * @param Tuple $tuple Related tuple
     */
    protected function applyChanges(Tuple $parentTuple, Tuple $tuple): void
    {
        foreach ($this->innerKeys as $i => $innerKey) {
            $tuple->state->register($this->outerKeys[$i], $parentTuple->state->getValue($innerKey));
        }
    }
}