ClassDiscovery::setStrategies() - Code Metrics - Inspection of "Better exception message when we do not find candi..." - php-http/discovery - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#119)

by Tobias

created 2018-12-29 09:28 UTC

ClassDiscovery::setStrategies() A

↳ Parent: ClassDiscovery

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	5
ccs	4
cts	4
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	1

<?php

namespace Http\Discovery;

use Http\Discovery\Exception\ClassInstantiationFailedException;
use Http\Discovery\Exception\DiscoveryFailedException;
use Http\Discovery\Exception\NoCandidateFoundException;
use Http\Discovery\Exception\StrategyUnavailableException;

/**
 * Registry that based find results on class existence.
 *
 * @author David de Boer <[email protected]>
 * @author Márk Sági-Kazár <[email protected]>
 * @author Tobias Nyholm <[email protected]>
 */
abstract class ClassDiscovery
{
    /**
     * A list of strategies to find classes.
     *
     * @var array
     */
    private static $strategies = [
        Strategy\PuliBetaStrategy::class,
        Strategy\CommonClassesStrategy::class,
    ];

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

    /**
     * Finds a class.
     *
     * @param string $type
     *
     * @return string|\Closure
     *
     * @throws DiscoveryFailedException
     */
    protected static function findOneByType($type)
    {
        // Look in the cache
        if (null !== ($class = self::getFromCache($type))) {
            return $class;
        }

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

                continue;
            }

            foreach ($candidates as $candidate) {
                if (isset($candidate['condition'])) {
                    if (!self::evaluateCondition($candidate['condition'])) {
                        continue;
                    }
                }

                // save the result for later use
                self::storeInCache($type, $candidate);

                return $candidate['class'];
            }

            $exceptions[] = new NoCandidateFoundException($strategy, $candidates);
        }

        throw DiscoveryFailedException::create($exceptions);
    }

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

        $candidate = self::$cache[$type];
        if (isset($candidate['condition'])) {
            if (!self::evaluateCondition($candidate['condition'])) {
                return;
            }
        }

        return $candidate['class'];
    }

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

    /**
     * Set new strategies and clear the cache.
     *
     * @param array $strategies string array of fully qualified class name to a DiscoveryStrategy
     */
    public static function setStrategies(array $strategies)
    {
        self::$strategies = $strategies;
        self::clearCache();
    }

    /**
     * Append a strategy at the end of the strategy queue.
     *
     * @param string $strategy Fully qualified class name to a DiscoveryStrategy
     */
    public static function appendStrategy($strategy)
    {
        self::$strategies[] = $strategy;
        self::clearCache();
    }

    /**
     * Prepend a strategy at the beginning of the strategy queue.
     *
     * @param string $strategy Fully qualified class name to a DiscoveryStrategy
     */
    public static function prependStrategy($strategy)
    {
        array_unshift(self::$strategies, $strategy);
        self::clearCache();
    }

    /**
     * Clear the cache.
     */
    public static function clearCache()
    {
        self::$cache = [];
    }

    /**
     * Evaluates conditions to boolean.
     *
     * @param mixed $condition
     *
     * @return bool
     */
    protected static function evaluateCondition($condition)
    {
        if (is_string($condition)) {
            // Should be extended for functions, extensions???
            return self::safeClassExists($condition);
        } elseif (is_callable($condition)) {
            return $condition();
        } elseif (is_bool($condition)) {
            return $condition;
        } elseif (is_array($condition)) {
            // Immediately stop execution if the condition is false
            for ($i = 0; $i < count($condition); ++$i) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                if (false === static::evaluateCondition($condition[$i])) {
                    return false;
                }
            }

            return true;
        }

        return false;
    }

    /**
     * Get an instance of the $class.
     *
     * @param string|\Closure $class A FQCN of a class or a closure that instantiate the class.
     *
     * @return object
     *
     * @throws ClassInstantiationFailedException
     */
    protected static function instantiateClass($class)
    {
        try {
            if (is_string($class)) {
                return new $class();
            }

            if (is_callable($class)) {
                return $class();
            }
        } catch (\Exception $e) {
            throw new ClassInstantiationFailedException('Unexpected exception when instantiating class.', 0, $e);
        }

        throw new ClassInstantiationFailedException('Could not instantiate class because parameter is neither a callable nor a string');
    }

    /**
     * We want to do a "safe" version of PHP's "class_exists" because Magento has a bug
     * (or they call it a "feature"). Magento is throwing an exception if you do class_exists()
     * on a class that ends with "Factory" and if that file does not exits.
     *
     * This function will catch all potential exceptions and make sure it returns a boolean.
     *
     * @param string $class
     * @param bool   $autoload
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     *
     * @return bool
     */
    public static function safeClassExists($class)
    {
        try {
            return class_exists($class);
        } catch (\Exception $e) {
            return false;
        }
    }
}


1		<?php
2
3		namespace Http\Discovery;
4
5		use Http\Discovery\Exception\ClassInstantiationFailedException;
6		use Http\Discovery\Exception\DiscoveryFailedException;
7		use Http\Discovery\Exception\NoCandidateFoundException;
8		use Http\Discovery\Exception\StrategyUnavailableException;
9
10		/**
11		* Registry that based find results on class existence.
12		*
13		* @author David de Boer <[email protected]>
14		* @author Márk Sági-Kazár <[email protected]>
15		* @author Tobias Nyholm <[email protected]>
16		*/
17		abstract class ClassDiscovery
18		{
19		/**
20		* A list of strategies to find classes.
21		*
22		* @var array
23		*/
24		private static $strategies = [
25		Strategy\PuliBetaStrategy::class,
26		Strategy\CommonClassesStrategy::class,
27		];
28
29		/**
30		* Discovery cache to make the second time we use discovery faster.
31		*
32		* @var array
33		*/
34		private static $cache = [];
35
36		/**
37		* Finds a class.
38		*
39		* @param string $type
40		*
41		* @return string\|\Closure
42		*
43		* @throws DiscoveryFailedException
44		*/
45	15	protected static function findOneByType($type)
46		{
47		// Look in the cache
48	15	if (null !== ($class = self::getFromCache($type))) {
49		return $class;
50		}
51
52	15	$exceptions = [];
53	15	foreach (self::$strategies as $strategy) {
54		try {
55	15	$candidates = call_user_func($strategy.'::getCandidates', $type);
56	15	} catch (StrategyUnavailableException $e) {
57		$exceptions[] = $e;
58
59		continue;
60		}
61
62	15	foreach ($candidates as $candidate) {
63	9	if (isset($candidate['condition'])) {
64	7	if (!self::evaluateCondition($candidate['condition'])) {
65	1	continue;
66		}
67	7	}
68
69		// save the result for later use
70	9	self::storeInCache($type, $candidate);
71
72	9	return $candidate['class'];
73	7	}
74
75	7	$exceptions[] = new NoCandidateFoundException($strategy, $candidates);
76	7	}
77
78	6	throw DiscoveryFailedException::create($exceptions);
79		}
80
81		/**
82		* Get a value from cache.
83		*
84		* @param string $type
85		*
86		* @return string\|null
87		*/
88	15	private static function getFromCache($type)
89		{
90	15	if (!isset(self::$cache[$type])) {
91	15	return;
92		}
93
94		$candidate = self::$cache[$type];
95		if (isset($candidate['condition'])) {
96		if (!self::evaluateCondition($candidate['condition'])) {
97		return;
98		}
99		}
100
101		return $candidate['class'];
102		}
103
104		/**
105		* Store a value in cache.
106		*
107		* @param string $type
108		* @param string $class
109		*/
110	9	private static function storeInCache($type, $class)
111		{
112	9	self::$cache[$type] = $class;
113	9	}
114
115		/**
116		* Set new strategies and clear the cache.
117		*
118		* @param array $strategies string array of fully qualified class name to a DiscoveryStrategy
119		*/
120	27	public static function setStrategies(array $strategies)
121		{
122	27	self::$strategies = $strategies;
123	27	self::clearCache();
124	27	}
125
126		/**
127		* Append a strategy at the end of the strategy queue.
128		*
129		* @param string $strategy Fully qualified class name to a DiscoveryStrategy
130		*/
131	1	public static function appendStrategy($strategy)
132		{
133	1	self::$strategies[] = $strategy;
134	1	self::clearCache();
135	1	}
136
137		/**
138		* Prepend a strategy at the beginning of the strategy queue.
139		*
140		* @param string $strategy Fully qualified class name to a DiscoveryStrategy
141		*/
142	1	public static function prependStrategy($strategy)
143		{
144	1	array_unshift(self::$strategies, $strategy);
145	1	self::clearCache();
146	1	}
147
148		/**
149		* Clear the cache.
150		*/
151	27	public static function clearCache()
152		{
153	27	self::$cache = [];
154	27	}
155
156		/**
157		* Evaluates conditions to boolean.
158		*
159		* @param mixed $condition
160		*
161		* @return bool
162		*/
163	7	protected static function evaluateCondition($condition)
164		{
165	7	if (is_string($condition)) {
166		// Should be extended for functions, extensions???
167		return self::safeClassExists($condition);
168	7	} elseif (is_callable($condition)) {
169		return $condition();
170	7	} elseif (is_bool($condition)) {
171	7	return $condition;
172	1	} elseif (is_array($condition)) {
173		// Immediately stop execution if the condition is false
174	1	for ($i = 0; $i < count($condition); ++$i) {
		0 ignored issues – show Performance Best Practice introduced 2018-12-29 07:48 UTC by Report Bug Copy Issue Report It seems like you are calling the size function `count()` as part of the test condition. You might want to compute the size beforehand, and not on each iteration. If the size of the collection does not change during the iteration, it is generally a good practice to compute it beforehand, and not on each iteration: for ($i=0; $i<count($array); $i++) { // calls count() on each iteration } // Better for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once } Loading history...
175	1	if (false === static::evaluateCondition($condition[$i])) {
176	1	return false;
177		}
178	1	}
179
180		return true;
181		}
182
183		return false;
184		}
185
186		/**
187		* Get an instance of the $class.
188		*
189		* @param string\|\Closure $class A FQCN of a class or a closure that instantiate the class.
190		*
191		* @return object
192		*
193		* @throws ClassInstantiationFailedException
194		*/
195	5	protected static function instantiateClass($class)
196		{
197		try {
198	5	if (is_string($class)) {
199	5	return new $class();
200		}
201
202		if (is_callable($class)) {
203		return $class();
204		}
205		} catch (\Exception $e) {
206		throw new ClassInstantiationFailedException('Unexpected exception when instantiating class.', 0, $e);
207		}
208
209		throw new ClassInstantiationFailedException('Could not instantiate class because parameter is neither a callable nor a string');
210		}
211
212		/**
213		* We want to do a "safe" version of PHP's "class_exists" because Magento has a bug
214		* (or they call it a "feature"). Magento is throwing an exception if you do class_exists()
215		* on a class that ends with "Factory" and if that file does not exits.
216		*
217		* This function will catch all potential exceptions and make sure it returns a boolean.
218		*
219		* @param string $class
220		* @param bool $autoload
		0 ignored issues – show Bug introduced 2018-08-17 12:15 UTC by Report Bug Copy Issue Report There is no parameter named `$autoload`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
221		*
222		* @return bool
223		*/
224		public static function safeClassExists($class)
225		{
226		try {
227		return class_exists($class);
228		} catch (\Exception $e) {
229		return false;
230		}
231		}
232		}
233

php-http / discovery

Pull Request — master (#119)

ClassDiscovery::setStrategies() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like