ConfigToken\TreeCompiler\XrefTokenResolver

Complexity

Total Complexity

44

Size/Duplication

Total Lines	342
Duplicated Lines	0 %

Coupling/Cohesion

Components	4
Dependencies	2

Test Coverage

Coverage

53.85%

Importance

Changes	2
Bugs	0	Features	0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	hasTokenResolver()	0	4	1
A	hasXref()	0	4	1
A	hasRegisteredTokenValues()	0	4	1
A	hasIgnoreUnknownFilters()	0	4	1
A	hasTokenRegex()	0	4	1
A	hasTokenPrefix()	0	4	1
A	hasTokenSuffix()	0	4	1
A	hasTokenFilterDelimiter()	0	4	1
A	getTokenResolver()	0	7	2
A	setTokenResolver()	0	5	1
A	getXref()	0	7	2
A	setXref()	0	5	1
A	getRegisteredTokenValues()	0	7	2
A	setRegisteredTokenValues()	0	5	1
A	getIgnoreUnknownFilters()	0	7	2
A	setIgnoreUnknownFilters()	0	5	1
A	getTokenRegex()	0	7	2
A	getTokenPrefix()	0	7	2
A	getTokenSuffix()	0	7	2
A	getTokenFilterDelimiter()	0	7	2
A	setTokenRegex()	0	8	2
A	setTokenPrefix()	0	8	2
A	setTokenSuffix()	0	8	2
A	setTokenFilterDelimiter()	0	8	2
B	getTokenParser()	0	17	6
A	resolve()	0	5	1

<?php

namespace ConfigToken\TreeCompiler;

use ConfigToken\TokenCollection;
use ConfigToken\TokenParser;
use ConfigToken\TokenResolver\TokenResolverInterface;


class XrefTokenResolver
{
    /** @var TokenResolverInterface */
    protected $tokenResolver;
    /** @var Xref */
    protected $xref;
    /** @var array */
    protected $registeredTokenValues;
    /** @var boolean */
    protected $ignoreUnknownFilters;
    /** @var string */
    protected $tokenRegex;
    /** @var string */
    protected $tokenPrefix;
    /** @var string */
    protected $tokenSuffix;
    /** @var string */
    protected $tokenFilterDelimiter;
    /** @var TokenParser */
    protected $tokenParser;

    public function __construct(TokenResolverInterface $tokenResolver = null)
    {
        $this->setTokenResolver($tokenResolver);
    }

    /**
     * Check if token resolver was set.
     *
     * @return boolean
     */
    public function hasTokenResolver()
    {
        return isset($this->tokenResolver);
    }

    /**
     * Get token resolver.
     *
     * @return TokenResolverInterface|null
     */
    public function getTokenResolver()
    {
        if (!$this->hasTokenResolver()) {
            return null;
        }
        return $this->tokenResolver;
    }

    /**
     * Set token resolver.
     *
     * @param TokenResolverInterface|null $tokenResolver The new value for token resolver or null for none.
     * @return $this
     */
    public function setTokenResolver($tokenResolver = null)
    {
        $this->tokenResolver = $tokenResolver;
        return $this;
    }

    /**
     * Check if xref was set.
     *
     * @return boolean
     */
    public function hasXref()
    {
        return isset($this->xref);
    }

    /**
     * Get xref.
     *
     * @return Xref|null
     */
    public function getXref()
    {
        if (!$this->hasXref()) {
            return null;
        }
        return $this->xref;
    }

    /**
     * Set xref.
     *
     * @param Xref|null $xref The new value for xref or null for none.
     * @return $this
     */
    public function setXref($xref = null)
    {
        $this->xref = $xref;
        return $this;
    }

    /**
     * Check if registered token values was set.
     *
     * @return boolean
     */
    public function hasRegisteredTokenValues()
    {
        return isset($this->registeredTokenValues);
    }

    /**
     * Get registered token values.
     *
     * @return array|null
     */
    public function getRegisteredTokenValues()
    {
        if (!$this->hasRegisteredTokenValues()) {
            return null;
        }
        return $this->registeredTokenValues;
    }

    /**
     * Set registered token values.
     *
     * @param array|null $registeredTokenValues The new value for registered token values or null for none.
     * @return $this
     */
    public function setRegisteredTokenValues($registeredTokenValues = null)
    {
        $this->registeredTokenValues = $registeredTokenValues;

It seems like $registeredTokenValues can be null. However, the property $registeredTokenValues is declared as array. Maybe change the type of the property to array|null or add a type check?

        return $this;
    }

    /**
     * Check if ignore unknown filters was set.
     *
     * @return boolean
     */
    public function hasIgnoreUnknownFilters()
    {
        return isset($this->ignoreUnknownFilters);
    }

    /**
     * Get ignore unknown filters.
     *
     * @return boolean|null
     */
    public function getIgnoreUnknownFilters()
    {
        if (!$this->hasIgnoreUnknownFilters()) {
            return null;
        }
        return $this->ignoreUnknownFilters;
    }

    /**
     * Set ignore unknown filters.
     *
     * @param boolean|null $ignoreUnknownFilters The new value for ignore unknown filters or null for default.
     * @return $this
     */
    public function setIgnoreUnknownFilters($ignoreUnknownFilters = null)
    {
        $this->ignoreUnknownFilters = $ignoreUnknownFilters;
        return $this;
    }

    /**
     * Check if token regex was set.
     *
     * @return boolean
     */
    public function hasTokenRegex()
    {
        return isset($this->tokenRegex);
    }

    /**
     * Get token regex.
     *
     * @return string|null
     */
    public function getTokenRegex()
    {
        if (!$this->hasTokenRegex()) {
            return null;
        }
        return $this->tokenRegex;
    }

    /**
     * Set token regex.
     *
     * @param string|null $tokenRegex The new value for token regex or null for default.
     * @return $this
     */
    public function setTokenRegex($tokenRegex = null)
    {
        $this->tokenRegex = $tokenRegex;
        if ($this->tokenRegex !== $tokenRegex) {
            $this->tokenParser = null;
        }
        return $this;
    }

    /**
     * Check if token prefix was set.
     *
     * @return boolean
     */
    public function hasTokenPrefix()
    {
        return isset($this->tokenPrefix);
    }

    /**
     * Get token prefix.
     *
     * @return string|null
     */
    public function getTokenPrefix()
    {
        if (!$this->hasTokenPrefix()) {
            return null;
        }
        return $this->tokenPrefix;
    }

    /**
     * Set token prefix.
     *
     * @param string|null $tokenPrefix The new value for token prefix or null for default.
     * @return $this
     */
    public function setTokenPrefix($tokenPrefix = null)
    {
        $this->tokenPrefix = $tokenPrefix;
        if ($this->tokenPrefix !== $tokenPrefix) {
            $this->tokenParser = null;
        }
        return $this;
    }

    /**
     * Check if token suffix was set.
     *
     * @return boolean
     */
    public function hasTokenSuffix()
    {
        return isset($this->tokenSuffix);
    }

    /**
     * Get token suffix.
     *
     * @return string|null
     */
    public function getTokenSuffix()
    {
        if (!$this->hasTokenSuffix()) {
            return null;
        }
        return $this->tokenSuffix;
    }

    /**
     * Set token suffix.
     *
     * @param string|null $tokenSuffix The new value for token suffix or null for default.
     * @return $this
     */
    public function setTokenSuffix($tokenSuffix = null)
    {
        $this->tokenSuffix = $tokenSuffix;
        if ($this->tokenSuffix !== $tokenSuffix) {
            $this->tokenParser = null;
        }
        return $this;
    }

    /**
     * Check if token filter delimiter was set.
     *
     * @return boolean
     */
    public function hasTokenFilterDelimiter()
    {
        return isset($this->tokenFilterDelimiter);
    }

    /**
     * Get token filter delimiter.
     *
     * @return string|null
     */
    public function getTokenFilterDelimiter()
    {
        if (!$this->hasTokenFilterDelimiter()) {
            return null;
        }
        return $this->tokenFilterDelimiter;
    }

    /**
     * Set token filter delimiter.
     *
     * @param string|null $tokenFilterDelimiter The new value for token filter delimiter or null for default.
     * @return $this
     */
    public function setTokenFilterDelimiter($tokenFilterDelimiter = null)
    {
        $this->tokenFilterDelimiter = $tokenFilterDelimiter;
        if ($this->tokenFilterDelimiter !== $tokenFilterDelimiter) {
            $this->tokenParser = null;
        }
        return $this;
    }

    public function getTokenParser()
    {
        if (!isset($this->tokenParser)) {
            $this->tokenParser = new TokenParser();
            if ($this->hasTokenFilterDelimiter()) {
                $this->tokenParser->setFilterDelimiter($this->getTokenFilterDelimiter());
            }
            if ($this->hasTokenRegex()) {
                $this->tokenParser->setTokenRegex($this->getTokenRegex());
            } else {
                if ($this->hasTokenPrefix() && $this->hasTokenSuffix()) {
                    $this->tokenParser->setTokenRegexByDelimiters($this->getTokenPrefix(), $this->getTokenSuffix());
                }
            }
        }
        return $this->tokenParser;
    }

    public function resolve(TokenCollection $tokens)
    {
        $tokens->resolve($this->tokenResolver, null, $this->ignoreUnknownFilters);
        return $this;
    }
}