Flipbox\Transform\Scope\AbstractScope

Complexity

Total Complexity

11

Size/Duplication

Total Lines	144
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

0%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	getTransform()	0	4	1
A	getParams()	0	6	1
A	getScopeIdentifier()	0	4	1
A	getIdentifier()	0	13	1
A	getParentScopes()	0	4	1
A	transform()	0	4	1
A	parseValue()	0	8	2
A	childScope()	0	11	1
A	isRootScope()	0	4	1

<?php

/**
 * @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\Scope;

use Flipbox\Transform\Transform\TransformInterface;
use Flipbox\Transform\Transformers\TransformerInterface;
use Flipbox\Transform\ParamBag;

/**
 * @author Flipbox Factory <hello@flipboxfactory.com>
 * @since 1.0.0
 */
abstract class AbstractScope implements ScopeInterface
{
    /**
     * @var string
     */
    protected $scopeIdentifier;

    /**
     * @var TransformInterface
     */
    protected $transform;

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

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

    /**
     * @return TransformInterface
     */
    public function getTransform(): TransformInterface
    {
        return $this->transform;
    }

    /**
     * @param $key
     * @return ParamBag
     */
    public function getParams(string $key = null): ParamBag
    {
        return $this->getTransform()->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;
    }

    /**
     * @param TransformerInterface|callable $transformer
     * @param mixed $data
     * @return mixed
     */
    public function transform(callable $transformer, $data)
    {
        return $this->parseValue($transformer, $data);
    }

    /**
     * @param $val
     * @param $data
     * @param string|null $key
     * @return array|string|null
     */
    protected function parseValue($val, $data, string $key = null)
    {
        if (is_callable($val)) {
            return call_user_func_array($val, [$data, $this, $key]);
        }

        return $val;
    }

    /**
     * @param string $identifier
     * @return static
     */
    public function childScope(string $identifier)
    {
        $parentScopes = $this->getParentScopes();
        $parentScopes[] = $this->getScopeIdentifier();

        return new static(
            $this->getTransform(),
            $identifier,
            $parentScopes
        );
    }

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