ConfigToken\TreeCompiler\XrefTokenResolverCollection

Complexity

Total Complexity

32

Size/Duplication

Total Lines	152
Duplicated Lines	10.53 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

82.64%

Importance

Changes	6
Bugs	1	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	add()	0	4	1
A	addCollection()	0	4	1
A	prepend()	0	4	1
A	prependCollection()	0	4	1
D	resolveTokens()	0	34	9
C	getTokensFromArray()	16	31	8
A	applyToString()	0	10	2
D	applyToArray()	0	41	9

<?php

namespace ConfigToken\TreeCompiler;


use ConfigToken\TokenCollection;
use ConfigToken\TokenInjector;
use ConfigToken\TokenParser;
use ConfigToken\TokenResolver\Types\RegisteredTokenResolver;
use ConfigToken\TokenResolver\Types\ScopeTokenResolver;
use ConfigToken\TreeCompiler;

class XrefTokenResolverCollection
{
    /** @var XrefTokenResolver[] */
    protected $collection = array();

    protected static $_KEY = 0;
    protected static $_KEY_TOKENS = 1;
    protected static $_KEY_REF = 2;
    protected static $_VALUE = 3;
    protected static $_VALUE_TOKENS = 4;
    protected static $_VALUE_REF = 5;

    public function add(XrefTokenResolver $xrefTokenResolver)
    {
        $this->collection[] = $xrefTokenResolver;
    }

    public function addCollection(XrefTokenResolverCollection $xrefTokenResolverCollection)
    {
        $this->collection = array_merge($this->collection, $xrefTokenResolverCollection->collection);
    }

    public function prepend(XrefTokenResolver $xrefTokenResolver)
    {
        array_unshift($this->collection, $xrefTokenResolver);
    }

    public function prependCollection(XrefTokenResolverCollection $xrefTokenResolverCollection)
    {
        $this->collection = array_merge($xrefTokenResolverCollection->collection, $this->collection);
    }

    protected function resolveTokens(TokenCollection $tokens, XrefTokenResolver $xrefTokenResolver)
    {
        if (!$xrefTokenResolver->hasTokenResolver()) {
            throw new \Exception('No token resolver found for Xref token resolver.');
        }
        $tokenResolver = $xrefTokenResolver->getTokenResolver();
        $hasValues = False;
        if ($tokenResolver instanceof RegisteredTokenResolver) {
            $hasValues = $tokenResolver->hasRegisteredTokenValues();
        }
        if ($tokenResolver instanceof ScopeTokenResolver) {
            $hasValues = $tokenResolver->hasScope();
        }
        if (!$hasValues) {
            if ($xrefTokenResolver->hasXref()) {
                $xref = $xrefTokenResolver->getXref();
                if (!$xref->isResolved()) {
                    $treeCompiler = new TreeCompiler();
                    $compiledValues = $treeCompiler->compileXref($xref);

It seems like $xref defined by $xrefTokenResolver->getXref() on line 60 can be null; however, ConfigToken\TreeCompiler::compileXref() does not accept null, maybe add an additional type check?

                    $xref->setData($compiledValues);
                }
                $values = $xref->getData();
            } else {
                $values = $xrefTokenResolver->getRegisteredTokenValues();
            }
            if ($tokenResolver instanceof RegisteredTokenResolver) {
                $tokenResolver->setRegisteredTokenValues($values);
            }
            if ($tokenResolver instanceof ScopeTokenResolver) {
                $tokenResolver->setScope($values);
            }
        }
        $xrefTokenResolver->resolve($tokens);
    }

    protected function getTokensFromArray(&$array, TokenParser $parser, &$result)
    {
        foreach ($array as $key => &$value) {
            $t = array();
            if (gettype($key) == 'string') {

This code seems to be duplicated across your project.

                $tokens = $parser->parseString($key);
                if (!$tokens->isEmpty()) {
                    $t[self::$_KEY] = $key;
                    $t[self::$_KEY_TOKENS] = $tokens;
                    $t[self::$_KEY_REF] = &$array;
                }
            }
            $valueType = gettype($value);
            if ($valueType == 'string') {

This code seems to be duplicated across your project.

                $tokens = $parser->parseString($value);
                if (!$tokens->isEmpty()) {
                    $t[self::$_VALUE] = $value;
                    $t[self::$_VALUE_TOKENS] = $tokens;
                    $t[self::$_VALUE_REF] = &$value;
                }
            }
            if (count($t) > 0) {
                $result[] = $t;
                unset($t);
            }
            if ($valueType == 'array') {
                $this->getTokensFromArray($value, $parser, $result);
            }
        }
        unset($value);
    }

    public function applyToString($string)
    {
        foreach ($this->collection as $xrefTokenResolver) {
            $tokenParser = $xrefTokenResolver->getTokenParser();
            $tokens = $tokenParser->parseString($string);
            $this->resolveTokens($tokens, $xrefTokenResolver);
            $string = TokenInjector::injectString($string, $tokens);
        }
        return $string;
    }

    public function applyToArray(&$array)
    {
        foreach ($this->collection as $xrefTokenResolver) {
            $tokenParser = $xrefTokenResolver->getTokenParser();
            $lookup = array();
            $this->getTokensFromArray($array, $tokenParser, $lookup);
            foreach ($lookup as $record) {
                if (isset($record[self::$_VALUE_TOKENS])) {
                    $this->resolveTokens($record[self::$_VALUE_TOKENS], $xrefTokenResolver);
                }
                if (isset($record[self::$_KEY_TOKENS])) {
                    $this->resolveTokens($record[self::$_KEY_TOKENS], $xrefTokenResolver);
                }
            }
            foreach ($lookup as &$record) {
                if (isset($record[self::$_VALUE])) {
                    $newValue = TokenInjector::injectString(
                        $record[self::$_VALUE],
                        $record[self::$_VALUE_TOKENS]
                    );
                    $record[self::$_VALUE_REF] = $newValue;
                    unset($record[self::$_VALUE_TOKENS]);
                    unset($record[self::$_VALUE_REF]);
                }
                if (isset($record[self::$_KEY])) {
                    $oldKey = $record[self::$_KEY];
                    $newKey = TokenInjector::injectString(
                        $oldKey,
                        $record[self::$_KEY_TOKENS]
                    );
                    unset($record[self::$_KEY_TOKENS]);
                    if ($oldKey != $newKey) {
                        $record[self::$_KEY_REF][$newKey] = $record[self::$_KEY_REF][$oldKey];
                        unset($record[self::$_KEY_REF][$oldKey]);
                        unset($record[self::$_KEY_REF]);
                    }
                }
            }
            unset($record);
        }
    }
}