Schemator::convert() - Code Metrics - Inspection of "exec() method deprecation" - Smoren/schemator-php - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( ff1a3c...f7850f )

by Smoren
created 2022-08-16 08:56 UTC
Schemator::convert() A

↳ Parent: Schemator
Complexity

Conditions	3
Paths	3
Size

Total Lines	13
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Importance

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

namespace Smoren\Schemator\Components;

use Smoren\Schemator\Interfaces\NestedAccessorFactoryInterface;
use Smoren\Schemator\Interfaces\SchematorInterface;
use Smoren\Schemator\Factories\NestedAccessorFactory;
use Smoren\Schemator\Structs\FilterContext;
use Smoren\Schemator\Exceptions\NestedAccessorException;
use Smoren\Schemator\Exceptions\SchematorException;
use Throwable;

/**
 * Class for schematic data converting
 * @author Smoren <[email protected]>
 */
class Schemator implements SchematorInterface
{
    /**
     * @var callable[] filters map
     */
    protected array $filters = [];
    /**
     * @var string delimiter for multilevel paths
     */
    protected string $pathDelimiter;
    /**
     * @var NestedAccessorFactoryInterface nested accessor factory
     */
    protected NestedAccessorFactoryInterface $nestedAccessorFactory;

    /**
     * Schemator constructor.
     * @param string $pathDelimiter delimiter for multilevel paths
     */
    public function __construct(
        string $pathDelimiter = '.',
        NestedAccessorFactoryInterface $nestedAccessorFactory = null
    ) {
        $this->pathDelimiter = $pathDelimiter;
        $this->nestedAccessorFactory = $nestedAccessorFactory ?? new NestedAccessorFactory();
    }

    /**
     * @inheritDoc
     */
    public function convert($source, array $schema, bool $strict = false)
    {
        $toAccessor = $this->nestedAccessorFactory->create($result, $this->pathDelimiter);

        foreach($schema as $keyTo => $keyFrom) {
            $value = $this->getValue($source, $keyFrom, $strict);
            if($keyTo === '') {
                return $value;
            }
            $toAccessor->set($keyTo, $value, $strict);
        }

        return $result;
    }

    /**
     * @inheritDoc
     * @deprecated please use convert() method
     */
    public function exec($source, array $schema, bool $strict = false)
    {
        return $this->convert($source, $schema, $strict);
    }

    /**
     * @inheritDoc
     */
    public function getValue($source, $key, bool $strict = false)
    {
        if($key === '' || $key === null) {
            return $source;
        }

        if($source === null || (!is_array($source) && !is_object($source))) {
            return $this->getValueFromUnsupportedSource($source, $key, $strict);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        }

        if(is_string($key)) {
            return $this->getValueByKey($source, $key, $strict);
            return $this->getValueByKey(/** @scrutinizer ignore-type */ $source, $key, $strict);
        }

        if(is_array($key)) {
            return $this->getValueByFilters($source, $key, $strict);
            return $this->getValueByFilters(/** @scrutinizer ignore-type */ $source, $key, $strict);
        }

        return $this->getValueByUnsupportedKey($source, $key, $strict);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
    }

    /**
     * @inheritDoc
     */
    public function addFilter(string $filterName, callable $callback): self
    {
        $this->filters[$filterName] = $callback;
        return $this;
    }

    /**
     * Returns value got by string key
     * @param array $source source to get value from
     * @param string $key nested path to get value by
     * @param bool $strict when true throw exception if something goes wrong
     * @return array|mixed|null value
     * @throws SchematorException
     */
    protected function getValueByKey(array $source, string $key, bool $strict)
    {
        try {
            $fromAccessor = $this->nestedAccessorFactory->create($source, $this->pathDelimiter);
            return $fromAccessor->get($key, $strict);
        } catch(NestedAccessorException $e) {
            throw SchematorException::createAsCannotGetValue($source, $key, $e);
        }
    }

    /**
     * Returns value got by filters key
     * @param array $source source to get value from
     * @param array $filters filters config
     * @param bool $strict when true throw exception if something goes wrong
     * @return array|mixed|null
     * @throws SchematorException
     */
    protected function getValueByFilters(array $source, array $filters, bool $strict)
    {
        $result = $source;
        foreach($filters as $filterConfig) {
            if(is_string($filterConfig)) {
                $result = $this->getValue($result, $filterConfig, $strict);
            } elseif(is_array($filterConfig)) {
                $result = $this->runFilter($filterConfig, $result, $source, $strict);
            } else {
                if($strict) {
                    throw SchematorException::createAsUnsupportedFilterConfigType($filterConfig);
                }
                $result = null;
            }
        }

        return $result;
    }

    /**
     * Returns value got from unsupported source
     * @param mixed $source unsupported source
     * @param mixed $key path to get value by
     * @param bool $strict when true throw exception
     * @return null the only value we can get from unsupported source
     * @throws SchematorException
     */
    protected function getValueFromUnsupportedSource($source, $key, bool $strict)
    {
        if(!$strict) {
            return null;
        }
        throw SchematorException::createAsUnsupportedSourceType($source, $key);
    }

    /**
     * Returns value got by unsupported key
     * @param mixed $source source to get value from
     * @param mixed $key unsupported key
     * @param bool $strict when true throw exception
     * @return null the only value we can get by unsupported key
     * @throws SchematorException
     */
    protected function getValueByUnsupportedKey($source, $key, bool $strict)
    {
        if(!$strict) {
            return null;
        }
        throw SchematorException::createAsUnsupportedKeyType($source, $key);
    }

    /**
     * Returns value from source by filter
     * @param array $filterConfig filter config [filterName, ...args]
     * @param mixed $source source to extract value from
     * @param array $rootSource root source
     * @param bool $strict when true throw exception if something goes wrong
     * @return mixed result value
     * @throws SchematorException
     */
    protected function runFilter(array $filterConfig, $source, array $rootSource, bool $strict)
    {
        $filterName = array_shift($filterConfig);

        SchematorException::ensureFilterExists($this->filters, $filterName);

        try {
            return $this->filters[$filterName](
                new FilterContext($this, $source, $rootSource),
                ...$filterConfig
            );
        } catch(Throwable $e) {
            if($strict) {
                throw SchematorException::createAsFilterError($filterName, $filterConfig, $source, $e);
            }
            return null;
        }
    }
}

Smoren / schemator-php

Push — master ( ff1a3c...f7850f )

Schemator::convert() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
