EagerLoading::findWithBy() - Code Metrics - Inspection of "eager loading refactoring" - zemit-cms/core - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 4c7cec...9fd0ac )

by Julien

created 2023-04-03 14:56 UTC

EagerLoading::findWithBy() A

↳ Parent: EagerLoading

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	5
c	1
b	0
f	0
nc	2
nop	2
dl	0
loc	10
ccs	0
cts	6
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;

use Phalcon\Mvc\ModelInterface;
use Zemit\Mvc\Model\EagerLoading\Loader;

trait EagerLoading
{
    /**
     * <code>
     * <?php
     *
     * $limit  = 100;
     * $offset = max(0, $this->request->getQuery('page', 'int') - 1) * $limit;
     *
     * $manufacturers = Manufacturer::with('Robots.Parts', [
     *     'limit' => [$limit, $offset]
     * ]);
     *
     * foreach ($manufacturers as $manufacturer) {
     *     foreach ($manufacturer->robots as $robot) {
     *         foreach ($robot->parts as $part) { ... }
     *     }
     * }
     *
     * </code>
     *
     * @param mixed ...$arguments
     */
    public static function findWith(array ...$arguments)
    {
        $parameters = self::getParametersFromArguments($arguments);
        $list = static::find($parameters);
        $list = static::find($parameters);
        if ($list->count()) {
            return Loader::fromResultset($list, ...$arguments);
        }
        
        return $list;
    }
    
    /**
     * Same as EagerLoadingTrait::findWith() for a single record
     *
     * @param mixed ...$arguments
     * @return false|\Phalcon\Mvc\ModelInterface
     */
    public static function findFirstWith(array ...$arguments)
    {
        $parameters = self::getParametersFromArguments($arguments);
        $entity = static::findFirst($parameters);
        $entity = static::findFirst($parameters);
        if ($entity) {
            return Loader::fromModel($entity, ...$arguments);
            return Loader::fromModel(/** @scrutinizer ignore-type */ $entity, ...$arguments);
        }
        
        return $entity;

    }
    
    /**
     * @deprecated
     * Alias of findWith
     */
    public static function with(array ...$arguments)
    {
        return self::findWith(...$arguments);
    }
    
    /**
     * @deprecated
     * Alias of findWith
     */
    public static function firstWith(array ...$arguments)
    {
        return self::findWith(...$arguments);
    }
    
    /**
     * Call magic method to make the with works in an implicit way
     * @todo change it to behavior missingMethods()
     */
    public static function __callStatic(string $method, array $arguments = [])
    {
        // Single - FindFirstBy...
        if (strpos($method, 'findFirstWithBy') === 0 || strpos($method, 'firstWithBy') === 0) {
            
            $forwardMethod = str_replace(['findFirstWithBy', 'firstWithBy'], 'findFirstBy', $method);
            return self::findFirstWithBy($forwardMethod, $arguments);
        }
        
        // List - FindWithBy...
        elseif (strpos($method, 'findWithBy') === 0 || strpos($method, 'withBy') === 0) {
    
            $forwardMethod = str_replace(['findWithBy', 'withBy'], 'findBy', $method);
            return self::findWithBy($forwardMethod, $arguments);
        }
    
        return parent::$method(...$arguments);
    }
    
    /**
     * Call native Phalcon FindFirstBy function then eager load relationships from the model
     */
    private static function findFirstWithBy(string $forwardMethod, array $arguments): ModelInterface
    {
        $parameters = self::getParametersFromArguments($arguments);
        $entity = parent::$forwardMethod($parameters);
    
        if ($entity) {
            return Loader::fromModel($entity, ...$arguments);
        }
    
        return $entity;
    }
    
    /**
     * Call native Phalcon findBy function then eager load relationships from the resultset
     */
    private static function findWithBy(string $forwardMethod, array $arguments): ?array
    {
        $parameters = self::getParametersFromArguments($arguments);
        $list = parent::$forwardMethod($parameters);
    
        if ($list->count()) {
            return Loader::fromResultset($list, ...$arguments);
        }
    
        return $list;
    }
    
    /**
     * <code>
     *
     * $manufacturer = Manufacturer::findFirstById(51);
     *
     * $manufacturer->load('Robots.Parts');
     *
     * foreach ($manufacturer->robots as $robot) {
     *    foreach ($robot->parts as $part) { ... }
     * }
     *
     * </code>
     *
     * @param mixed ...$arguments
     * @return \Phalcon\Mvc\ModelInterface
     */
    public function load(array ...$arguments)
    {
        return Loader::fromModel($this, ...$arguments);
        return Loader::fromModel(/** @scrutinizer ignore-type */ $this, ...$arguments);
    }
    
    /**
     * Get the query parameters from a list of arguments
     * @return mixed
     */
    public static function getParametersFromArguments(array &$arguments)
    {
        $parameters = null;
        
        if (!empty($arguments)) {
            $numArgs = count($arguments);
            $lastArg = $numArgs - 1;
            
            if ($numArgs >= 2) {
                $parameters = $arguments[$lastArg];
                unset($arguments[$lastArg]);
                
                if (isset($parameters['columns'])) {
                    throw new \LogicException('Results from database must be full models, do not use `columns` key');
                }
            }
        }
        
        return $parameters;
    }
}


zemit-cms / core

Push — master ( 4c7cec...9fd0ac )

EagerLoading::findWithBy() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like