Loader::get() - Code Metrics - Inspection of "replication model trait refactoring" - zemit-cms/core - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — master ( a835f3...4c7cec )

by Julien
created 2023-04-03 04:50 UTC
Loader::get() A

↳ Parent: Loader
Complexity

Conditions	2
Paths	2
Size

Total Lines	5
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	6
Importance

Changes
Metric	Value
cc	2
eloc	3
c	0
b	0
f	0
nc	2
nop	0
dl	0
loc	5
ccs	0
cts	4
cp	0
crap	6
rs	10
<?php

/**
 * This file is part of the Zemit Framework.
 *
 * (c) Zemit Team <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE.txt
 * file that was distributed with this source code.
 */

namespace Zemit\Mvc\Model\EagerLoading;

use Phalcon\Di;
use Phalcon\Mvc\ModelInterface;
use Phalcon\Mvc\Model\Relation;
use Phalcon\Mvc\Model\Resultset\Simple;
use Zemit\Exception;

final class Loader
{
    protected ?array $subject;
    
    protected string $className;
    
    protected array $eagerLoads;
    
    protected bool $singleModel;
    
    protected array $options = [];
    
    /**
     * @param ModelInterface|ModelInterface[]|Simple $from
     * @param ...$arguments
     * @throws \InvalidArgumentException
     */
    public function __construct($from, array ...$arguments)
    {
        $error = false;
        $className = null;
        $this->singleModel = false;
        
        // Handle Model Interface
        if ($from instanceof ModelInterface) {
            $className = get_class($from);
            $from = [$from];
            $this->singleModel = true;
        }
        
        // Handle Simple Resultset
        elseif ($from instanceof Simple) {
            $new = [];
            foreach ($from as $record) {
                $className ??= get_class($record);
                $className ??= get_class(/** @scrutinizer ignore-type */ $record);
                $new[] = $record;
            }
            if (empty($from)) {
                $new = null;
            }
            $from = $new;
        }
        
        // Handle array
        elseif (is_array($from)) {

            $from = array_filter($from);
            foreach ($from as $el) {
                if ($el instanceof ModelInterface) {
                    // elements must be all the same model class
                    $className ??= get_class($el);
                    if ($className !== get_class($el)) {
                        $error = true;
                        break;
                    }
                }
                else {
                    // element must be a ModelInterface
                    $error = true;
                    break;
                }
            }
            if (empty($from)) {
                $from = null;
            }
        }
        
        // Handle null or empty
        elseif (is_null($from) || is_bool($from)) {
            $from = null;
        }
        
        // error
        else {
            $error = true;
        }
        
        if ($error) {
            throw new Exception('Expected value of `subject` to be either a ModelInterface object, a Simple object or an array of ModelInterface objects');
        }
        
        $this->subject = $from;
        $this->className = $className;
        $this->eagerLoads = ($from === null || empty($arguments)) ? [] : self::parseArguments($arguments);
    }
    
    public function setOptions($options)
    {
        $this->options = $options;
        return $this;
    }
    
    /**
     * Create and get from a mixed $subject
     *
     * @param ModelInterface|ModelInterface[]|Simple $subject
     * @param mixed ...$arguments
     * @return mixed
     * @throws \InvalidArgumentException
     */
    public static function from($subject, array ...$arguments)
    {
        if ($subject instanceof ModelInterface) {
            return self::fromModel(...$arguments);
            return self::fromModel(/** @scrutinizer ignore-type */ ...$arguments);
        }
        elseif ($subject instanceof Simple) {
            return self::fromResultset(...$arguments);
            return self::fromResultset(/** @scrutinizer ignore-type */ ...$arguments);
        }
        elseif (is_array($subject)) {

            return self::fromArray(...$arguments);
        }
        
        throw new \InvalidArgumentException(self::E_INVALID_SUBJECT);
    }
    
    /**
     * Create and get from a Model
     *
     * @param ModelInterface $subject
     * @param mixed ...$arguments
     * @return ModelInterface
     */
    public static function fromModel(ModelInterface $subject, ...$arguments): ModelInterface
    {
        return (new self($subject, ...$arguments))->execute()->get();

    }
    
    /**
     * Create and get from a Model without soft deleted records
     *
     * @param ModelInterface $subject
     * @param mixed ...$arguments
     * @return ModelInterface
     */
    public static function fromModelWithoutSoftDelete(ModelInterface $subject, ...$arguments): ModelInterface
    {
        $options = ['softDelete' => 'softDelete'];
        $obj = new self($subject, ...$arguments);
        return $obj->setOptions($options)->execute()->get();

    }
    
    /**
     * Create and get from an array
     *
     * @param ModelInterface[] $subject
     * @param mixed ...$arguments
     * @return array
     */
    public static function fromArray(array $subject, ...$arguments): array
    {
        return (new self($subject, ...$arguments))->execute()->get();

    }
    
    /**
     * Create and get from an array without soft deleted records
     *
     * @param ModelInterface[] $subject
     * @param mixed ...$arguments
     * @return array
     */
    public static function fromArrayWithoutSoftDelete(array $subject, ...$arguments): array
    {
        $options = ['softDelete' => 'softDelete'];
        $obj = new self($subject, ...$arguments);
        return $obj->setOptions($options)->execute()->get();

    }
    
    /**
     * Create and get from a Resultset
     *
     * @param Simple $subject
     * @param mixed ...$arguments
     * @return ?array
     */
    public static function fromResultset(Simple $subject, ...$arguments): ?array
    {
        return (new self($subject, ...$arguments))->execute()->get();

    }
    
    /**
     * @return null|ModelInterface[]|ModelInterface
     */
    public function get()
    {
        return $this->singleModel
            ? $this->subject[0] ?? null
            : $this->subject ?? [];
    }
    
    /**
     * @return null|ModelInterface[]
     */
    public function getSubject()
    {
        return $this->subject;
    }
    
    /**
     * Parses the arguments that will be resolved to Relation instances
     *
     * @param array $arguments
     * @return array
     * @throws \InvalidArgumentException
     */
    private static function parseArguments(array $arguments)
    {
        if (empty($arguments)) {
            throw new \InvalidArgumentException('Arguments can not be empty');
        }
        
        $relations = [];
        if (count($arguments) === 1 && isset($arguments[0]) && is_array($arguments[0])) {
            foreach ($arguments[0] as $relationAlias => $queryConstraints) {
                if (is_string($relationAlias)) {
                    $relations[$relationAlias] = is_callable($queryConstraints) ? $queryConstraints : null;
                }
                elseif (is_string($queryConstraints)) {
                    $relations[$queryConstraints] = null;
                }
            }
        }
        else {
            foreach ($arguments as $relationAlias) {
                if (is_string($relationAlias)) {
                    $relations[$relationAlias] = null;
                }
            }
        }
        
        return $relations;
    }
    
    public function addEagerLoad(string $relationAlias, ?callable $constraints = null): self
    {
        $this->eagerLoads[$relationAlias] = $constraints;
        return $this;
    }
    
    /**
     * Resolves the relations
     *
     * @return EagerLoad[]
     * @throws \RuntimeException
     */
    private function buildTree()
    {
        uksort($this->eagerLoads, 'strcmp');
        
        $di = \Phalcon\DI::getDefault();
        $mM = $di['modelsManager'];
        
        $eagerLoads = $resolvedRelations = [];
        $cache = new Cache();
filter:
    dependency_paths: ["lib/*"]
        
        foreach ($this->eagerLoads as $relationAliases => $queryConstraints) {
            $nestingLevel = 0;
            $relationAliases = explode('.', $relationAliases);
            $nestingLevels = count($relationAliases);
            
            do {
                do {
                    $alias = $relationAliases[$nestingLevel];
                    $name = implode('.', array_slice($relationAliases, 0, $nestingLevel + 1));
                }
                while (isset($eagerLoads[$name]) && ++$nestingLevel);
                
                if ($nestingLevel === 0) {
                    $parentClassName = $this->className;
                }
                else {
                    $parentName = implode('.', array_slice($relationAliases, 0, $nestingLevel));
                    $parentClassName = $resolvedRelations[$parentName]->getReferencedModel();
                    
                    if ($parentClassName[0] === '\\') {
                        $parentClassName = ltrim($parentClassName, '\\');
                    }
                }
                
                if (!isset($resolvedRelations[$name])) {
                    $mM->load($parentClassName);
                    $relation = $mM->getRelationByAlias($parentClassName, $alias);
                    
                    if (!$relation instanceof Relation) {
                        throw new \RuntimeException(sprintf(
                            'There is no defined relation for the model `%s` using alias `%s`',
                            $parentClassName,
                            $alias
                        ));
                    }
                    
                    $resolvedRelations[$name] = $relation;
                }
                else {
                    $relation = $resolvedRelations[$name];
                }
                
                $relType = $relation->getType();
                
                if ($relType !== Relation::BELONGS_TO &&
                    $relType !== Relation::HAS_ONE &&
                    $relType !== Relation::HAS_MANY &&
                    $relType !== Relation::HAS_MANY_THROUGH
                ) {
                    
                    throw new \RuntimeException(sprintf('Unknown relation type `%s`', $relType));
                }
                
                if (is_array($relation->getFields()) ||
                    is_array($relation->getReferencedFields())
                ) {
                    
                    throw new \RuntimeException('Relations with composite keys are not supported');
                }
                
                $parent = $nestingLevel > 0 ? $eagerLoads[$parentName] : $this;

                $constraints = $nestingLevel + 1 === $nestingLevels ? $queryConstraints : null;
                
                $eagerLoads[$name] = new EagerLoad($relation, $constraints, $parent, $cache);
                $eagerLoads[$name] = /** @scrutinizer ignore-call */ new EagerLoad($relation, $constraints, $parent, $cache);
            }
            while (++$nestingLevel < $nestingLevels);
        }
        
        return $eagerLoads;
    }
    
    /**
     * @return $this
     */
    public function execute(): self
    {
        foreach ($this->buildTree() as $eagerLoad) {
            $eagerLoad->load($this->options);
                        load($this->options);
        }
        
        return $this;
    }
    
    /**
     * Loader::execute() alias
     *
     * @return $this
     */
    public function load(): self
    {
        return $this->execute();
    }
}

zemit-cms / core

Push — master ( a835f3...4c7cec )

Loader::get() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
