Http\Discovery\ClassDiscovery

Complexity

Total Complexity

27

Size/Duplication

Total Lines	170
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

57.8%

Importance

Changes	11
Bugs	2	Features	4

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getPuliFactory()	0	18	4
A	setPuliFactory()	0	9	3
A	resetPuliFactory()	0	5	1
A	getPuliDiscovery()	0	11	2
B	findOneByType()	0	15	5
A	puliFindOneByType()	0	19	4
A	find()	0	4	1
C	evaluateCondition()	0	22	7

<?php

namespace Http\Discovery;

use Http\Discovery\Exception\NotFoundException;
use Http\Discovery\Exception\PuliNotAvailableException;
use Http\Discovery\FallbackStrategy\HttpClients;
use Http\Discovery\FallbackStrategy\DiactorosFactory;
use Http\Discovery\FallbackStrategy\GuzzleFactory;
use Puli\Discovery\Api\Discovery;

/**
 * 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>
 */
abstract class ClassDiscovery
{
    /**
     * @var GeneratedPuliFactory
     */
    private static $puliFactory;

    /**
     * @var Discovery
     */
    private static $puliDiscovery;

    /**
     * @return GeneratedPuliFactory
     */
    public static function getPuliFactory()
    {
        if (null === self::$puliFactory) {
            if (!defined('PULI_FACTORY_CLASS')) {
                throw new PuliNotAvailableException('Puli Factory is not available');
            }

            $puliFactoryClass = PULI_FACTORY_CLASS;

            if (!class_exists($puliFactoryClass)) {
                throw new PuliNotAvailableException('Puli Factory class does not exist');
            }

            self::$puliFactory = new $puliFactoryClass();
        }

        return self::$puliFactory;
    }

    /**
     * Sets the Puli factory.
     *
     * @param object $puliFactory
     */
    public static function setPuliFactory($puliFactory)
    {
        if (!is_callable([$puliFactory, 'createRepository']) || !is_callable([$puliFactory, 'createDiscovery'])) {
            throw new \InvalidArgumentException('The Puli Factory must expose a repository and a discovery');
        }

        self::$puliFactory = $puliFactory;
        self::$puliDiscovery = null;
    }

    /**
     * Resets the factory.
     */
    public static function resetPuliFactory()
    {
        self::$puliFactory = null;
        self::$puliDiscovery = null;
    }

    /**
     * Returns the Puli discovery layer.
     *
     * @return Discovery
     */
    public static function getPuliDiscovery()
    {
        if (!isset(self::$puliDiscovery)) {
            $factory = self::getPuliFactory();
            $repository = $factory->createRepository();

            self::$puliDiscovery = $factory->createDiscovery($repository);
        }

        return self::$puliDiscovery;
    }

    /**
     * Finds a class.
     *
     * @param $type
     *
     * @return string
     *
     * @throws NotFoundException
     */
    public static function findOneByType($type)
    {
        try {
            return self::puliFindOneByType($type);
        } catch (PuliNotAvailableException $e) {
            if (false !== $class = HttpClients::findOneByType($type)) {
                return $class;
            } elseif (false !== $class = GuzzleFactory::findOneByType($type)) {
                return $class;
            } elseif (false !== $class = DiactorosFactory::findOneByType($type)) {
                return $class;
            }
            throw new NotFoundException('Could not find resource using Puli nor common Guzzle/Diactoros classes', 0, $e);
        }
    }

    /**
     * Finds a class using Puli.
     *
     * @param $type
     *
     * @return string
     *
     * @throws NotFoundException
     * @throws PuliNotAvailableException
     */
    private static function puliFindOneByType($type)
    {
        $bindings = self::getPuliDiscovery()->findBindings($type);

        foreach ($bindings as $binding) {
            if ($binding->hasParameterValue('depends')) {
                $dependency = $binding->getParameterValue('depends');

                if (!self::evaluateCondition($dependency)) {
                    continue;
                }
            }

            // TODO: check class binding
            return $binding->getClassName();

It seems like you code against a concrete implementation and not the interface Puli\Discovery\Api\Binding\Binding as the method getClassName() does only exist in the following implementations of said interface: Puli\Discovery\Binding\ClassBinding.

        }

        throw new NotFoundException(sprintf('Resource of type "%s" not found', $type));
    }

    /**
     * Finds a resource.
     *
     * @return object
     */
    public static function find()
    {
        throw new \LogicException('Not implemented');
    }

    /**
     * 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;
    }
}