Class luya\helpers\StringHelper

                public static function base64UrlDecode($input)
{
    return base64_decode(strtr($input, '-_', '+/'));
}

            

                public static function base64UrlEncode($input)
{
    return strtr(base64_encode($input), '+/', '-_');
}

            

                public static function basename($path, $suffix = '')
{
    $len = mb_strlen($suffix);
    if ($len > 0 && mb_substr($path, -$len) === $suffix) {
        $path = mb_substr($path, 0, -$len);
    }
    $path = rtrim(str_replace('\\', '/', $path), '/');
    $pos = mb_strrpos($path, '/');
    if ($pos !== false) {
        return mb_substr($path, $pos + 1);
    }
    return $path;
}

            

                public static function byteLength($string)
{
    return mb_strlen((string)$string, '8bit');
}

            

                public static function byteSubstr($string, $start, $length = null)
{
    if ($length === null) {
        $length = static::byteLength($string);
    }
    return mb_substr($string, $start, $length, '8bit');
}

            

                public static function contains($needle, $haystack, $strict = false)
{
    $needles = (array) $needle;
    $state = false;
    foreach ($needles as $item) {
        $state = (strpos($haystack, (string) $item) !== false);
        if ($strict && !$state) {
            return false;
        }
        if (!$strict && $state) {
            return true;
        }
    }
    return $state;
}

            

                public static function countWords($string)
{
    return count(preg_split('/\s+/u', $string, 0, PREG_SPLIT_NO_EMPTY));
}

            

                public static function dirname($path)
{
    $normalizedPath = rtrim(
        str_replace('\\', '/', $path),
        '/'
    );
    $separatorPosition = mb_strrpos($normalizedPath, '/');
    if ($separatorPosition !== false) {
        return mb_substr($path, 0, $separatorPosition);
    }
    return '';
}

            

                public static function endsWith($string, $with, $caseSensitive = true)
{
    if (!$bytes = static::byteLength($with)) {
        return true;
    }
    if ($caseSensitive) {
        // Warning check, see https://php.net/substr-compare#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';
    $string = static::byteSubstr($string, -$bytes);
    return mb_strtolower($string, $encoding) === mb_strtolower($with, $encoding);
}

            

                public static function explode($string, $delimiter = ',', $trim = true, $skipEmpty = false)
{
    $result = explode($delimiter, $string);
    if ($trim !== false) {
        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;
}

            

                public static function filterMatch($value, $conditions, $caseSensitive = true)
{
    if (is_scalar($conditions)) {
        $conditions = self::explode($conditions, ",", true, true);
    }
    foreach ($conditions as $condition) {
        $isMatch = true;
        // negate
        if (substr($condition, 0, 1) == "!") {
            $isMatch = false;
            $condition = substr($condition, 1);
        }
        if ($caseSensitive) {
            $condition = strtolower($condition);
            $value = strtolower($value);
        }
        if ($condition == $value || self::startsWithWildcard($value, $condition)) {
            return $isMatch;
        }
    }
    return false;
}

            

                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);
}

            

                public static function highlightWord($content, $word, $markup = '<b>%s</b>')
{
    $transliterateContent = Inflector::transliterate($content);
    $highlights = [];
    $words = array_unique((array) $word);
    // if there are multiple words, we need to ensure the same part of a word does not exists twice
    // otherwise this can generate wrong highlight results like a highlight inside of a highlight.
    if (count($words) > 1) {
        foreach ($words as $wordIndex => $word) {
            $inArrayIndex = preg_grep('/'.preg_quote($word).'/', $words);
            if ((is_countable($inArrayIndex) ? count($inArrayIndex) : 0) > 1) {
                unset($words[$wordIndex]);
            }
        }
    }
    foreach ($words as $word) {
        // search in content
        preg_match_all("/".preg_quote($word, '/')."+/i", $content, $matches);
        foreach ($matches[0] as $word) {
            $highlights[] = $word;
            // if the word is covered already, do not process further in foreach and break here
            break;
        }
        // search in transliated content if not yet breaked from previous results
        preg_match_all("/".preg_quote($word, '/')."+/i", $transliterateContent, $matches);
        foreach ($matches[0] as $word) {
            $highlights[] = self::sliceTransliteratedWord($word, $transliterateContent, $content);
        }
    }
    // hightlight all results in text with [[$word]]
    foreach (array_unique($highlights) as $highlight) {
        $content = str_replace($highlight, '[['.$highlight.']]', $content);
    }
    preg_match_all('/\[\[(.*?)\]\]/', $content, $matches, PREG_SET_ORDER);
    $searchReplace = [];
    foreach ($matches as $match) {
        if (!array_key_exists($match[0], $searchReplace)) {
            $searchReplace[$match[0]] = sprintf($markup, $match[1]);
        }
    }
    foreach ($searchReplace as $search => $replace) {
        $content = str_replace($search, $replace, $content);
    }
    return $content;
}

            

                public static function isFloat($value)
{
    if (is_float($value)) {
        return true;
    }
    return ($value == (string)(float) $value);
}

            

                public static function isNummeric($value, $strict = true)
{
    if (!is_scalar($value)) {
        return false;
    }
    if (is_bool($value)) {
        return false;
    }
    if ($strict) {
        return preg_match('/^[0-9]+$/', $value) == 1 ? true : false;
    }
    return is_numeric($value);
}

            

                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)$string) === 1;
}

            

                public static function mb_str_split($string, $length = 1)
{
    return preg_split('/(.{'.$length.'})/us', $string, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
}

            

                public static function mb_ucfirst($string, $encoding = 'UTF-8')
{
    $firstChar = mb_substr((string)$string, 0, 1, $encoding);
    $rest = mb_substr((string)$string, 1, null, $encoding);
    return mb_strtoupper($firstChar, $encoding) . $rest;
}

            

                public static function mb_ucwords($string, $encoding = 'UTF-8')
{
    $string = (string) $string;
    if (empty($string)) {
        return $string;
    }
    $parts = preg_split('/(\s+\W+\s+|^\W+\s+|\s+)/u', $string, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
    $ucfirstEven = trim(mb_substr($parts[0], -1, 1, $encoding)) === '';
    foreach ($parts as $key => $value) {
        $isEven = (bool)($key % 2);
        if ($ucfirstEven === $isEven) {
            $parts[$key] = static::mb_ucfirst($value, $encoding);
        }
    }
    return implode('', $parts);
}

            

                public static function minify($content, array $options = [])
{
    $min = preg_replace(['/[\n\r]/', '/\>[^\S ]+/s', '/[^\S ]+\</s', '/(\s)+/s', ], ['', '>', '<', '\\1'], trim($content));
    $min = str_replace(['> <'], ['><'], $min);
    if (ArrayHelper::getValue($options, 'comments', false)) {
        $min = preg_replace('/<!--(.*)-->/Uis', '', $min);
    }
    return $min;
}

            

                public static function normalizeNumber($value)
{
    $value = (string) $value;
    $localeInfo = localeconv();
    $decimalSeparator = isset($localeInfo['decimal_point']) ? $localeInfo['decimal_point'] : null;
    if ($decimalSeparator !== null && $decimalSeparator !== '.') {
        $value = str_replace($decimalSeparator, '.', $value);
    }
    return $value;
}

            

                public static function replaceFirst($search, $replace, $subject)
{
    return preg_replace('/'.preg_quote($search, '/').'/', $replace, $subject, 1);
}

            

                public static function sliceTransliteratedWord($word, $transliteratedText, $originalText)
{
    return mb_substr($originalText, mb_strpos($transliteratedText, $word), mb_strlen($word));
}

            

                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';
    $string = static::byteSubstr($string, 0, $bytes);
    return mb_strtolower($string, $encoding) === mb_strtolower($with, $encoding);
}

            

                public static function startsWithWildcard($string, $with, $caseSensitive = true)
{
    if (substr($with, -1) != "*") {
        return false;
    }
    return self::startsWith($string, rtrim($with, '*'), $caseSensitive);
}

            

                public static function template($template, array $variables = [], $removeEmpty = false, $leftDelimiter = '{{', $rightDelimiter = '}}')
{
    preg_match_all("/$leftDelimiter(.*?)$rightDelimiter/", $template, $matches, PREG_SET_ORDER);
    if (empty($matches)) {
        return $template;
    }
    foreach ($matches as $match) {
        $exposedVariableName = trim($match[1]);
        if (array_key_exists($exposedVariableName, $variables)) {
            $template = str_replace($match[0], (string) $variables[$exposedVariableName], $template);
        } elseif ($removeEmpty) {
            $template = str_replace($match[0], '', $template);
        }
    }
    return $template;
}

            

                public static function textList($text, array $seperators = [PHP_EOL, "\n", "\r", "\n\r", ";", ","])
{
    return StringHelper::explode(str_replace($seperators, ';', $text), ";", true, true);
}

            

                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;
}

            

                protected static function truncateHtml($string, $count, $suffix, $encoding = false)
{
    $config = \HTMLPurifier_Config::create(null);
    if (Yii::$app !== null) {
        $config->set('Cache.SerializerPath', Yii::$app->getRuntimePath());
    }
    $lexer = \HTMLPurifier_Lexer::create($config);
    $tokens = $lexer->tokenizeHTML($string, $config, new \HTMLPurifier_Context());
    $openTokens = [];
    $totalCount = 0;
    $depth = 0;
    $truncated = [];
    foreach ($tokens as $token) {
        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 : '');
}

            

                public static function truncateMiddle($content, $word, $length, $affix = '..', $caseSensitive = false)
{
    $content = strip_tags($content);
    $array = self::mb_str_split($content);
    $first = mb_strpos($caseSensitive ? $content : mb_strtolower($content), $caseSensitive ? $word : mb_strtolower($word));
    // we could not find any match, therefore use casual truncate method.
    if ($first === false) {
        // as the length value in truncate middle stands for to the left and to the right, we multiple this value with 2
        return self::truncate($content, ($length*2), $affix);
    }
    $last = $first + mb_strlen($word);
    // left and right array chars from word
    $left = array_slice($array, 0, $first, true);
    $right = array_slice($array, $last, null, true);
    $middle = array_splice($array, $first, mb_strlen($word));
    // string before
    $before = (count($left) > $length) ? $affix.implode("", array_slice($left, -$length)) : implode("", $left);
    $after = (count($right) > $length) ? implode("", array_slice($right, 0, $length)) . $affix : implode("", $right);
    return $before . implode("", $middle) . $after;
}

            

                public static function truncateWords($string, $count, $suffix = '...', $asHtml = false)
{
    if ($asHtml) {
        return static::truncateHtml($string, $count, $suffix);
    }
    $words = preg_split('/(\s+)/u', trim($string), 0, PREG_SPLIT_DELIM_CAPTURE);
    if (count($words) / 2 > $count) {
        return implode('', array_slice($words, 0, ($count * 2) - 1)) . $suffix;
    }
    return $string;
}

            

                public static function typeCast($string)
{
    if (is_numeric($string)) {
        return static::typeCastNumeric($string);
    } elseif (is_array($string)) {
        return ArrayHelper::typeCast($string);
    }
    return $string;
}

            

                public static function typeCastNumeric($value)
{
    if (!self::isFloat($value)) {
        return $value;
    }
    if (intval($value) == $value) {
        return (int) $value;
    }
    return (float) $value;
}