Koch\Functions\Functions

Complexity

Total Complexity

99

Size/Duplication

Total Lines	640
Duplicated Lines	9.84 %

Coupling/Cohesion

Components	0
Dependencies	0

Importance

Changes

0

24 Methods

Rating	Name	Duplication	Size	Complexity
A	globRecursive()	0	15	3
A	inString()	0	8	4
B	findKeyInArray()	0	18	5
A	arrayFlatten()	0	9	2
A	formatSecondsToShortstring()	0	11	2
A	getServerLoad()	0	22	3
A	ensurePrefixedWith()	0	12	3
A	dropNumericKeys()	0	10	3
A	issetOrDefault()	0	4	2
A	issetArrayKeyOrDefault()	0	4	2
A	toUnderscoredUpperCamelCase()	0	6	1
A	cutStringBackwards()	0	10	2
A	strReplaceCount()	0	21	3
C	arrayCompare()	4	44	11
B	arrayUnequalCombine()	0	23	4
A	mapArrayKeysToValues()	0	9	2
C	distanceOfTimeInWords()	6	55	17
C	dateToWord()	10	42	15
A	vname()	0	21	4
A	removeCommentsFromTemplate()	0	4	1
A	shortenString()	0	21	3
A	utf8ToHtml()	0	7	1
A	__callStatic()	20	20	3
A	__call()	23	23	3

<?php

/**
 * Koch Framework
 * Jens-André Koch © 2005 - onwards.
 *
 * This file is part of "Koch Framework".
 *
 * License: GNU/GPL v2 or any later version, see LICENSE file.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

namespace Koch\Functions;

/**
 * Koch Framework - Class Library for various static helper Functions.
 */
class Functions
{
    /**
     * @var array This array contains the names of the loaded functions from directory /core/functions.
     */
    public static $alreadyLoaded = [];

    /**
     * Recursive glob.
     *
     * @param string $pattern
     * @param int    $flags
     *
     * @return type

Should the return type not be array? Also, consider making the array more specific, something like array<String>, or String[].

     */
    public static function globRecursive($pattern, $flags = 0)
    {
        $files = glob($pattern, $flags);

        foreach (glob(dirname($pattern) . '/*', GLOB_ONLYDIR | GLOB_NOSORT) as $dir) {
            $files = array_merge($files, self::globRecursive($dir . '/' . basename($pattern), $flags));
        }

        // slash fix
        foreach ($files as $key => $value) {
            $files[$key] = realpath($value);
        }

        return $files;
    }

    public static function getServerLoad()
    {
        if (stristr(PHP_OS, 'win')) {
            $wmi  = new COM('Winmgmts://');
            $cpus = $wmi->execquery('SELECT LoadPercentage FROM Win32_Processor');

            $cpu_num    = 0;

$cpu_num does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            $load_total = 0;

$load_total does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            foreach ($cpus as $cpu) {
                ++$cpu_num;

$cpu_num does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                $load_total += $cpu->loadpercentage;

$load_total does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            }

            $load = round($load_total / $cpu_num);

$load_total does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        } else {
            $sys_load = sys_getloadavg();

$sys_load does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            $load     = $sys_load[0];

$sys_load does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        }

        return (int) $load;
    }

    public static function inString($needle, $haystack, $insensitive = false)

function inString() does not seem to conform to the naming convention (^(?:is|has|should|may|supports)).

    {
        if ($insensitive === true) {
            return (false !== stristr($haystack, $needle)) ? true : false;
        } else {
            return (false !== strpos($haystack, $needle)) ? true : false;
        }
    }

    /**
     * Checks a string for a certain prefix or adds it, if missing.
     *
     * @param string $string
     * @param string $prefix
     *
     * @return string prefixed classname
     */
    public static function ensurePrefixedWith($string, $prefix)
    {
        $pos = null;

$pos is not used, you could remove the assignment.

        $pos = mb_strpos($string, $prefix);

        if (is_int($pos) && ($pos === 0)) {
            return $string;
        } else {
            return $prefix . $string;
        }
    }

    public function dropNumericKeys(array $array)
    {
        foreach ($array as $key => $value) {
            if (is_int($key)) {
                unset($array[$key]);
            }
        }

        return $array;
    }

    public function issetOrDefault($var, $defaultValue = null)

The return type could not be reliably inferred; please add a @return annotation.

    {
        return isset($var) ? $var : $defaultValue;
    }

    public function issetArrayKeyOrDefault(array $array, $key, $defaultValue = null)

The return type could not be reliably inferred; please add a @return annotation.

    {
        return isset($array[$key]) ? $array[$key] : $defaultValue;
    }

    /**
     * Transforms a string from underscored_lower_case to Underscored_Upper_Camel_Case.
     *
     * @param string $string String in underscored_lower_case format.
     *
     * @return $string String in Upper_Camel_Case.

The doc-type $string could not be parsed: Unknown type name "$string" at position 0. (view supported doc-types)

     */
    public static function toUnderscoredUpperCamelCase($string)
    {
        $upperCamelCase = str_replace(' ', '_', ucwords(str_replace('_', ' ', strtolower($string))));

        return $upperCamelCase;
    }

    /**
     * cut_string_backwards.
     *
     * haystack = abc_def
     * needle = _def
     * result = abc
     *
     * In PHP6
     * abc = $string = mb_strstr('abc_def', '_def');
     *
     * @param $haystack string
     * @param $needle string
     *
     * @return string
     */
    public static function cutStringBackwards($haystack, $needle)
    {
        $needle_length = mb_strlen($needle);

$needle_length does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        if (($i = mb_strpos($haystack, $needle) !== false)) {

$i is not used, you could remove the assignment.

            return mb_substr($haystack, 0, -$needle_length);

$needle_length does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        }

        return $haystack;
    }

    /**
     * @param string $haystack
     * @param string $replace
     * @param string $needle
     * @param int    $times
     *
     * @return $needle

The doc-type $needle could not be parsed: Unknown type name "$needle" at position 0. (view supported doc-types)

     */
    public static function strReplaceCount($haystack, $replace, $needle, $times)
    {
        $subject_original = $needle;

$subject_original does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        $length           = mb_strlen($haystack);
        $pos              = 0;

        for ($i = 1; $i <= $times; ++$i) {
            $pos = mb_strpos($needle, $haystack, $pos);

            if ($pos !== false) {
                $needle = mb_substr($subject_original, 0, $pos);

$subject_original does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                $needle .= $replace;
                $needle .= mb_substr($subject_original, $pos + $length);

$subject_original does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                $subject_original = $needle;

$subject_original does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            } else {
                break;
            }
        }

        return $needle;
    }

    /**
     * Takes a needle and multi-dimensional haystack array and does a search on it's values.
     *
     * @param string $needle   Needle to find
     * @param array  $haystack Haystack to look through
     * @result array Returns the elements that the $string was found in
     *
     * array_values_recursive
     */
    public static function findKeyInArray($needle, array $haystack)

The return type could not be reliably inferred; please add a @return annotation.

    {
        // take a look for the needle
        if (isset($haystack[$needle]) or array_key_exists($needle, $haystack)) {

Using logical operators such as or instead of || is generally not recommended.

            // if found, return it
            return $haystack[$needle];
        }

        // dig a little bit deeper in the array structure
        foreach ($haystack as $k => $v) {
            if (is_array($v)) {
                // recursion
                return self::findKeyInArray($needle, $v);
            }
        }

        return false;
    }

    /**
     * array_compare.
     *
     * @author  55 dot php at imars dot com
     * @author  dwarven dot co dot uk
     *
     * @link    http://www.php.net/manual/de/function.array-diff-assoc.php#89635
     *
     * @param $array1
     * @param $array2
     */
    public static function arrayCompare($array1, $array2)

function arrayCompare() does not seem to conform to the naming convention (^(?:is|has|should|may|supports)).

    {
        $diff = false;

        // Left-to-right
        foreach ($array1 as $key => $value) {
            if (array_key_exists($key, $array2) === false) {
                $diff[0][$key] = $value;
            } elseif (is_array($value)) {
                if (is_array($array2[$key]) === false) {
                    $diff[0][$key] = $value;
                    $diff[1][$key] = $array2[$key];
                } else {
                    $new = self::array_compare($value, $array2[$key]);

                    if ($new !== false) {
                        if ($new[0] !== null) {

This code seems to be duplicated across your project.

                            $diff[0][$key] = $new[0];
                        }
                        if ($new[1] !== null) {

This code seems to be duplicated across your project.

                            $diff[1][$key] = $new[1];
                        }
                    }
                }
            } elseif ($array2[$key] !== $value) {
                $diff[0][$key] = $value;
                $diff[1][$key] = $array2[$key];
            }
        }

        // Right-to-left
        foreach ($array2 as $key => $value) {
            if (array_key_exists($key, $array1) === false) {
                $diff[1][$key] = $value;
            }

            /*
             * No direct comparsion because matching keys were compared in the
             * left-to-right loop earlier, recursively.
             */
        }

        return $diff;
    }

    /**
     * Combines two arrays by using $keyArray as key providing array
     * an $valueArray as value providing array.
     * In case the valueArray is greater than the keyArray,
     * the keyArray determines the maximum number of values returned.
     * In case the valueArray is smaller than the keyArray,
     * those keys are returned for which values exist.
     *
     * @example
     * $keys = array('mod', 'sub', 'action', 'id');
     * $values = array('news', 'admin');
     * $combined = self::array_unequal_combine($keys, $values);
     * Results in: array('mod'=>'news', 'sub'=>'admin');
     *
     * @param array $keyArray
     * @param array $valueArray
     *
     * @return array Combined Array
     */
    public static function arrayUnequalCombine($keyArray, $valueArray)
    {
        $returnArray = [];
        $key         = '';
        $index       = 0;

        // more keys than values, reduce keys array
        while (count($keyArray) > count($valueArray)) {
            array_pop($keyArray);
        }

        // @todo more values than keys ?
        // add pseudo keys a la "key-0"

        foreach ($keyArray as $key) {
            if ($valueArray[$index] !== null) {
                // index is used, then incremented for the next turn in foreach (post-increment-operator)
                $returnArray[$key] = $valueArray[$index++];
            }
        }

        return $returnArray;
    }

    /**
     * Remaps multi-dim array (k1=>v1, k2=>v2, k(n) => v(n)) to the values of key1=>key2 (v1 => v2).
     * The array might have several keys, so you might map value of key2 to value of key5 ;)
     * Simple, but impressive!
     *
     * @param type $array
     * @param type $map_value_of_key1
     * @param type $to_value_of_key2
     *
     * @return type array

Should the return type not be array? Also, consider making the array more specific, something like array<String>, or String[].

     */
    public static function mapArrayKeysToValues($array, $map_value_of_key1, $to_value_of_key2)

$map_value_of_key1 does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    {
        $new_array = [];

$new_array does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        foreach ($array as $inner_array) {

$inner_array does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            $new_array[$inner_array[$map_value_of_key1]] = $inner_array[$to_value_of_key2];

$new_array does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        }

        return $new_array;

$new_array does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    }

    /**
     * flatten multi-dimensional array.
     *
     * @param array $array
     *
     * @return array
     */
    public static function arrayFlatten(array $array)
    {
        $flatened_array = [];

$flatened_array does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        foreach (new \RecursiveIteratorIterator(new \RecursiveArrayIterator($array)) as $value) {
            $flatened_array[] = $value;

$flatened_array does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        }

        return $flatened_array;

$flatened_array does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    }

    /**
     * distanceOfTimeInWords.
     *
     * @author: anon
     * @link: http://www.php.net/manual/de/function.time.php#85481
     *
     * @param int $fromTime starttime
     * @param $toTime endtime
     * @param $showLessThanAMinute boolean
     *
     * @return string
     */
    public static function distanceOfTimeInWords($fromTime, $toTime = 0, $showLessThanAMinute = false)
    {
        $distanceInSeconds = round(abs($toTime - $fromTime));
        $distanceInMinutes = round($distanceInSeconds / 60);

        if ($distanceInMinutes <= 1) {
            if ($showLessThanAMinute === false) {
                return ($distanceInMinutes === 0) ? 'less than a minute' : '1 minute';
            } else {
                if ($distanceInSeconds < 5) {
                    return 'less than 5 seconds';
                }
                if ($distanceInSeconds < 10) {
                    return 'less than 10 seconds';
                }
                if ($distanceInSeconds < 20) {
                    return 'less than 20 seconds';
                }
                if ($distanceInSeconds < 40) {
                    return 'about half a minute';
                }
                if ($distanceInSeconds < 60) {
                    return 'less than a minute';
                }

                return '1 minute';
            }
        }
        if ($distanceInMinutes < 45) {
            return $distanceInMinutes . ' minutes';
        }
        if ($distanceInMinutes < 90) {
            return 'about 1 hour';
        }
        if ($distanceInMinutes < 1440) {

This code seems to be duplicated across your project.

            return 'about ' . round(floatval($distanceInMinutes) / 60.0) . ' hours';
        }
        if ($distanceInMinutes < 2880) {
            return '1 day';
        }
        if ($distanceInMinutes < 43200) {

This code seems to be duplicated across your project.

            return 'about ' . round(floatval($distanceInMinutes) / 1440) . ' days';
        }
        if ($distanceInMinutes < 86400) {
            return 'about 1 month';
        }
        if ($distanceInMinutes < 525600) {
            return round(floatval($distanceInMinutes) / 43200) . ' months';
        }
        if ($distanceInMinutes < 1051199) {
            return 'about 1 year';
        }

        return 'over ' . round(floatval($distanceInMinutes) / 525600) . ' years';
    }

    /**
     * Performs a dateToWord transformation via gettext.
     * uses idate() to format a local time/date as integer and gettext functions _n(), _t().
     *
     * @see http://www.php.net/idate
     *
     * @param string $from
     * @param string $now

Should the type for parameter $now not be string|null?

     *
     * @return string Word representation of
     */
    public static function dateToWord($from, $now = null)
    {
        if ($now === null) {
            $now = time();
        }

        $between = $now - $from;

        if ($between < 86400 and idate('d', $from) === idate('d', $now)) {

Using logical operators such as and instead of && is generally not recommended.

            if ($between < 3600 and idate('H', $from) === idate('H', $now)) {

Using logical operators such as and instead of && is generally not recommended.

                if ($between < 60 and idate('i', $from) === idate('i', $now)) {

This code seems to be duplicated across your project.

Using logical operators such as and instead of && is generally not recommended.

                    $second = idate('s', $now) - idate('s', $from);

                    return sprintf(_n('%d', '%d', $second), $second);
                }

                $min = idate('i', $now) - idate('i', $from);

                return sprintf(_n('%d', '%d', $min), $min);
            }

            $hour = idate('H', $now) - idate('H', $from);

            return sprintf(_n('%d', '%d', $hour), $hour);
        }

        if ($between < 172800 && (idate('z', $from) + 1 === idate('z', $now) or idate('z', $from) > 2 + idate('z', $now))) {

Using logical operators such as or instead of || is generally not recommended.

            return _t('.. %s', date('H:i', $from));
        }

        if ($between < 604800 and idate('W', $from) === idate('W', $now)) {

This code seems to be duplicated across your project.

Using logical operators such as and instead of && is generally not recommended.

            $day = intval($between / (3600 * 24));

            return sprintf(_n('...', '...', $day), $day);
        }

        if ($between < 31622400 and idate('Y', $from) === idate('Y', $now)) {

Using logical operators such as and instead of && is generally not recommended.

            return date(_t('...'), $from);
        }

        return date(_t('...'), $from);
    }

    /**
     * Get the variable name as string.
     *
     * @author http://us2.php.net/manual/en/language.variables.php#76245
     *
     * @param $var variable as reference
     * @param $scope scope
     *
     * @return string

Should the return type not be integer|string|false?

     */
    public static function vname($var, $scope = false, $prefix = 'unique', $suffix = 'value')
    {
        $values = '';

        if ($scope === true) {
            $values = $scope;
        }

        $old   = $var;
        $var   = $new   = $prefix . rand() . $suffix;

$var is not used, you could remove the assignment.

        $vname = false;

        foreach ($values as $key => $val) {

The expression $values of type boolean|string is not guaranteed to be traversable. How about adding an additional type check?

            if ($val === $new) {
                $vname = $key;
            }
        }
        $var = $old;

$var is not used, you could remove the assignment.

        return $vname;
    }

    /**
     * format_seconds_to_shortstring.
     *
     * @param $seconds int
     *
     * @return string Ouput: 4D 10:12:20
     */
    public static function formatSecondsToShortstring($seconds = 0)
    {
        $time = '';

$time is not used, you could remove the assignment.

        if ($seconds !== null) {
            $time = sprintf('%dD %02d:%02d:%02dh', $seconds / 60 / 60 / 24, ($seconds / 60 / 60) % 24, ($seconds / 60) % 60, $seconds % 60);
        } else {
            return '00:00:00';
        }

        return $time;
    }

    /**
     * Remove comments prefilter.
     *
     * @param $html A String with HTML Comments.
     *
     * @return string $html String without Comments.
     */
    public function removeCommentsFromTemplate($html)
    {
        return preg_replace('/<!--.*-->/U', '', $html);
    }

    /**
     * @param string $string
     */
    public static function shortenString($string, $maxlength = 50, $append_string = '[...]')

$append_string does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    {
        // already way too short...
        if (mb_strlen($string) < $maxlength) {
            return $string;
        }

        // ok, lets shorten
        if (mb_strlen($string) > $maxlength) {
            /*
             * do not short the string, when maxlength would split a word!
             * that would make things unreadable.
             * so search for the next space after the requested maxlength.
             */
            $next_space_after_maxlength = mb_strpos($string, ' ', $maxlength);

$next_space_after_maxlength does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            $shortened_string = mb_substr($string, 0, $next_space_after_maxlength);

$shortened_string does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            return $shortened_string . $append_string;

$shortened_string does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        }
    }

    /**
     * Converts a UTF8-string into HTML entities.
     *
     * When using UTF-8 as a charset you want to convert multi-byte characters.
     * This function takes multi-byte characters up to level 4 into account.
     * Htmlentities will only convert 1-byte and 2-byte characters.
     * Use this function if you want to convert 3-byte and 4-byte characters also.
     *
     * @author silverbeat gmx  at
     *
     * @link http://www.php.net/manual/de/function.htmlentities.php#96648
     *
     * @param $utf8 string The UTF8-string to convert
     * @param $encodeTags booloean TRUE will convert "<" to "&lt;", Default = false
     *
     * @return string the converted HTML-string
     */
    public static function utf8ToHtml($utf8, $encodeTags = false)
    {
        include_once __DIR__ . '/Pool/UTF8_to_HTML.php';

        // calling the loaded function
        return UTF8_to_HTML($utf8, $encodeTags);
    }

    /**
     * The Magic Call __callStatic() is triggered when invoking inaccessible methods in a static context.
     * Method overloading.
     * Available from PHP 5.3 onwards.
     *
     * @param $name string The $name argument is the name of the method being called.
     * @param $arguments arra The $arguments argument is an enumerated array containing the parameters passed to the $name'ed method.
     */
    public static function __callStatic($method, $arguments)

This method seems to be duplicated in your project.

    {
        // Debug message for Method Overloading
        // Making it easier to see which static method is called magically
        //\Koch\Debug\Debug::firebug('DEBUG (Overloading): Calling static method "'.$method.'" '. implode(', ', $arguments). "\n");

57% of this comment could be valid code. Did you maybe forget this after debugging?

        // construct the filename of the command
        $filename = __DIR__ . '/Pool/' . $method . '.php';

        // check if name is valid
        if (is_file($filename) && is_readable($filename)) {
            // dynamically include the command
            include_once $filename;

            return call_user_func_array($method, $arguments);
        } else {
            throw new \RuntimeException(
                sprintf('Koch Framework Function not found: "%s".', $filename)
            );
        }
    }

    /**
     * The Magic Call __call() is triggered when invoking inaccessible methods in an object context.
     * Method overloading.
     *
     * This method takes care of loading the function command files.
     *
     * This means that a currently non-existing methods or properties of this class are dynamically "created".
     * Overloading methods are always in the "public" scope.
     *
     * @param $name string The $name argument is the name of the method being called.
     * @param $arguments array The $arguments  argument is an enumerated array containing the parameters passed to the $name'ed method.
     */
    public function __call($method, $arguments)

This method seems to be duplicated in your project.

    {
        // Because value of $name is case sensitive, its forced to be lowercase.
        $method = mb_strtolower($method);

        // Debug message for Method Overloading
        // Making it easier to see which method is called magically
        // \Koch\Debug\Debug::fbg('DEBUG (Overloading): Calling object method "'.$method.'" '. implode(', ', $arguments). "\n");

55% of this comment could be valid code. Did you maybe forget this after debugging?

        // construct the filename of the command
        $filename = __DIR__ . '/pool/' . $method . '.php';

        // check if name is valid
        if (is_file($filename) && is_readable($filename)) {
            // dynamically include the command
            include_once $filename;

            return call_user_func_array($method, $arguments);
        } else {
            throw new \RuntimeException(
                sprintf('Koch Framework Function not found: "%s".', $filename)
            );
        }
    }
}