Charcoal\Factory\ResolverFactory

Complexity

Total Complexity

18

Size/Duplication

Total Lines	178
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	4
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	setResolverPrefix()	0	10	2
A	resolverPrefix()	0	4	1
A	setResolverSuffix()	0	10	2
A	resolverSuffix()	0	4	1
A	setResolverCapitals()	0	5	1
A	resolverCapitals()	0	13	2
A	setResolverReplacements()	0	5	1
A	resolverReplacements()	0	11	2
B	resolve()	0	31	4
A	isResolvable()	0	11	2

<?php

namespace Charcoal\Factory;

use \InvalidArgumentException;

// Local namespace dependencies
use \Charcoal\Factory\AbstractFactory;

/**
 *
 */
class ResolverFactory extends AbstractFactory
{
    /**
     * @var string $resolverPrefix
     */
    private $resolverPrefix = '';

    /**
     * @var string $resolverSuffix
     */
    private $resolverSuffix = '';

    /**
     * @var array $resolverCapitals
     */
    private $resolverCapitals = null;

    /**
     * @var array $resolverReplacements
     */
    private $resolverReplacements = null;

    /**
     * @param string $prefix The resolver prefix string.
     * @throws InvalidArgumentException If the prefix argument is not a string.
     * @return ResolverFactory Chainable
     */
    public function setResolverPrefix($prefix)
    {
        if (!is_string($prefix)) {
            throw new InvalidArgumentException(
                'Prefix must be a string'
            );
        }
        $this->resolverPrefix = $prefix;
        return $this;
    }

    /**
     * @return string
     */
    public function resolverPrefix()
    {
        return $this->resolverPrefix;
    }

    /**
     * @param string $suffix The resolver suffix string.
     * @throws InvalidArgumentException If the suffix argument is not a string.
     * @return ResolverFactory Chainable
     */
    public function setResolverSuffix($suffix)
    {
        if (!is_string($suffix)) {
            throw new InvalidArgumentException(
                'Prefix must be a string'
            );
        }
        $this->resolverSuffix = $suffix;
        return $this;
    }

    /**
     * @return string
     */
    public function resolverSuffix()
    {
        return $this->resolverSuffix;
    }

    /**
     * @param array $capitals The array of letter to "calitalize-next" (uppercase next letter in the string).
     * @return ResolverFactory Chainable
     */
    public function setResolverCapitals(array $capitals)
    {
        $this->resolverCapitals = $capitals;
        return $this;
    }

    /**
     * @return array
     */
    public function resolverCapitals()
    {
        if ($this->resolverCapitals === null) {
            return [
                '-',
                '\\',
                '/',
                '.',
                '_'
            ];
        }
        return $this->resolverCapitals;
    }

    /**
     * @param array $replacements The array (key=>value) of replacements.
     * @return ResolverFactory Chainable
     */
    public function setResolverReplacements(array $replacements)
    {
        $this->resolverReplacements = $replacements;
        return $this;
    }

    /**
     * @return array
     */
    public function resolverReplacements()
    {
        if ($this->resolverReplacements === null) {
            return [
                '-'=>'',
                '/'=>'\\',
                '.'=>'_'
            ];
        }
        return $this->resolverReplacements;
    }

    /**
     * Resolve the class name from the requested type.
     *
     * @param string $type The "type" of object to resolve (the object ident).
     * @throws InvalidArgumentException If the type parameter is not a string.
     * @return string
     */
    public function resolve($type)
    {
        if (!is_string($type)) {
            throw new InvalidArgumentException(
                'Can not resolve class ident: type must be a string'
            );
        }

        $capitalize_next = function(&$i) {
            $i = ucfirst($i);
        };

        $capitals = $this->resolverCapitals();
        foreach ($capitals as $cap) {
            $expl = explode($cap, $type);
            array_walk($expl, $capitalize_next);
            $type = implode($cap, $expl);
        }

        $replacements = $this->resolverReplacements();
        foreach ($replacements as $rep => $target) {
            $type = str_replace($rep, $target, $type);
        }

        $class = '\\'.trim($type, '\\');

        // Add prefix + suffix, if applicable
        $class = $this->resolverPrefix().$class.$this->resolverSuffix();

        return $class;
    }

    /**
     * @param string $type The "type" of object to resolve (the object ident).
     * @throws InvalidArgumentException If the type parameter is not a string.
     * @return boolean
     */
    public function isResolvable($type)
    {
        if (!is_string($type)) {
            throw new InvalidArgumentException(
                'Can not check resolvable: type must be a string'
            );
        }

        $class_name = $this->resolve($type);
        return class_exists($class_name);
    }
}