BaseStringHelper::startsWith() - Code Metrics - Inspection of "remove outdated unit test" - yiisoft/yii2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 2.1 ( d5f162...fcc12f )

unknown

created 2018-01-15 15:54 UTC

BaseStringHelper::startsWith() A

↳ Parent: BaseStringHelper

Complexity

Conditions	4
Paths	4

Size

Total Lines	12
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	4

Importance

Changes

Metric	Value
dl	0
loc	12
ccs	7
cts	7
cp	1
rs	9.2
c	0
b	0
f	0
cc	4
eloc	7
nc	4
nop	3
crap	4

<?php
/**
 * @link http://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 */

namespace yii\helpers;

use Yii;

/**
 * BaseStringHelper provides concrete implementation for [[StringHelper]].
 *
 * Do not use BaseStringHelper. Use [[StringHelper]] instead.
 *
 * @author Qiang Xue <[email protected]>
 * @author Alex Makarov <[email protected]>
 * @since 2.0
 */
class BaseStringHelper
{
    /**
     * Returns the number of bytes in the given string.
     * This method ensures the string is treated as a byte array by using `mb_strlen()`.
     * @param string $string the string being measured for length
     * @return int the number of bytes in the given string.
     */
    public static function byteLength($string)
    {
        return mb_strlen($string, '8bit');
    }

    /**
     * Returns the portion of string specified by the start and length parameters.
     * This method ensures the string is treated as a byte array by using `mb_substr()`.
     * @param string $string the input string. Must be one character or longer.
     * @param int $start the starting position
     * @param int $length the desired portion length. If not specified or `null`, there will be
     * no limit on length i.e. the output will be until the end of the string.
     * @return string the extracted part of string, or FALSE on failure or an empty string.
     * @see http://www.php.net/manual/en/function.substr.php
     */
    public static function byteSubstr($string, $start, $length = null)
    {
        return mb_substr($string, $start, $length === null ? mb_strlen($string, '8bit') : $length, '8bit');
    }

    /**
     * Returns the trailing name component of a path.
     * This method is similar to the php function `basename()` except that it will
     * treat both \ and / as directory separators, independent of the operating system.
     * This method was mainly created to work on php namespaces. When working with real
     * file paths, php's `basename()` should work fine for you.
     * Note: this method is not aware of the actual filesystem, or path components such as "..".
     *
     * @param string $path A path string.
     * @param string $suffix If the name component ends in suffix this will also be cut off.
     * @return string the trailing name component of the given path.
     * @see http://www.php.net/manual/en/function.basename.php
     */
    public static function basename($path, $suffix = '')
    {
        if (($len = mb_strlen($suffix)) > 0 && mb_substr($path, -$len) === $suffix) {
            $path = mb_substr($path, 0, -$len);
        }
        $path = rtrim(str_replace('\\', '/', $path), '/\\');
        if (($pos = mb_strrpos($path, '/')) !== false) {
            return mb_substr($path, $pos + 1);
        }

        return $path;
    }

    /**
     * Returns parent directory's path.
     * This method is similar to `dirname()` except that it will treat
     * both \ and / as directory separators, independent of the operating system.
     *
     * @param string $path A path string.
     * @return string the parent directory's path.
     * @see http://www.php.net/manual/en/function.basename.php
     */
    public static function dirname($path)
    {
        $pos = mb_strrpos(str_replace('\\', '/', $path), '/');
        if ($pos !== false) {
            return mb_substr($path, 0, $pos);
        }

        return '';
    }

    /**
     * Truncates a string to the number of characters specified.
     *
     * @param string $string The string to truncate.
     * @param int $length How many characters from original string to include into truncated string.
     * @param string $suffix String to append to the end of truncated string.
     * @param string $encoding The charset to use, defaults to charset currently used by application.
     * @param bool $asHtml Whether to treat the string being truncated as HTML and preserve proper HTML tags.
     * This parameter is available since version 2.0.1.
     * @return string the truncated string.
     */
    public static function truncate($string, $length, $suffix = '...', $encoding = null, $asHtml = false)
    {
        if ($encoding === null) {
            $encoding = Yii::$app ? Yii::$app->charset : 'UTF-8';
        }
        if ($asHtml) {
            return static::truncateHtml($string, $length, $suffix, $encoding);
        }

        if (mb_strlen($string, $encoding) > $length) {
            return rtrim(mb_substr($string, 0, $length, $encoding)) . $suffix;
        }

        return $string;
    }

    /**
     * Truncates a string to the number of words specified.
     *
     * @param string $string The string to truncate.
     * @param int $count How many words from original string to include into truncated string.
     * @param string $suffix String to append to the end of truncated string.
     * @param bool $asHtml Whether to treat the string being truncated as HTML and preserve proper HTML tags.
     * This parameter is available since version 2.0.1.
     * @return string the truncated string.
     */
    public static function truncateWords($string, $count, $suffix = '...', $asHtml = false)
    {
        if ($asHtml) {
            return static::truncateHtml($string, $count, $suffix);
        }

        $words = preg_split('/(\s+)/u', trim($string), null, PREG_SPLIT_DELIM_CAPTURE);
        if (count($words) / 2 > $count) {
            return implode('', array_slice($words, 0, ($count * 2) - 1)) . $suffix;
        }

        return $string;
    }

    /**
     * Truncate a string while preserving the HTML.
     *
     * @param string $string The string to truncate
     * @param int $count
     * @param string $suffix String to append to the end of the truncated string.
     * @param string|bool $encoding
     * @return string
     * @since 2.0.1
     */
    protected static function truncateHtml($string, $count, $suffix, $encoding = false)
    {
        $config = HtmlPurifier::createConfig();
        $lexer = \HTMLPurifier_Lexer::create($config);
        $tokens = $lexer->tokenizeHTML($string, $config, new \HTMLPurifier_Context());
        $openTokens = [];
        $totalCount = 0;
        $depth = 0;
        $truncated = [];
        foreach ($tokens as $token) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            if ($token instanceof \HTMLPurifier_Token_Start) { //Tag begins
                $openTokens[$depth] = $token->name;
                $truncated[] = $token;
                ++$depth;
            } elseif ($token instanceof \HTMLPurifier_Token_Text && $totalCount <= $count) { //Text
                if (false === $encoding) {
                    preg_match('/^(\s*)/um', $token->data, $prefixSpace) ?: $prefixSpace = ['', ''];
                    $token->data = $prefixSpace[1] . self::truncateWords(ltrim($token->data), $count - $totalCount, '');
                    $currentCount = self::countWords($token->data);
                } else {
                    $token->data = self::truncate($token->data, $count - $totalCount, '', $encoding);

                    $currentCount = mb_strlen($token->data, $encoding);
                }
                $totalCount += $currentCount;
                $truncated[] = $token;
            } elseif ($token instanceof \HTMLPurifier_Token_End) { //Tag ends
                if ($token->name === $openTokens[$depth - 1]) {
                    --$depth;
                    unset($openTokens[$depth]);
                    $truncated[] = $token;
                }
            } elseif ($token instanceof \HTMLPurifier_Token_Empty) { //Self contained tags, i.e. <img/> etc.
                $truncated[] = $token;
            }
            if ($totalCount >= $count) {
                if (0 < count($openTokens)) {
                    krsort($openTokens);
                    foreach ($openTokens as $name) {
                        $truncated[] = new \HTMLPurifier_Token_End($name);
                    }
                }
                break;
            }
        }
        $context = new \HTMLPurifier_Context();
        $generator = new \HTMLPurifier_Generator($config, $context);
        return $generator->generateFromTokens($truncated) . ($totalCount >= $count ? $suffix : '');
    }

    /**
     * Check if given string starts with specified substring.
     * Binary and multibyte safe.
     *
     * @param string $string Input string
     * @param string $with Part to search inside the $string
     * @param bool $caseSensitive Case sensitive search. Default is true. When case sensitive is enabled, $with must exactly match the starting of the string in order to get a true value.
     * @return bool Returns true if first input starts with second input, false otherwise
     */
    public static function startsWith($string, $with, $caseSensitive = true)
    {
        if (!$bytes = static::byteLength($with)) {
            return true;
        }
        if ($caseSensitive) {
            return strncmp($string, $with, $bytes) === 0;

        }
        $encoding = Yii::$app ? Yii::$app->charset : 'UTF-8';
        return mb_strtolower(mb_substr($string, 0, $bytes, '8bit'), $encoding) === mb_strtolower($with, $encoding);
    }

    /**
     * Check if given string ends with specified substring.
     * Binary and multibyte safe.
     *
     * @param string $string Input string to check
     * @param string $with Part to search inside of the $string.
     * @param bool $caseSensitive Case sensitive search. Default is true. When case sensitive is enabled, $with must exactly match the ending of the string in order to get a true value.
     * @return bool Returns true if first input ends with second input, false otherwise
     */
    public static function endsWith($string, $with, $caseSensitive = true)
    {
        if (!$bytes = static::byteLength($with)) {
            return true;
        }
        if ($caseSensitive) {
            // Warning check, see http://php.net/manual/en/function.substr-compare.php#refsect1-function.substr-compare-returnvalues
            if (static::byteLength($string) < $bytes) {
                return false;
            }

            return substr_compare($string, $with, -$bytes, $bytes) === 0;
        }

        $encoding = Yii::$app ? Yii::$app->charset : 'UTF-8';
        return mb_strtolower(mb_substr($string, -$bytes, mb_strlen($string, '8bit'), '8bit'), $encoding) === mb_strtolower($with, $encoding);
    }

    /**
     * Explodes string into array, optionally trims values and skips empty ones.
     *
     * @param string $string String to be exploded.
     * @param string $delimiter Delimiter. Default is ','.
     * @param mixed $trim Whether to trim each element. Can be:
     *   - boolean - to trim normally;
     *   - string - custom characters to trim. Will be passed as a second argument to `trim()` function.
     *   - callable - will be called for each value instead of trim. Takes the only argument - value.
     * @param bool $skipEmpty Whether to skip empty strings between delimiters. Default is false.
     * @return array
     * @since 2.0.4
     */
    public static function explode($string, $delimiter = ',', $trim = true, $skipEmpty = false)
    {
        $result = explode($delimiter, $string);
        if ($trim) {
            if ($trim === true) {
                $trim = 'trim';
            } elseif (!is_callable($trim)) {
                $trim = function ($v) use ($trim) {
                    return trim($v, $trim);
                };
            }
            $result = array_map($trim, $result);
        }
        if ($skipEmpty) {
            // Wrapped with array_values to make array keys sequential after empty values removing
            $result = array_values(array_filter($result, function ($value) {
                return $value !== '';
            }));
        }

        return $result;
    }

    /**
     * Counts words in a string.
     * @since 2.0.8
     *
     * @param string $string
     * @return int
     */
    public static function countWords($string)
    {
        return count(preg_split('/\s+/u', $string, null, PREG_SPLIT_NO_EMPTY));
    }

    /**
     * Returns string representation of number value with replaced commas to dots, if decimal point
     * of current locale is comma.
     * @param int|float|string $value
     * @return string
     * @since 2.0.11
     */
    public static function normalizeNumber($value)
    {
        $value = "$value";

        $localeInfo = localeconv();
        $decimalSeparator = isset($localeInfo['decimal_point']) ? $localeInfo['decimal_point'] : null;

        if ($decimalSeparator !== null && $decimalSeparator !== '.') {
            $value = str_replace($decimalSeparator, '.', $value);
        }

        return $value;
    }

    /**
     * Encodes string into "Base 64 Encoding with URL and Filename Safe Alphabet" (RFC 4648).
     *
     * > Note: Base 64 padding `=` may be at the end of the returned string.
     * > `=` is not transparent to URL encoding.
     *
     * @see https://tools.ietf.org/html/rfc4648#page-7
     * @param string $input the string to encode.
     * @return string encoded string.
     * @since 2.0.12
     */
    public static function base64UrlEncode($input)
    {
        return strtr(base64_encode($input), '+/', '-_');
    }

    /**
     * Decodes "Base 64 Encoding with URL and Filename Safe Alphabet" (RFC 4648).
     *
     * @see https://tools.ietf.org/html/rfc4648#page-7
     * @param string $input encoded string.
     * @return string decoded string.
     * @since 2.0.12
     */
    public static function base64UrlDecode($input)
    {
        return base64_decode(strtr($input, '-_', '+/'));
    }

    /**
     * Safely casts a float to string independent of the current locale.
     *
     * The decimal separator will always be `.`.
     * @param float|int $number a floating point number or integer.
     * @return string the string representation of the number.
     * @since 2.0.13
     */
    public static function floatToString($number)
    {
        // . and , are the only decimal separators known in ICU data,
        // so its safe to call str_replace here
        return str_replace(',', '.', (string) $number);
    }

    /**
     * Checks if the passed string would match the given shell wildcard pattern.
     * This function emulates [[fnmatch()]], which may be unavailable at certain environment, using PCRE.
     * @param string $pattern the shell wildcard pattern.
     * @param string $string the tested string.
     * @param array $options options for matching. Valid options are:
     *
     * - caseSensitive: bool, whether pattern should be case sensitive. Defaults to `true`.
     * - escape: bool, whether backslash escaping is enabled. Defaults to `true`.
     * - filePath: bool, whether slashes in string only matches slashes in the given pattern. Defaults to `false`.
     *
     * @return bool whether the string matches pattern or not.
     * @since 2.0.14
     */
    public static function matchWildcard($pattern, $string, $options = [])
    {
        if ($pattern === '*' && empty($options['filePath'])) {
            return true;
        }

        $replacements = [
            '\\\\\\\\' => '\\\\',
            '\\\\\\*' => '[*]',
            '\\\\\\?' => '[?]',
            '\*' => '.*',
            '\?' => '.',
            '\[\!' => '[^',
            '\[' => '[',
            '\]' => ']',
            '\-' => '-',
        ];

        if (isset($options['escape']) && !$options['escape']) {
            unset($replacements['\\\\\\\\']);
            unset($replacements['\\\\\\*']);
            unset($replacements['\\\\\\?']);
        }

        if (!empty($options['filePath'])) {
            $replacements['\*'] = '[^/\\\\]*';
            $replacements['\?'] = '[^/\\\\]';
        }

        $pattern = strtr(preg_quote($pattern, '#'), $replacements);
        $pattern = '#^' . $pattern . '$#us';

        if (isset($options['caseSensitive']) && !$options['caseSensitive']) {
            $pattern .= 'i';
        }

        return preg_match($pattern, $string) === 1;
    }
}


1		<?php
2		/**
3		* @link http://www.yiiframework.com/
4		* @copyright Copyright (c) 2008 Yii Software LLC
5		* @license http://www.yiiframework.com/license/
6		*/
7
8		namespace yii\helpers;
9
10		use Yii;
11
12		/**
13		* BaseStringHelper provides concrete implementation for [[StringHelper]].
14		*
15		* Do not use BaseStringHelper. Use [[StringHelper]] instead.
16		*
17		* @author Qiang Xue <[email protected]>
18		* @author Alex Makarov <[email protected]>
19		* @since 2.0
20		*/
21		class BaseStringHelper
22		{
23		/**
24		* Returns the number of bytes in the given string.
25		* This method ensures the string is treated as a byte array by using `mb_strlen()`.
26		* @param string $string the string being measured for length
27		* @return int the number of bytes in the given string.
28		*/
29	429	public static function byteLength($string)
30		{
31	429	return mb_strlen($string, '8bit');
32		}
33
34		/**
35		* Returns the portion of string specified by the start and length parameters.
36		* This method ensures the string is treated as a byte array by using `mb_substr()`.
37		* @param string $string the input string. Must be one character or longer.
38		* @param int $start the starting position
39		* @param int $length the desired portion length. If not specified or `null`, there will be
40		* no limit on length i.e. the output will be until the end of the string.
41		* @return string the extracted part of string, or FALSE on failure or an empty string.
42		* @see http://www.php.net/manual/en/function.substr.php
43		*/
44	91	public static function byteSubstr($string, $start, $length = null)
45		{
46	91	return mb_substr($string, $start, $length === null ? mb_strlen($string, '8bit') : $length, '8bit');
47		}
48
49		/**
50		* Returns the trailing name component of a path.
51		* This method is similar to the php function `basename()` except that it will
52		* treat both \ and / as directory separators, independent of the operating system.
53		* This method was mainly created to work on php namespaces. When working with real
54		* file paths, php's `basename()` should work fine for you.
55		* Note: this method is not aware of the actual filesystem, or path components such as "..".
56		*
57		* @param string $path A path string.
58		* @param string $suffix If the name component ends in suffix this will also be cut off.
59		* @return string the trailing name component of the given path.
60		* @see http://www.php.net/manual/en/function.basename.php
61		*/
62	15	public static function basename($path, $suffix = '')
63		{
64	15	if (($len = mb_strlen($suffix)) > 0 && mb_substr($path, -$len) === $suffix) {
65	1	$path = mb_substr($path, 0, -$len);
66		}
67	15	$path = rtrim(str_replace('\\', '/', $path), '/\\');
68	15	if (($pos = mb_strrpos($path, '/')) !== false) {
69	15	return mb_substr($path, $pos + 1);
70		}
71
72	1	return $path;
73		}
74
75		/**
76		* Returns parent directory's path.
77		* This method is similar to `dirname()` except that it will treat
78		* both \ and / as directory separators, independent of the operating system.
79		*
80		* @param string $path A path string.
81		* @return string the parent directory's path.
82		* @see http://www.php.net/manual/en/function.basename.php
83		*/
84	5	public static function dirname($path)
85		{
86	5	$pos = mb_strrpos(str_replace('\\', '/', $path), '/');
87	5	if ($pos !== false) {
88	5	return mb_substr($path, 0, $pos);
89		}
90
91		return '';
92		}
93
94		/**
95		* Truncates a string to the number of characters specified.
96		*
97		* @param string $string The string to truncate.
98		* @param int $length How many characters from original string to include into truncated string.
99		* @param string $suffix String to append to the end of truncated string.
100		* @param string $encoding The charset to use, defaults to charset currently used by application.
101		* @param bool $asHtml Whether to treat the string being truncated as HTML and preserve proper HTML tags.
102		* This parameter is available since version 2.0.1.
103		* @return string the truncated string.
104		*/
105	1	public static function truncate($string, $length, $suffix = '...', $encoding = null, $asHtml = false)
106		{
107	1	if ($encoding === null) {
108	1	$encoding = Yii::$app ? Yii::$app->charset : 'UTF-8';
109		}
110	1	if ($asHtml) {
111	1	return static::truncateHtml($string, $length, $suffix, $encoding);
112		}
113
114	1	if (mb_strlen($string, $encoding) > $length) {
115	1	return rtrim(mb_substr($string, 0, $length, $encoding)) . $suffix;
116		}
117
118	1	return $string;
119		}
120
121		/**
122		* Truncates a string to the number of words specified.
123		*
124		* @param string $string The string to truncate.
125		* @param int $count How many words from original string to include into truncated string.
126		* @param string $suffix String to append to the end of truncated string.
127		* @param bool $asHtml Whether to treat the string being truncated as HTML and preserve proper HTML tags.
128		* This parameter is available since version 2.0.1.
129		* @return string the truncated string.
130		*/
131	1	public static function truncateWords($string, $count, $suffix = '...', $asHtml = false)
132		{
133	1	if ($asHtml) {
134	1	return static::truncateHtml($string, $count, $suffix);
135		}
136
137	1	$words = preg_split('/(\s+)/u', trim($string), null, PREG_SPLIT_DELIM_CAPTURE);
138	1	if (count($words) / 2 > $count) {
139	1	return implode('', array_slice($words, 0, ($count * 2) - 1)) . $suffix;
140		}
141
142	1	return $string;
143		}
144
145		/**
146		* Truncate a string while preserving the HTML.
147		*
148		* @param string $string The string to truncate
149		* @param int $count
150		* @param string $suffix String to append to the end of the truncated string.
151		* @param string\|bool $encoding
152		* @return string
153		* @since 2.0.1
154		*/
155	2	protected static function truncateHtml($string, $count, $suffix, $encoding = false)
156		{
157	2	$config = HtmlPurifier::createConfig();
158	2	$lexer = \HTMLPurifier_Lexer::create($config);
159	2	$tokens = $lexer->tokenizeHTML($string, $config, new \HTMLPurifier_Context());
160	2	$openTokens = [];
161	2	$totalCount = 0;
162	2	$depth = 0;
163	2	$truncated = [];
164	2	foreach ($tokens as $token) {
		0 ignored issues – show Bug introduced 2018-01-08 13:17 UTC by Report Bug Copy Issue Report The expression `$tokens` of type `array<integer,object<HTMLPurifier_Token>>\|null` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
165	2	if ($token instanceof \HTMLPurifier_Token_Start) { //Tag begins
166	2	$openTokens[$depth] = $token->name;
167	2	$truncated[] = $token;
168	2	++$depth;
169	2	} elseif ($token instanceof \HTMLPurifier_Token_Text && $totalCount <= $count) { //Text
170	2	if (false === $encoding) {
171	1	preg_match('/^(\s*)/um', $token->data, $prefixSpace) ?: $prefixSpace = ['', ''];
172	1	$token->data = $prefixSpace[1] . self::truncateWords(ltrim($token->data), $count - $totalCount, '');
173	1	$currentCount = self::countWords($token->data);
174		} else {
175	1	$token->data = self::truncate($token->data, $count - $totalCount, '', $encoding);
		0 ignored issues – show Bug introduced 2016-09-14 11:59 UTC by Report Bug Copy Issue Report It seems like `$encoding` defined by parameter `$encoding` on line 155 can also be of type `boolean`; however, `yii\helpers\BaseStringHelper::truncate()` does only seem to accept `string\|null`, maybe add an additional type check? This check looks at variables that have been passed in as parameters and are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
176	1	$currentCount = mb_strlen($token->data, $encoding);
177		}
178	2	$totalCount += $currentCount;
179	2	$truncated[] = $token;
180	2	} elseif ($token instanceof \HTMLPurifier_Token_End) { //Tag ends
181	2	if ($token->name === $openTokens[$depth - 1]) {
182	2	--$depth;
183	2	unset($openTokens[$depth]);
184	2	$truncated[] = $token;
185		}
186	2	} elseif ($token instanceof \HTMLPurifier_Token_Empty) { //Self contained tags, i.e. <img/> etc.
187	2	$truncated[] = $token;
188		}
189	2	if ($totalCount >= $count) {
190	2	if (0 < count($openTokens)) {
191	2	krsort($openTokens);
192	2	foreach ($openTokens as $name) {
193	2	$truncated[] = new \HTMLPurifier_Token_End($name);
194		}
195		}
196	2	break;
197		}
198		}
199	2	$context = new \HTMLPurifier_Context();
200	2	$generator = new \HTMLPurifier_Generator($config, $context);
201	2	return $generator->generateFromTokens($truncated) . ($totalCount >= $count ? $suffix : '');
202		}
203
204		/**
205		* Check if given string starts with specified substring.
206		* Binary and multibyte safe.
207		*
208		* @param string $string Input string
209		* @param string $with Part to search inside the $string
210		* @param bool $caseSensitive Case sensitive search. Default is true. When case sensitive is enabled, $with must exactly match the starting of the string in order to get a true value.
211		* @return bool Returns true if first input starts with second input, false otherwise
212		*/
213	20	public static function startsWith($string, $with, $caseSensitive = true)
214		{
215	20	if (!$bytes = static::byteLength($with)) {
216	3	return true;
217		}
218	17	if ($caseSensitive) {
219	16	return strncmp($string, $with, $bytes) === 0;
220
221		}
222	15	$encoding = Yii::$app ? Yii::$app->charset : 'UTF-8';
223	15	return mb_strtolower(mb_substr($string, 0, $bytes, '8bit'), $encoding) === mb_strtolower($with, $encoding);
224		}
225
226		/**
227		* Check if given string ends with specified substring.
228		* Binary and multibyte safe.
229		*
230		* @param string $string Input string to check
231		* @param string $with Part to search inside of the $string.
232		* @param bool $caseSensitive Case sensitive search. Default is true. When case sensitive is enabled, $with must exactly match the ending of the string in order to get a true value.
233		* @return bool Returns true if first input ends with second input, false otherwise
234		*/
235	20	public static function endsWith($string, $with, $caseSensitive = true)
236		{
237	20	if (!$bytes = static::byteLength($with)) {
238	3	return true;
239		}
240	17	if ($caseSensitive) {
241		// Warning check, see http://php.net/manual/en/function.substr-compare.php#refsect1-function.substr-compare-returnvalues
242	16	if (static::byteLength($string) < $bytes) {
243	3	return false;
244		}
245
246	13	return substr_compare($string, $with, -$bytes, $bytes) === 0;
247		}
248
249	15	$encoding = Yii::$app ? Yii::$app->charset : 'UTF-8';
250	15	return mb_strtolower(mb_substr($string, -$bytes, mb_strlen($string, '8bit'), '8bit'), $encoding) === mb_strtolower($with, $encoding);
251		}
252
253		/**
254		* Explodes string into array, optionally trims values and skips empty ones.
255		*
256		* @param string $string String to be exploded.
257		* @param string $delimiter Delimiter. Default is ','.
258		* @param mixed $trim Whether to trim each element. Can be:
259		* - boolean - to trim normally;
260		* - string - custom characters to trim. Will be passed as a second argument to `trim()` function.
261		* - callable - will be called for each value instead of trim. Takes the only argument - value.
262		* @param bool $skipEmpty Whether to skip empty strings between delimiters. Default is false.
263		* @return array
264		* @since 2.0.4
265		*/
266	1	public static function explode($string, $delimiter = ',', $trim = true, $skipEmpty = false)
267		{
268	1	$result = explode($delimiter, $string);
269	1	if ($trim) {
270	1	if ($trim === true) {
271	1	$trim = 'trim';
272	1	} elseif (!is_callable($trim)) {
273		$trim = function ($v) use ($trim) {
274		return trim($v, $trim);
275		};
276		}
277	1	$result = array_map($trim, $result);
278		}
279	1	if ($skipEmpty) {
280		// Wrapped with array_values to make array keys sequential after empty values removing
281	1	$result = array_values(array_filter($result, function ($value) {
282	1	return $value !== '';
283	1	}));
284		}
285
286	1	return $result;
287		}
288
289		/**
290		* Counts words in a string.
291		* @since 2.0.8
292		*
293		* @param string $string
294		* @return int
295		*/
296	2	public static function countWords($string)
297		{
298	2	return count(preg_split('/\s+/u', $string, null, PREG_SPLIT_NO_EMPTY));
299		}
300
301		/**
302		* Returns string representation of number value with replaced commas to dots, if decimal point
303		* of current locale is comma.
304		* @param int\|float\|string $value
305		* @return string
306		* @since 2.0.11
307		*/
308	24	public static function normalizeNumber($value)
309		{
310	24	$value = "$value";
311
312	24	$localeInfo = localeconv();
313	24	$decimalSeparator = isset($localeInfo['decimal_point']) ? $localeInfo['decimal_point'] : null;
314
315	24	if ($decimalSeparator !== null && $decimalSeparator !== '.') {
316	3	$value = str_replace($decimalSeparator, '.', $value);
317		}
318
319	24	return $value;
320		}
321
322		/**
323		* Encodes string into "Base 64 Encoding with URL and Filename Safe Alphabet" (RFC 4648).
324		*
325		* > Note: Base 64 padding `=` may be at the end of the returned string.
326		* > `=` is not transparent to URL encoding.
327		*
328		* @see https://tools.ietf.org/html/rfc4648#page-7
329		* @param string $input the string to encode.
330		* @return string encoded string.
331		* @since 2.0.12
332		*/
333	77	public static function base64UrlEncode($input)
334		{
335	77	return strtr(base64_encode($input), '+/', '-_');
336		}
337
338		/**
339		* Decodes "Base 64 Encoding with URL and Filename Safe Alphabet" (RFC 4648).
340		*
341		* @see https://tools.ietf.org/html/rfc4648#page-7
342		* @param string $input encoded string.
343		* @return string decoded string.
344		* @since 2.0.12
345		*/
346	13	public static function base64UrlDecode($input)
347		{
348	13	return base64_decode(strtr($input, '-_', '+/'));
349		}
350
351		/**
352		* Safely casts a float to string independent of the current locale.
353		*
354		* The decimal separator will always be `.`.
355		* @param float\|int $number a floating point number or integer.
356		* @return string the string representation of the number.
357		* @since 2.0.13
358		*/
359	13	public static function floatToString($number)
360		{
361		// . and , are the only decimal separators known in ICU data,
362		// so its safe to call str_replace here
363	13	return str_replace(',', '.', (string) $number);
364		}
365
366		/**
367		* Checks if the passed string would match the given shell wildcard pattern.
368		* This function emulates [[fnmatch()]], which may be unavailable at certain environment, using PCRE.
369		* @param string $pattern the shell wildcard pattern.
370		* @param string $string the tested string.
371		* @param array $options options for matching. Valid options are:
372		*
373		* - caseSensitive: bool, whether pattern should be case sensitive. Defaults to `true`.
374		* - escape: bool, whether backslash escaping is enabled. Defaults to `true`.
375		* - filePath: bool, whether slashes in string only matches slashes in the given pattern. Defaults to `false`.
376		*
377		* @return bool whether the string matches pattern or not.
378		* @since 2.0.14
379		*/
380	182	public static function matchWildcard($pattern, $string, $options = [])
381		{
382	182	if ($pattern === '*' && empty($options['filePath'])) {
383	5	return true;
384		}
385
386		$replacements = [
387	178	'\\\\\\\\' => '\\\\',
388		'\\\\\\' => '[]',
389		'\\\\\\?' => '[?]',
390		'\' => '.',
391		'\?' => '.',
392		'\[\!' => '[^',
393		'\[' => '[',
394		'\]' => ']',
395		'\-' => '-',
396		];
397
398	178	if (isset($options['escape']) && !$options['escape']) {
399	5	unset($replacements['\\\\\\\\']);
400	5	unset($replacements['\\\\\\*']);
401	5	unset($replacements['\\\\\\?']);
402		}
403
404	178	if (!empty($options['filePath'])) {
405	12	$replacements['\'] = '[^/\\\\]';
406	12	$replacements['\?'] = '[^/\\\\]';
407		}
408
409	178	$pattern = strtr(preg_quote($pattern, '#'), $replacements);
410	178	$pattern = '#^' . $pattern . '$#us';
411
412	178	if (isset($options['caseSensitive']) && !$options['caseSensitive']) {
413	2	$pattern .= 'i';
414		}
415
416	178	return preg_match($pattern, $string) === 1;
417		}
418		}
419

yiisoft / yii2

Push — 2.1 ( d5f162...fcc12f )

BaseStringHelper::startsWith() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like