hiqdev\composerassetplugin\Constraint

Complexity

Total Complexity

22

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

58.97%

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	merge()	0	14	4
A	isWeaker()	0	4	2
A	startsWith()	0	3	2
A	endsWith()	0	3	3
A	isEmpty()	0	4	3
A	findMax()	0	19	4
A	toNum()	0	10	4

<?php

/*
 * Composer plugin for bower/npm assets
 *
 * @link      https://github.com/hiqdev/composer-asset-plugin
 * @package   composer-asset-plugin
 * @license   BSD-3-Clause
 * @copyright Copyright (c) 2015-2016, HiQDev (http://hiqdev.com/)
 */

namespace hiqdev\composerassetplugin;

/**
 * Constraint helper class.
 *
 * @author Andrii Vasyliev <sol@hiqdev.com>
 */
class Constraint
{
    /**
     * Merges two constraints.
     * Doesn't resolve version conflicts.
     * @param $a
     * @param $b
     * @return string
     */
    static public function merge($a, $b)

As per PSR2, the static declaration should come after the visibility declaration.

    {
        $a = trim($a);
        $b = trim($b);
        var_dump("a:$a b:$b");

var_dump("a:{$a} b:{$b}"); looks like debug code. Are you sure you do not want to remove it? This might expose sensitive data.

        if ($a === $b || static::isWeaker($b, $a)) {
            return $a;
        } elseif (static::isWeaker($a, $b)) {
            return $b;
        } else {
            return $a . ' ' . $b;
        }
    }

    /**
     * Check if $a is weaker condition then $b, like:
     * - a="*"         b="2.2"
     * - a="2.2 | 3.3" b="2.2"
     * - a="1.1 | 2.2" b="2.2"
     * Possible optimization.
     * // TODO Rename and implement.
     * @param string $a
     * @param string $b
     * @return boolean
     */
    static public function isWeaker($a, $b)

As per PSR2, the static declaration should come after the visibility declaration.

    {
        return static::isEmpty($a) || static::startsWith($a, $b . ' |') | static::endsWith($a, '| ' . $b);
    }

    static public function startsWith($haystack, $needle) {

As per PSR2, the static declaration should come after the visibility declaration.

        return $needle === "" || strrpos($haystack, $needle, -strlen($haystack)) !== false;
    }

    static public function endsWith($haystack, $needle) {

As per PSR2, the static declaration should come after the visibility declaration.

        return $needle === "" || (($temp = strlen($haystack) - strlen($needle)) >= 0 && strpos($haystack, $needle, $temp) !== false);
    }

    /**
     * Checks whether the $version represents any possible version.
     *
     * @param string $version
     * @return boolean
     */
    static public function isEmpty($version)

As per PSR2, the static declaration should come after the visibility declaration.

    {
        return $version === '' || $version === '*' || $version === '>=0.0.0';
    }

    static public function findMax(array $versions)

As per PSR2, the static declaration should come after the visibility declaration.

    {
        $versions = array_unique(array_values($versions));
        if (count($versions)<2) {
            return reset($versions);
        }
        $max = $versions[0];
        $maxNum = static::toNum($max);
        for ($i=1; $i<= count($versions); $i++) {

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.

            $cur = $versions[$i];
            $curNum = static::toNum($cur);
            if ($curNum > $maxNum) {
                $max = $cur;
                $maxNum = $curNum;
            }
        }

        return $max;
    }

    static public function toNum($version)

As per PSR2, the static declaration should come after the visibility declaration.

    {
        $version = preg_replace('/[^0-9\.]/', '', $version);
        $nums = explode('.', $version);
        $n1 = isset($nums[0]) ? $nums[0] : 0;
        $n2 = isset($nums[1]) ? $nums[1] : 0;
        $n3 = isset($nums[2]) ? $nums[2] : 0;

        return (($n1*1000) + $n2)*1000 + $n3;
    }

}