PHPFeature - Code Metrics - Inspection of "Update change log." - brightnucleus/phpfeature - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( b0e99a...74682a )

by Alain

created 2016-03-31 17:17 UTC

PHPFeature C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	366
Duplicated Lines	17.21 %

Coupling/Cohesion

Components	2
Dependencies	4

Test Coverage

Coverage

77.48%

Importance

Changes	5
Bugs	0	Features	2

Metric	Value
wmc	56
c	5
b	0
f	2
lcom	2
cbo	4
dl	63
loc	366
ccs	86
cts	111
cp	0.7748
rs	6.5957

10 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	24	5
B	isSupported()	4	23	5
B	getMinimumRequired()	4	24	5
B	checkSupport()	0	18	5
C	checkRequirement()	0	30	8
C	getRequiredVersion()	0	27	13
A	getGreaterThanVersion()	11	11	3
A	getLesserThanVersion()	14	14	4
A	getGreaterEqualVersion()	15	15	4
A	getLesserEqualVersion()	15	15	4

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like PHPFeature often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use PHPFeature, and based on these observations, apply Extract Interface, too.

<?php
/**
 * PHPFeature Class.
 *
 * @package   brightnucleus/phpfeature
 * @author    Alain Schlesser <[email protected]>
 * @license   MIT
 * @link      http://www.brightnucleus.com/
 * @copyright 2016 Alain Schlesser, Bright Nucleus
 */

use BrightNucleus_Config as Config;
use BrightNucleus_ConfigInterface as ConfigInterface;
use PHPFeature_SemanticVersion as SemanticVersion;

/**
 * Class PHPFeature.
 *
 * The main PHP Feature implementation of the `FeatureInterface`.
 *
 * @since  0.1.0
 *
 * @author Alain Schlesser <[email protected]>
 */
class PHPFeature implements FeatureInterface
{

    /**
     * RegEx pattern that matches the comparison string.
     *
     * @since 0.1.0
     *
     * @var string
     */
    const COMPARISON_PATTERN = '/^(?:(<=|lt|<|le|>=|gt|>|ge|=|==|eq|!=|<>|ne))([0-9].*)$/';

    /**
     * Reference to the Configuration object.
     *
     * @since 0.1.0
     *
     * @var ConfigInterface
     */
    protected $config;

    /**
     * Reference to the Version object.
     *
     * @since 0.1.0
     *
     * @var SemanticVersion
     */
    protected $version;

    /**
     * Reference to the PHP releases.
     *
     * @since 0.2.4
     *
     * @var PHPReleases
     */
    protected $releases;

    /**
     * Instantiate a PHPFeature object.
     *
     * @since 0.1.0
     *
     * @param SemanticVersion|string|int|null $phpVersion Version of PHP to check the features for.
     * @param ConfigInterface|null            $config     Configuration that contains the known features.
     *
     * @throws RuntimeException If the PHP version could not be validated.
     */
    public function __construct($phpVersion = null, ConfigInterface $config = null)
    {

        // TODO: Better way to bootstrap this while still allowing DI?

        if ( ! $config) {
            $config = new Config(include(dirname(__FILE__) . '/../config/known_features.php'));
        }

        $this->config = $config;

        if (null === $phpVersion) {
            $phpVersion = phpversion();
        }

        if (is_int($phpVersion)) {
            $phpVersion = (string)$phpVersion;
        }

        if (is_string($phpVersion)) {
            $phpVersion = new SemanticVersion($phpVersion, true);
        }

        $this->version = $phpVersion;
    }

    /**
     * Check whether a feature or a collection of features is supported.
     *
     * Accepts either a string or an array of strings. Returns true if all the passed-in features are supported, or
     * false if at least one of them is not.
     *
     * @since 0.1.0
     *
     * @param string|array $features What features to check the support of.
     *
     * @return bool Whether the set of features as a whole is supported.
     * @throws InvalidArgumentException If the wrong type of argument is passed in.
     * @throws RuntimeException         If a requirement could not be parsed.
     */
    public function isSupported($features)
    {

        if (is_string($features)) {
            $features = array($features);
        }

        if ( ! is_array($features)) {
            throw new InvalidArgumentException(sprintf(
                'Wrong type of argument passed in to is_supported(): "%1$s".',
                gettype($features)
            ));
        }

        $isSupported = true;

        while ($isSupported && count($features) > 0) {

            $feature = array_pop($features);
            $isSupported &= (bool)$this->checkSupport($feature);
        }

        return (bool)$isSupported;
    }

    /**
     * Get the minimum required version that supports all of the requested features.
     *
     * Accepts either a string or an array of strings. Returns a SemanticVersion object for the version number that is
     * known to support all the passed-in features, or false if at least one of them is not supported by any known
     * version.
     *
     * @since 0.2.0
     *
     * @param string|array $features What features to check the support of.
     *
     * @return SemanticVersion|false SemanticVersion object for the version number that is known to support all the
     *                               passed-in features, false if none.
     * @throws InvalidArgumentException If the wrong type of argument is passed in.
     * @throws RuntimeException         If a requirement could not be parsed.
     */
    public function getMinimumRequired($features)
    {

        if (is_string($features)) {
            $features = array($features);
        }

        if ( ! is_array($features)) {
            throw new InvalidArgumentException(sprintf(
                'Wrong type of argument passed in to get_minimum_required(): "%1$s".',
                gettype($features)
            ));
        }

        $minimumRequired = '0.0.0';
        $isSupported     = true;

        while (count($features) > 0) {

            $feature = array_pop($features);
            $isSupported &= (bool)$this->checkSupport($feature, $minimumRequired);
        }

        return $minimumRequired !== '0.0.0' ? new SemanticVersion($minimumRequired, true) : false;
    }

    /**
     * Check whether a single feature is supported.
     *
     * @since 0.1.0
     *
     * @param string      $feature         The feature to check.
     * @param string|null $minimumRequired Optional. Minimum required version that supports all features.
     *
     * @return bool Whether the requested feature is supported.
     * @throws RuntimeException If the requirement could not be parsed.
     */
    protected function checkSupport($feature, &$minimumRequired = null)
    {

        if ( ! $this->config->hasKey($feature)) {
            return false;
        }

        $requirements = (array)$this->config->getKey($feature);

        $isSupported = true;

        while (($isSupported || null !== $minimumRequired) && count($requirements) > 0) {
            $requirement = array_pop($requirements);
            $isSupported &= (bool)$this->checkRequirement($requirement, $minimumRequired);
        }

        return (bool)$isSupported;
    }

    /**
     * Check whether a single requirement is met.
     *
     * @since 0.1.0
     *
     * @param string      $requirement     A requirement that is composed of an operator and a version milestone.
     * @param string|null $minimumRequired Optional. Minimum required version that supports all features.
     *
     * @return bool Whether the requirement is met.
     * @throws RuntimeException If the requirement could not be parsed.
     */
    protected function checkRequirement($requirement, &$minimumRequired = null)
    {

        $requirement = trim($requirement);
        $pattern     = self::COMPARISON_PATTERN;

        $arguments = array();
        $result    = preg_match($pattern, $requirement, $arguments);

        if ( ! $result || ! isset($arguments[1]) || ! isset($arguments[2])) {
            throw new RuntimeException(sprintf(
                'Could not parse the requirement "%1$s".',
                (string)$requirement
            ));
        }

        $operator  = isset($arguments[1]) ? (string)$arguments[1] : '>=';
        $milestone = isset($arguments[2]) ? (string)$arguments[2] : '0.0.0';

        $isSupported = (bool)version_compare($this->version->getVersion(), $milestone, $operator);

        if (null !== $minimumRequired) {
            $requiredVersion = $this->getRequiredVersion($milestone, $operator);
            if (version_compare($requiredVersion, $minimumRequired, '>')) {
                $minimumRequired = $requiredVersion;
            }
        }

        return $isSupported;
    }

    /**
     * Get the required version for a single requirement.
     *
     * @todo  The entire algorithm is only an approximation. A 5.2 SemVer library is needed.

     *
     * @since 0.2.0
     *
     * @param string $milestone A version milestone that is used to define the requirement.
     * @param string $operator  An operator that gets applied to the milestone.
     *                          Possible values: '<=', 'lt', '<', 'le', '>=', 'gt', '>', 'ge', '=', '==', 'eq', '!=',
     *                          '<>', 'ne'
     *
     * @return string Version string that meets a single requirement.

     * @throws RuntimeException If the requirement could not be satisfied.
     * @throws RuntimeException If the NotEqual is used.
     */
    protected function getRequiredVersion($milestone, $operator)
    {
        if (null === $this->releases) {
            $this->releases = new PHPReleases();
        }

        switch ($operator) {
            case '>':
            case 'gt':
                return $this->getGreaterThanVersion($milestone);
            case '<':
            case 'lt':
                return $this->getLesserThanVersion($milestone);
            case '>=':
            case 'ge':
                return $this->getGreaterEqualVersion($milestone);
            case '<=':
            case 'le':
                return $this->getLesserEqualVersion($milestone);
            case '!=':
            case '<>':
            case 'ne':
                throw new RuntimeException('NotEqual operator is not implemented.');
        }

        return $milestone;
    }

    /**
     * Get a version greater than the milestone.
     *
     * @since 0.2.4
     *
     * @param string $milestone A version milestone that is used to define the requirement.
     *
     * @return string Version number that meets the requirement.

     * @throws RuntimeException If the requirement could not be satisfied.
     */
    protected function getGreaterThanVersion($milestone)

    {
        $data = $this->releases->getAll();
        foreach ($data as $version => $date) {
            if (version_compare($version, $milestone, '>')) {
                return $version;
            }
        }

        throw new RuntimeException('Could not satisfy version requirements.');
    }

    /**
     * Get a version lesser than the milestone.
     *
     * @since 0.2.4
     *
     * @param string $milestone A version milestone that is used to define the requirement.
     *
     * @return string Version number that meets the requirement.

     * @throws RuntimeException If the requirement could not be satisfied.
     */
    protected function getLesserThanVersion($milestone)

    {
        if (version_compare($this->version->getVersion(), $milestone, '<')) {
            return $this->version->getVersion();
        }
        $data = array_reverse($this->releases->getAll());
        foreach ($data as $version => $date) {
            if (version_compare($version, $milestone, '<')) {
                return $version;
            }
        }

        throw new RuntimeException('Could not satisfy version requirements.');
    }

    /**
     * Get a version greater or equal than the milestone.
     *
     * @since 0.2.4
     *
     * @param string $milestone A version milestone that is used to define the requirement.
     *
     * @return string Version number that meets the requirement.

     */
    protected function getGreaterEqualVersion($milestone)

    {
        if ($this->releases->exists($milestone)) {
            return $milestone;
        }

        $data = $this->releases->getAll();
        foreach ($data as $version => $date) {
            if (version_compare($version, $milestone, '>=')) {
                return $version;
            }
        }

        throw new RuntimeException('Could not satisfy version requirements.');
    }

    /**
     * Get a version lesser or equal than the milestone.
     *
     * @since 0.2.4
     *
     * @param string $milestone A version milestone that is used to define the requirement.
     *
     * @return string Version number that meets the requirement.

     */
    protected function getLesserEqualVersion($milestone)

    {
        if (version_compare($this->version->getVersion(), $milestone, '<=')) {
            return $this->version->getVersion();
        }

        $data = array_reverse($this->releases->getAll());
        foreach ($data as $version => $date) {
            if (version_compare($version, $milestone, '<=')) {
                return $version;
            }
        }

        throw new RuntimeException('Could not satisfy version requirements.');
    }
}


1			<?php
2			/**
3			* PHPFeature Class.
4			*
5			* @package brightnucleus/phpfeature
6			* @author Alain Schlesser <[email protected]>
7			* @license MIT
8			* @link http://www.brightnucleus.com/
9			* @copyright 2016 Alain Schlesser, Bright Nucleus
10			*/
11
12			use BrightNucleus_Config as Config;
13			use BrightNucleus_ConfigInterface as ConfigInterface;
14			use PHPFeature_SemanticVersion as SemanticVersion;
15
16			/**
17			* Class PHPFeature.
18			*
19			* The main PHP Feature implementation of the `FeatureInterface`.
20			*
21			* @since 0.1.0
22			*
23			* @author Alain Schlesser <[email protected]>
24			*/
25			class PHPFeature implements FeatureInterface
26			{
27
28			/**
29			* RegEx pattern that matches the comparison string.
30			*
31			* @since 0.1.0
32			*
33			* @var string
34			*/
35			const COMPARISON_PATTERN = '/^(?:(<=\|lt\|<\|le\|>=\|gt\|>\|ge\|=\|==\|eq\|!=\|<>\|ne))([0-9].*)$/';
36
37			/**
38			* Reference to the Configuration object.
39			*
40			* @since 0.1.0
41			*
42			* @var ConfigInterface
43			*/
44			protected $config;
45
46			/**
47			* Reference to the Version object.
48			*
49			* @since 0.1.0
50			*
51			* @var SemanticVersion
52			*/
53			protected $version;
54
55			/**
56			* Reference to the PHP releases.
57			*
58			* @since 0.2.4
59			*
60			* @var PHPReleases
61			*/
62			protected $releases;
63
64			/**
65			* Instantiate a PHPFeature object.
66			*
67			* @since 0.1.0
68			*
69			* @param SemanticVersion\|string\|int\|null $phpVersion Version of PHP to check the features for.
70			* @param ConfigInterface\|null $config Configuration that contains the known features.
71			*
72			* @throws RuntimeException If the PHP version could not be validated.
73			*/
74	66		public function __construct($phpVersion = null, ConfigInterface $config = null)
75			{
76
77			// TODO: Better way to bootstrap this while still allowing DI?
			0 ignored issues – show Coding Style Best Practice introduced 2016-02-10 08:00 UTC by Report Bug Copy Issue Report Comments for TODO tasks are often forgotten in the code; it might be better to use a dedicated issue tracker. Loading history...
78	66		if ( ! $config) {
79	46		$config = new Config(include(dirname(__FILE__) . '/../config/known_features.php'));
80			}
81
82	66		$this->config = $config;
83
84	66		if (null === $phpVersion) {
85			$phpVersion = phpversion();
86			}
87
88	66		if (is_int($phpVersion)) {
89			$phpVersion = (string)$phpVersion;
90			}
91
92	66		if (is_string($phpVersion)) {
93	66		$phpVersion = new SemanticVersion($phpVersion, true);
94			}
95
96	66		$this->version = $phpVersion;
97	66		}
98
99			/**
100			* Check whether a feature or a collection of features is supported.
101			*
102			* Accepts either a string or an array of strings. Returns true if all the passed-in features are supported, or
103			* false if at least one of them is not.
104			*
105			* @since 0.1.0
106			*
107			* @param string\|array $features What features to check the support of.
108			*
109			* @return bool Whether the set of features as a whole is supported.
110			* @throws InvalidArgumentException If the wrong type of argument is passed in.
111			* @throws RuntimeException If a requirement could not be parsed.
112			*/
113	23		public function isSupported($features)
114			{
115
116	23		if (is_string($features)) {
117	21		$features = array($features);
118			}
119
120	23		if ( ! is_array($features)) {
121			throw new InvalidArgumentException(sprintf(
122			'Wrong type of argument passed in to is_supported(): "%1$s".',
123			gettype($features)
124			));
125			}
126
127	23		$isSupported = true;
128
129	23	View Code Duplication	while ($isSupported && count($features) > 0) {
			0 ignored issues – show Duplication introduced 2016-02-10 07:43 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
130	23		$feature = array_pop($features);
131	23		$isSupported &= (bool)$this->checkSupport($feature);
132			}
133
134	23		return (bool)$isSupported;
135			}
136
137			/**
138			* Get the minimum required version that supports all of the requested features.
139			*
140			* Accepts either a string or an array of strings. Returns a SemanticVersion object for the version number that is
141			* known to support all the passed-in features, or false if at least one of them is not supported by any known
142			* version.
143			*
144			* @since 0.2.0
145			*
146			* @param string\|array $features What features to check the support of.
147			*
148			* @return SemanticVersion\|false SemanticVersion object for the version number that is known to support all the
149			* passed-in features, false if none.
150			* @throws InvalidArgumentException If the wrong type of argument is passed in.
151			* @throws RuntimeException If a requirement could not be parsed.
152			*/
153	43		public function getMinimumRequired($features)
154			{
155
156	43		if (is_string($features)) {
157	41		$features = array($features);
158			}
159
160	43		if ( ! is_array($features)) {
161			throw new InvalidArgumentException(sprintf(
162			'Wrong type of argument passed in to get_minimum_required(): "%1$s".',
163			gettype($features)
164			));
165			}
166
167	43		$minimumRequired = '0.0.0';
168	43		$isSupported = true;
169
170	43	View Code Duplication	while (count($features) > 0) {
			0 ignored issues – show Duplication introduced 2016-02-09 18:31 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
171	43		$feature = array_pop($features);
172	43		$isSupported &= (bool)$this->checkSupport($feature, $minimumRequired);
173			}
174
175	43		return $minimumRequired !== '0.0.0' ? new SemanticVersion($minimumRequired, true) : false;
176			}
177
178			/**
179			* Check whether a single feature is supported.
180			*
181			* @since 0.1.0
182			*
183			* @param string $feature The feature to check.
184			* @param string\|null $minimumRequired Optional. Minimum required version that supports all features.
185			*
186			* @return bool Whether the requested feature is supported.
187			* @throws RuntimeException If the requirement could not be parsed.
188			*/
189	66		protected function checkSupport($feature, &$minimumRequired = null)
190			{
191
192	66		if ( ! $this->config->hasKey($feature)) {
193	2		return false;
194			}
195
196	64		$requirements = (array)$this->config->getKey($feature);
197
198	64		$isSupported = true;
199
200	64		while (($isSupported \|\| null !== $minimumRequired) && count($requirements) > 0) {
201	64		$requirement = array_pop($requirements);
202	64		$isSupported &= (bool)$this->checkRequirement($requirement, $minimumRequired);
203			}
204
205	64		return (bool)$isSupported;
206			}
207
208			/**
209			* Check whether a single requirement is met.
210			*
211			* @since 0.1.0
212			*
213			* @param string $requirement A requirement that is composed of an operator and a version milestone.
214			* @param string\|null $minimumRequired Optional. Minimum required version that supports all features.
215			*
216			* @return bool Whether the requirement is met.
217			* @throws RuntimeException If the requirement could not be parsed.
218			*/
219	64		protected function checkRequirement($requirement, &$minimumRequired = null)
220			{
221
222	64		$requirement = trim($requirement);
223	64		$pattern = self::COMPARISON_PATTERN;
224
225	64		$arguments = array();
226	64		$result = preg_match($pattern, $requirement, $arguments);
227
228	64		if ( ! $result \|\| ! isset($arguments[1]) \|\| ! isset($arguments[2])) {
229			throw new RuntimeException(sprintf(
230			'Could not parse the requirement "%1$s".',
231			(string)$requirement
232			));
233			}
234
235	64		$operator = isset($arguments[1]) ? (string)$arguments[1] : '>=';
236	64		$milestone = isset($arguments[2]) ? (string)$arguments[2] : '0.0.0';
237
238	64		$isSupported = (bool)version_compare($this->version->getVersion(), $milestone, $operator);
239
240	64		if (null !== $minimumRequired) {
241	42		$requiredVersion = $this->getRequiredVersion($milestone, $operator);
242	42		if (version_compare($requiredVersion, $minimumRequired, '>')) {
243	42		$minimumRequired = $requiredVersion;
244			}
245			}
246
247	64		return $isSupported;
248			}
249
250			/**
251			* Get the required version for a single requirement.
252			*
253			* @todo The entire algorithm is only an approximation. A 5.2 SemVer library is needed.
			0 ignored issues – show Coding Style introduced 2016-03-31 16:46 UTC by Report Bug Copy Issue Report Comment refers to a TODO task This check looks `TODO` comments that have been left in the code. ``TODO``s show that something is left unfinished and should be attended to. Loading history...
254			*
255			* @since 0.2.0
256			*
257			* @param string $milestone A version milestone that is used to define the requirement.
258			* @param string $operator An operator that gets applied to the milestone.
259			* Possible values: '<=', 'lt', '<', 'le', '>=', 'gt', '>', 'ge', '=', '==', 'eq', '!=',
260			* '<>', 'ne'
261			*
262			* @return string Version string that meets a single requirement.
			0 ignored issues – show Documentation introduced 2016-03-31 16:46 UTC by Report Bug Copy Issue Report Should the return type not be `integer\|string`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
263			* @throws RuntimeException If the requirement could not be satisfied.
264			* @throws RuntimeException If the NotEqual is used.
265			*/
266	42		protected function getRequiredVersion($milestone, $operator)
267			{
268	42		if (null === $this->releases) {
269	42		$this->releases = new PHPReleases();
270			}
271
272			switch ($operator) {
273	42		case '>':
274			case 'gt':
275	4		return $this->getGreaterThanVersion($milestone);
276			case '<':
277			case 'lt':
278	6		return $this->getLesserThanVersion($milestone);
279			case '>=':
280			case 'ge':
281	26		return $this->getGreaterEqualVersion($milestone);
282			case '<=':
283			case 'le':
284	6		return $this->getLesserEqualVersion($milestone);
285			case '!=':
286			case '<>':
287			case 'ne':
288			throw new RuntimeException('NotEqual operator is not implemented.');
289			}
290
291			return $milestone;
292			}
293
294			/**
295			* Get a version greater than the milestone.
296			*
297			* @since 0.2.4
298			*
299			* @param string $milestone A version milestone that is used to define the requirement.
300			*
301			* @return string Version number that meets the requirement.
			0 ignored issues – show Documentation introduced 2016-03-31 16:46 UTC by Report Bug Copy Issue Report Should the return type not be `integer\|string`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
302			* @throws RuntimeException If the requirement could not be satisfied.
303			*/
304	4	View Code Duplication	protected function getGreaterThanVersion($milestone)
			0 ignored issues – show Duplication introduced 2016-03-31 16:46 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
305			{
306	4		$data = $this->releases->getAll();
307	4		foreach ($data as $version => $date) {
308	4		if (version_compare($version, $milestone, '>')) {
309	4		return $version;
310			}
311			}
312
313			throw new RuntimeException('Could not satisfy version requirements.');
314			}
315
316			/**
317			* Get a version lesser than the milestone.
318			*
319			* @since 0.2.4
320			*
321			* @param string $milestone A version milestone that is used to define the requirement.
322			*
323			* @return string Version number that meets the requirement.
			0 ignored issues – show Documentation introduced 2016-03-31 17:19 UTC by Report Bug Copy Issue Report Should the return type not be `string\|integer`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
324			* @throws RuntimeException If the requirement could not be satisfied.
325			*/
326	6	View Code Duplication	protected function getLesserThanVersion($milestone)
			0 ignored issues – show Duplication introduced 2016-03-31 16:46 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
327			{
328	6		if (version_compare($this->version->getVersion(), $milestone, '<')) {
329	4		return $this->version->getVersion();
330			}
331	2		$data = array_reverse($this->releases->getAll());
332	2		foreach ($data as $version => $date) {
333	2		if (version_compare($version, $milestone, '<')) {
334	2		return $version;
335			}
336			}
337
338			throw new RuntimeException('Could not satisfy version requirements.');
339			}
340
341			/**
342			* Get a version greater or equal than the milestone.
343			*
344			* @since 0.2.4
345			*
346			* @param string $milestone A version milestone that is used to define the requirement.
347			*
348			* @return string Version number that meets the requirement.
			0 ignored issues – show Documentation introduced 2016-03-31 16:46 UTC by Report Bug Copy Issue Report Should the return type not be `string\|integer`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
349			*/
350	26	View Code Duplication	protected function getGreaterEqualVersion($milestone)
			0 ignored issues – show Duplication introduced 2016-03-31 17:19 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
351			{
352	26		if ($this->releases->exists($milestone)) {
353	25		return $milestone;
354			}
355
356	1		$data = $this->releases->getAll();
357	1		foreach ($data as $version => $date) {
358	1		if (version_compare($version, $milestone, '>=')) {
359	1		return $version;
360			}
361			}
362
363			throw new RuntimeException('Could not satisfy version requirements.');
364			}
365
366			/**
367			* Get a version lesser or equal than the milestone.
368			*
369			* @since 0.2.4
370			*
371			* @param string $milestone A version milestone that is used to define the requirement.
372			*
373			* @return string Version number that meets the requirement.
			0 ignored issues – show Documentation introduced 2016-03-31 16:46 UTC by Report Bug Copy Issue Report Should the return type not be `string\|integer`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
374			*/
375	6	View Code Duplication	protected function getLesserEqualVersion($milestone)
			0 ignored issues – show Duplication introduced 2016-03-31 17:19 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
376			{
377	6		if (version_compare($this->version->getVersion(), $milestone, '<=')) {
378	4		return $this->version->getVersion();
379			}
380
381	2		$data = array_reverse($this->releases->getAll());
382	2		foreach ($data as $version => $date) {
383	2		if (version_compare($version, $milestone, '<=')) {
384	2		return $version;
385			}
386			}
387
388			throw new RuntimeException('Could not satisfy version requirements.');
389			}
390			}
391

brightnucleus / phpfeature