flipbox\transform\Scope

Complexity

Total Complexity

32

Size/Duplication

Total Lines	351
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	getResource()	0	4	1
A	getFactory()	0	4	1
A	getParams()	0	6	1
A	getScopeIdentifier()	0	4	1
A	getIdentifier()	0	13	1
A	getParentScopes()	0	4	1
A	isRequested()	0	7	1
A	isExcluded()	0	7	1
B	transform()	0	30	4
B	fireTransformer()	0	34	5
B	includeValue()	0	16	5
A	parseValue()	0	19	3
A	isRootScope()	0	4	1
A	filterFields()	0	17	2
A	getFilterFields()	0	6	1
A	_scopeString()	0	13	2

<?php

/**
 * @package   Transform
 * @author    Flipbox Factory
 * @copyright Copyright (c) 2017, Flipbox Digital
 * @link      https://github.com/flipbox/transform/releases/latest
 * @license   https://github.com/flipbox/transform/blob/master/LICENSE
 */

namespace flipbox\transform;

use flipbox\transform\resources\CollectionInterface;
use flipbox\transform\resources\ItemInterface;
use flipbox\transform\resources\ResourceInterface;
use flipbox\transform\transformers\TransformerInterface;

/**
 * @package flipbox\transform
 * @author Flipbox Factory <hello@flipboxfactory.com>
 * @since 1.0.0
 */
class Scope
{

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

    /**
     * @var Factory
     */
    protected $factory;

    /**
     * @var ResourceInterface
     */
    protected $resource;

    /**
     * @var array
     */
    protected $parentScopes = [];

    /**
     * Scope constructor.
     * @param Factory $factory
     * @param ResourceInterface $resource
     * @param string|null $scopeIdentifier
     * @param array $parentScopes
     */
    public function __construct(Factory $factory, ResourceInterface $resource, string $scopeIdentifier = null, array $parentScopes = [])
    {
        $this->factory = $factory;
        $this->resource = $resource;
        $this->scopeIdentifier = $scopeIdentifier;
        $this->parentScopes = $parentScopes;
    }

    /**
     * @return ResourceInterface
     */
    public function getResource(): ResourceInterface
    {
        return $this->resource;
    }

    /**
     * Getter for manager.
     *
     * @return Factory
     */
    public function getFactory(): Factory
    {
        return $this->factory;
    }

    /**
     * @param $key
     * @return ParamBag
     */
    public function getParams(string $key = null): ParamBag
    {
        return $this->getFactory()->getParams(
            $this->getIdentifier($key)
        );
    }

    /**
     * Get the current identifier.
     *
     * @return string|null
     */
    public function getScopeIdentifier()
    {
        return $this->scopeIdentifier;
    }

    /**
     * Get the unique identifier for this scope.
     *
     * @param string $appendIdentifier
     *
     * @return string
     */
    public function getIdentifier(string $appendIdentifier = null): string
    {
        return implode(
            '.',
            array_filter(array_merge(
                $this->parentScopes,
                [
                    $this->scopeIdentifier,
                    $appendIdentifier
                ]
            ))
        );
    }

    /**
     * Getter for parentScopes.
     *
     * @return array
     */
    public function getParentScopes(): array
    {
        return $this->parentScopes;
    }

    /**
     * Is Requested.
     *
     * Check if - in relation to the current scope - this specific segment is allowed.
     * That means, if a.b.c is requested and the current scope is a.b, then c is allowed. If the current
     * scope is a then c is not allowed, even if it is there and potentially transformable.
     *
     * @internal
     *
     * @param string $checkScopeSegment
     *
     * @return bool Returns the new number of elements in the array.
     */
    public function isRequested($checkScopeSegment): bool
    {
        return in_array(
            $this->_scopeString($checkScopeSegment),
            $this->factory->getIncludes()
        );
    }

    /**
     * Is Excluded.
     *
     * Check if - in relation to the current scope - this specific segment should
     * be excluded. That means, if a.b.c is excluded and the current scope is a.b,
     * then c will not be allowed in the transformation whether it appears in
     * the list of default or available, requested includes.
     *
     * @internal
     *
     * @param string $checkScopeSegment
     *
     * @return bool
     */
    public function isExcluded($checkScopeSegment): bool
    {
        return in_array(
            $this->_scopeString($checkScopeSegment),
            $this->factory->getExcludes()
        );
    }

    /**
     * Convert the current data for this scope to an array.
     *
     * @return array|null
     */
    public function transform()
    {

        $resource = $this->getResource();
        $transformer = $resource->getTransformer();
        $data = $resource->getData();

        $transformedData = [];

        if ($resource instanceof ItemInterface) {

            $transformedData = $this->fireTransformer($transformer, $data);

        } elseif ($resource instanceof CollectionInterface) {

            foreach ($data as $value) {

                $transformedData[] = $this->fireTransformer($transformer, $value);

            }

        } else {

            $transformedData = null;

        }

        return $transformedData;

    }

    /**
     * Fire the main transformer.
     *
     * @internal
     *
     * @param TransformerInterface|callable $transformer
     * @param mixed $data
     *
     * @return array
     */
    protected function fireTransformer(callable $transformer, $data): array
    {

        $includedData = [];

        // Transform data
        $transformedData = $this->parseValue($transformer, $data);

        // Bail now
        if (null === $transformedData) {
            return $includedData;
        }

        // Conform to array
        if (!is_array($transformedData)) {
            $transformedData = [$transformedData];
        }

        foreach ($transformedData as $key => $val) {

            if (!$this->includeValue($transformer, $key)) {
                continue;
            }

            $includedData[$key] = $this->parseValue($val, $data, $key);

        }

        // Return only the requested fields
        $includedData = $this->filterFields($includedData);

        return $includedData;

    }

    /**
     * @param callable $transformer
     * @param string $key
     * @return bool
     */
    protected function includeValue(callable $transformer, string $key): bool
    {

        // Ignore optional (that have not been explicitly requested)
        if ($transformer instanceof TransformerInterface && in_array($key, $transformer->getIncludes(), true) && !$this->isRequested($key)) {
            return false;
        }

        // Ignore excludes
        if ($this->isExcluded($key)) {
            return false;
        }

        return true;

    }

    /**
     * @param $val
     * @param $data
     * @param string|null $key
     * @return array|string|null
     */
    protected function parseValue($val, $data, string $key = null)
    {

        // Nesting
        if ($val instanceof ResourceInterface) {

            return $this->getFactory()->transform($val, $key, $this);

It seems like $key defined by parameter $key on line 283 can also be of type string; however, flipbox\transform\Factory::transform() does only seem to accept null, maybe add an additional type check?

        }

        if (is_callable($val)) {

            return call_user_func_array($val, [$data, $this, $key]);

        }

        return $val;

    }

    /**
     * Check, if this is the root scope.
     *
     * @return bool
     */
    protected function isRootScope(): bool
    {
        return empty($this->parentScopes);
    }

    /**
     * Filter the provided data with the requested filter fields for
     * the scope resource
     *
     * @internal
     *
     * @param array $data
     *
     * @return array
     */
    protected function filterFields(array $data): array
    {

        $fields = $this->getFilterFields();

        if ($fields === null) {
            return $data;
        }

        return array_intersect_key(
            $data,
            array_flip(
                iterator_to_array($fields)
            )
        );

    }

    /**
     * Return the requested filter fields for the scope resource
     *
     * @internal
     *
     * @return ParamBag|null
     */
    protected function getFilterFields()
    {
        return $this->factory->getField(
            $this->getScopeIdentifier()
        );
    }

    /**
     * @param string $checkScopeSegment
     * @return string
     */
    private function _scopeString(string $checkScopeSegment): string
    {

        if ($this->parentScopes) {

The expression $this->parentScopes of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $scopeArray = array_slice($this->parentScopes, 1);
            array_push($scopeArray, $this->scopeIdentifier, $checkScopeSegment);
        } else {
            $scopeArray = [$checkScopeSegment];
        }

        return implode('.', (array)$scopeArray);

    }

}