Seboettg\CiteProc\Util\NumberHelper

Complexity

Total Complexity

36

Size/Duplication

Total Lines	176
Duplicated Lines	0 %

Test Coverage

Coverage

85.71%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getCompareNumber()	0	12	6
A	dec2roman()	0	13	3
A	extractNumber()	0	6	2
A	isRomanRange()	0	11	4
A	roman2Dec()	0	22	6
A	evaluateStringPluralism()	0	14	5
A	isRange()	0	13	6
A	isRomanNumber()	0	10	3
A	splitByRangeDelimiter()	0	3	1

<?php
/*

You must use "/**" style comments for a file comment

 * citeproc-php
 *
 * @link        http://github.com/seboettg/citeproc-php for the source repository
 * @copyright   Copyright (c) 2016 Sebastian Böttger.
 * @license     https://opensource.org/licenses/MIT
 */

namespace Seboettg\CiteProc\Util;

use Closure;

/**
 * Class Number
 * @package Seboettg\CiteProc\Util

There must be exactly one blank line before the tags in a doc comment

 *
 * @author Sebastian Böttger <seboettg@gmail.com>
 */

Missing @category tag in class comment

Missing @license tag in class comment

Missing @link tag in class comment

class NumberHelper
{

    const PATTERN_ORDINAL = "/\d+(st|nd|rd|th)?\.?$/";

    const PATTERN_ROMAN = "/^[ivxlcdm]+\.?$/i";

    const PATTERN_AFFIXES = "/^[a-z]?\d+[a-z]?$/i";

    const PATTERN_COMMA_AMPERSAND_RANGE = "/\d*([\s?\-&+,;\s])+\d+/";

    const ROMAN_NUMERALS = [
        ["", "i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix"],
        ["", "x", "xx", "xxx", "xl", "l", "lx", "lxx", "lxxx", "xc"],
        ["", "c", "cc", "ccc", "cd", "d", "dc", "dcc", "dccc", "cm"],
        ["", "m", "mm", "mmm", "mmmm", "mmmmm"]
    ];

    const ROMAN_DIGITS = [
        "M" => 1000,
        "D" => 500,
        "C" => 100,
        "L" => 50,
        "X" => 10,
        "V" => 5,
        "I" => 1
    ];

    /**

Missing short description in doc comment

     * @return Closure
     */
    public static function getCompareNumber()
    {
        return function($numA, $numB, $order) {

Expected 1 space after FUNCTION keyword; 0 found

            if (is_numeric($numA) && is_numeric($numB)) {
                $ret = $numA - $numB;
            } else {
                $ret = strcasecmp($numA, $numB);
            }
            if ("descending" === $order) {
                return $ret > 0 ? -1 : 1;
            }
            return $ret > 0 ? 1 : -1;
        };
    }

    /**

Missing short description in doc comment

     * @param $num

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

Missing parameter comment

     * @return string

Tag @return cannot be grouped with parameter tags in a doc comment

     */
    public static function dec2roman($num)
    {
        $ret = "";
        if ($num < 6000) {

            $numStr = strrev($num);
            $len = strlen($numStr);
            for ($pos = 0; $pos < $len; $pos++) {
                $n = $numStr[$pos];
                $ret = self::ROMAN_NUMERALS[$pos][$n] . $ret;
            }
        }
        return $ret;
    }

    /**

Missing short description in doc comment

     * @param $romanNumber

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

Missing parameter comment

     * @return int|mixed

Tag @return cannot be grouped with parameter tags in a doc comment

     */
    public static function roman2Dec($romanNumber)
    {
        $romanNumber = trim($romanNumber);
        if (is_numeric($romanNumber)) {
            return 0;
        }

        $values = [];
        // Convert the string to an array of roman values:
        for ($i = 0; $i < strlen($romanNumber); ++$i) {
            $char = strtoupper($romanNumber{$i});
            if (self::ROMAN_DIGITS[$char] !== null) {
                $values[] = self::ROMAN_DIGITS[$char];
            }
        }

        $sum = 0;
        while ($current = current($values)) {
            $next = next($values);
            $next > $current ? $sum += $next - $current + 0 * next($values) : $sum += $current;
        }
        return $sum;
    }

    public static function isRomanNumber($str)

Missing doc comment for function isRomanNumber()

    {
        $number = trim($str);
        for ($i = 0; $i < strlen($number); ++$i) {
            $char = strtoupper($number{$i});
            if (!in_array($char, array_keys(self::ROMAN_DIGITS))) {
                return false;
            }
        }
        return true;
    }

    /**

Missing short description in doc comment

     * @param $str

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

Missing parameter comment

     * @return string

Tag @return cannot be grouped with parameter tags in a doc comment

     */
    public static function evaluateStringPluralism($str)
    {
        $plural = 'single';
        if (!empty($str)) {
            $isRange = self::isRange($str);
            if ($isRange) {
                return 'multiple';
            } else {
                if (is_numeric($str) || NumberHelper::isRomanNumber($str)) {
                    return 'single';
                }
            }
        }
        return $plural;
    }

    public static function extractNumber($string)

Missing doc comment for function extractNumber()

    {
        if (preg_match("/(\d+)[^\d]*$/", $string, $match)) {
            return $match[1];
        }
        return $string;
    }

    /**

Missing short description in doc comment

     * @param $str

Missing parameter comment

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @return array[]|false|string[]

Tag @return cannot be grouped with parameter tags in a doc comment

     */
    public static function splitByRangeDelimiter($str)
    {
        return preg_split("/[-–&,]/", $str);
    }

    /**

Missing short description in doc comment

     * @param string $str

Missing parameter comment

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @return bool

Tag @return cannot be grouped with parameter tags in a doc comment

     */
    private static function isRange($str)

Private method name "NumberHelper::isRange" must be prefixed with an underscore

    {
        $rangeParts = self::splitByRangeDelimiter($str);
        $isRange = false;
        if (count($rangeParts) > 1) {

It seems like $rangeParts can also be of type false; however, parameter $var of count() does only seem to accept Countable|array, maybe add an additional type check?

            $isRange = true;
            foreach ($rangeParts as $range) {
                if (NumberHelper::isRomanNumber(trim($range)) || is_numeric(trim($range))) {
                    $isRange = $isRange && true;
                }
            }
        }
        return $isRange;
    }

    /**

Missing short description in doc comment

     * @param int|string $number

Missing parameter comment

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @return bool

Tag @return cannot be grouped with parameter tags in a doc comment

     */
    public static function isRomanRange($number)
    {
        $rangeParts = array_map("trim", self::splitByRangeDelimiter($number));

It seems like self::splitByRangeDelimiter($number) can also be of type false; however, parameter $arr1 of array_map() does only seem to accept array, maybe add an additional type check?

        $isRange = false;
        if (count($rangeParts) > 1) {
            $isRange = true;
            foreach ($rangeParts as $part) {
                $isRange = $isRange && NumberHelper::isRomanNumber($part);
            }
        }
        return $isRange;
    }
}