Class yii\helpers\Inflector

                public static function camel2id($name, $separator = '-', $strict = false)
{
    if (empty($name)) {
        return (string) $name;
    }
    $regex = $strict ? '/\p{Lu}/u' : '/(?<!\p{Lu})\p{Lu}/u';
    if ($separator === '_') {
        return mb_strtolower(trim(preg_replace($regex, '_\0', $name), '_'), self::encoding());
    }
    return mb_strtolower(trim(str_replace('_', $separator, preg_replace($regex, $separator . '\0', $name)), $separator), self::encoding());
}

            

                public static function camel2words($name, $ucwords = true)
{
    if (empty($name)) {
        return (string) $name;
    }
    // Add a space before any uppercase letter preceded by a lowercase letter (xY => x Y)
    // and any uppercase letter preceded by an uppercase letter and followed by a lowercase letter (XYz => X Yz)
    $label = preg_replace('/(?<=\p{Ll})\p{Lu}|(?<=\p{L})\p{Lu}(?=\p{Ll})/u', ' \0', $name);
    $label = mb_strtolower(trim(str_replace(['-', '_', '.'], ' ', $label)), self::encoding());
    return $ucwords ? StringHelper::mb_ucwords($label, self::encoding()) : $label;
}

            

                public static function camelize($word)
{
    if (empty($word)) {
        return (string) $word;
    }
    return str_replace(' ', '', StringHelper::mb_ucwords(preg_replace('/[^\pL\pN]+/u', ' ', $word), self::encoding()));
}

            

                public static function classify($tableName)
{
    if (empty($tableName)) {
        return (string) $tableName;
    }
    return static::camelize(static::singularize($tableName));
}

            

                protected static function hasIntl()
{
    return extension_loaded('intl');
}

            

                public static function humanize($word, $ucAll = false)
{
    if (empty($word)) {
        return (string) $word;
    }
    $word = str_replace('_', ' ', preg_replace('/_id$/', '', $word));
    $encoding = self::encoding();
    return $ucAll ? StringHelper::mb_ucwords($word, $encoding) : StringHelper::mb_ucfirst($word, $encoding);
}

            

                public static function id2camel($id, $separator = '-')
{
    if (empty($id)) {
        return (string) $id;
    }
    return str_replace(' ', '', StringHelper::mb_ucwords(str_replace($separator, ' ', $id), self::encoding()));
}

            

                public static function ordinalize($number)
{
    if (in_array($number % 100, range(11, 13))) {
        return $number . 'th';
    }
    switch ($number % 10) {
        case 1:
            return $number . 'st';
        case 2:
            return $number . 'nd';
        case 3:
            return $number . 'rd';
        default:
            return $number . 'th';
    }
}

            

                public static function pluralize($word)
{
    if (empty($word)) {
        return (string) $word;
    }
    if (isset(static::$specials[$word])) {
        return static::$specials[$word];
    }
    foreach (static::$plurals as $rule => $replacement) {
        if (preg_match($rule, $word)) {
            return preg_replace($rule, $replacement, $word);
        }
    }
    return $word;
}

            

                public static function sentence(array $words, $twoWordsConnector = null, $lastWordConnector = null, $connector = ', ')
{
    if ($twoWordsConnector === null) {
        $twoWordsConnector = Yii::t('yii', ' and ');
    }
    if ($lastWordConnector === null) {
        $lastWordConnector = $twoWordsConnector;
    }
    switch (count($words)) {
        case 0:
            return '';
        case 1:
            return reset($words);
        case 2:
            return implode($twoWordsConnector, $words);
        default:
            return implode($connector, array_slice($words, 0, -1)) . $lastWordConnector . end($words);
    }
}

            

                public static function singularize($word)
{
    if (empty($word)) {
        return (string) $word;
    }
    $result = array_search($word, static::$specials, true);
    if ($result !== false) {
        return $result;
    }
    foreach (static::$singulars as $rule => $replacement) {
        if (preg_match($rule, $word)) {
            return preg_replace($rule, $replacement, $word);
        }
    }
    return $word;
}

            

                public static function slug($string, $replacement = '-', $lowercase = true)
{
    if (empty($string)) {
        return (string) $string;
    }
    if ((string)$replacement !== '') {
        $parts = explode($replacement, static::transliterate($string));
    } else {
        $parts = [static::transliterate($string)];
    }
    $replaced = array_map(function ($element) use ($replacement) {
        $element = preg_replace('/[^a-zA-Z0-9=\s—–-]+/u', '', $element);
        return preg_replace('/[=\s—–-]+/u', $replacement, $element);
    }, $parts);
    $string = trim(implode($replacement, $replaced), $replacement);
    if ((string)$replacement !== '') {
        $string = preg_replace('#' . preg_quote($replacement, '#') . '+#', $replacement, $string);
    }
    return $lowercase ? strtolower($string) : $string;
}

            

                public static function tableize($className)
{
    if (empty($className)) {
        return (string) $className;
    }
    return static::pluralize(static::underscore($className));
}

            

                public static function titleize($words, $ucAll = false)
{
    if (empty($words)) {
        return (string) $words;
    }
    $words = static::humanize(static::underscore($words), $ucAll);
    return $ucAll ? StringHelper::mb_ucwords($words, self::encoding()) : StringHelper::mb_ucfirst($words, self::encoding());
}

            

                public static function transliterate($string, $transliterator = null)
{
    if (empty($string)) {
        return (string) $string;
    }
    if (static::hasIntl()) {
        if ($transliterator === null) {
            $transliterator = static::$transliterator;
        }
        return transliterator_transliterate($transliterator, $string);
    }
    return strtr($string, static::$transliteration);
}

            

                public static function underscore($words)
{
    if (empty($words)) {
        return (string) $words;
    }
    return mb_strtolower(preg_replace('/(?<=\\pL)(\\p{Lu})/u', '_\\1', $words), self::encoding());
}

            

                public static function variablize($word)
{
    if (empty($word)) {
        return (string) $word;
    }
    $word = static::camelize($word);
    return mb_strtolower(mb_substr($word, 0, 1, self::encoding())) . mb_substr($word, 1, null, self::encoding());
}