Http\Discovery\ClassDiscovery

Complexity

Total Complexity

17

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

72.72%

Importance

Changes	13
Bugs	2	Features	4

4 Methods

Rating	Name	Duplication	Size	Complexity
C	findOneByType()	0	32	7
A	getFromCache()	0	8	2
A	storeInCache()	0	4	1
C	evaluateCondition()	0	22	7

<?php

namespace Http\Discovery;

use Http\Discovery\Exception\DiscoveryFailedException;
use Http\Discovery\Exception\StrategyUnavailableException;
use Http\Discovery\Exception\NotFoundException;
use Http\Discovery\Strategy\DiactorosFactory;
use Http\Discovery\Strategy\GuzzleFactory;
use Http\Discovery\Strategy\HttpClients;
use Http\Discovery\Strategy\Puli;

/**
 * Registry that based find results on class existence.
 *
 * @author David de Boer <david@ddeboer.nl>
 * @author Márk Sági-Kazár <mark.sagikazar@gmail.com>
 * @author Tobias Nyholm <tobias.nyholm@gmail.com>
 */
abstract class ClassDiscovery
{
    /**
     * A list of strategies to find classes.
     *
     * @var array
     */
    public static $strategies = [
        Puli::class,
        HttpClients::class,
        GuzzleFactory::class,
        DiactorosFactory::class,
    ];

    /**
     * Discovery cache to make the second time we use discovery faster.
     *
     * @var array
     */
    private static $cache = [];

    /**
     * Finds a class.
     *
     * @param $type
     *
     * @return string
     *
     * @throws NotFoundException
     */
    public static function findOneByType($type)
    {
        $exceptions = [];

        if (null !== $class = self::getFromCache($type)) {
            return $class;
        }

        foreach (self::$strategies as $strategy) {
            try {
                $bindings = call_user_func($strategy.'::find', $type);
            } catch (StrategyUnavailableException $e) {
                $exceptions[] = $e;
                continue;
            }

            foreach ($bindings as $binding) {
                if ($binding['condition']) {
                    if (!self::evaluateCondition($binding['condition'])) {
                        continue;
                    }
                }

                // save the result for later use
                self::storeInCache($type, $binding['class']);

                return $binding['class'];
            }
        }

        throw new DiscoveryFailedException('Could not find resource using any discovery strategy', $exceptions);
    }

    /**
     * Get a value from cache.
     *
     * @param string $type
     *
     * @return string|null
     */
    private static function getFromCache($type)
    {
        if (isset(self::$cache[$type])) {
            return self::$cache[$type];
        }

        return;
    }

    /**
     * Store a value in cache.
     *
     * @param string $type
     * @param string $class
     */
    private static function storeInCache($type, $class)
    {
        self::$cache[$type] = $class;
    }

    /**
     * Evaulates conditions to boolean.
     *
     * @param mixed $condition
     *
     * @return bool
     */
    protected static function evaluateCondition($condition)
    {
        if (is_string($condition)) {
            // Should be extended for functions, extensions???
            return class_exists($condition);
        } elseif (is_callable($condition)) {
            return $condition();
        } elseif (is_bool($condition)) {
            return $condition;
        } elseif (is_array($condition)) {
            $evaluatedCondition = true;

            // Immediately stop execution if the condition is false
            for ($i = 0; $i < count($condition) && false !== $evaluatedCondition; ++$i) {
                $evaluatedCondition &= static::evaluateCondition($condition[$i]);
            }

            return $evaluatedCondition;
        }

        return false;
    }
}