Final Class Yiisoft\Strings\Inflector

                public function classToTable(string $className): string
{
    return $this->toPlural($this->pascalCaseToId($className, '_'));
}

            

                public function getPluralizeRules(): array
{
    return $this->pluralizeRules;
}

            

                public function getSingularizeRules(): array
{
    return $this->singularizeRules;
}

            

                public function getSpecialRules(): array
{
    return $this->specialRules;
}

            

                public function pascalCaseToId(string $input, string $separator = '-', bool $strict = false): string
{
    $regex = $strict
        ? '/(?<=\p{L})(\p{Lu})/u'
        : '/(?<=\p{L})(?<!\p{Lu})(\p{Lu})/u';
    /**
     * @var string $result We assume that `$separator` and `$input` are valid UTF-8 strings, so `preg_replace()`
     * never returns `false`.
     */
    $result = preg_replace($regex, addslashes($separator) . '\1', $input);
    if ($separator !== '_') {
        $result = str_replace('_', $separator, $result);
    }
    return mb_strtolower(trim($result, $separator));
}

            

                public function tableToClass(string $tableName): string
{
    return $this->toPascalCase($this->toSingular($tableName));
}

            

                public function toCamelCase(string $input): string
{
    $input = $this->toPascalCase($input);
    return mb_strtolower(mb_substr($input, 0, 1)) . mb_substr($input, 1);
}

            

                public function toHumanReadable(string $input, bool $uppercaseWords = false): string
{
    /**
     * @var string $input We assume that `$input` is valid UTF-8 string, so `preg_replace()` never returns `false`.
     */
    $input = preg_replace('/_id$/', '', $input);
    $input = str_replace('_', ' ', $input);
    return $uppercaseWords
        ? StringHelper::uppercaseFirstCharacterInEachWord($input)
        : StringHelper::uppercaseFirstCharacter($input);
}

            

                public function toPascalCase(string $input): string
{
    /**
     * @var string $input We assume that `$input` is valid UTF-8 string, so `preg_replace()` never returns `false`.
     */
    $input = preg_replace('/[^\pL\pN]+/u', ' ', $input);
    return str_replace(
        ' ',
        '',
        StringHelper::uppercaseFirstCharacterInEachWord($input),
    );
}

            

                public function toPlural(string $input): string
{
    if (isset($this->specialRules[$input])) {
        return $this->specialRules[$input];
    }
    foreach ($this->pluralizeRules as $rule => $replacement) {
        if (preg_match($rule, $input)) {
            /** @var string `$rule` and `$replacement` always correct, so `preg_replace` always returns string */
            return preg_replace($rule, $replacement, $input);
        }
    }
    return $input;
}

            

                public function toSentence(string $input, bool $uppercaseAll = false): string
{
    $input = $this->toHumanReadable($this->pascalCaseToId($input, '_'), $uppercaseAll);
    return $uppercaseAll
        ? StringHelper::uppercaseFirstCharacterInEachWord($input)
        : StringHelper::uppercaseFirstCharacter($input);
}

            

                public function toSingular(string $input): string
{
    $result = array_search($input, $this->specialRules, true);
    if ($result !== false) {
        return $result;
    }
    foreach ($this->singularizeRules as $rule => $replacement) {
        if (preg_match($rule, $input)) {
            /** @var string `$rule` and `$replacement` always correct, so `preg_replace` always returns string */
            return preg_replace($rule, $replacement, $input);
        }
    }
    return $input;
}

            

                public function toSlug(string $input, string $replacement = '-', bool $lowercase = true): string
{
    $quotedReplacement = preg_quote($replacement, '/');
    /**
     * Replace all non-words character
     *
     * @var string $input We assume that `$input` and `$replacement` are valid UTF-8 strings, so `preg_replace()`
     * never returns `false`.
     */
    $input = preg_replace('/[^a-zA-Z0-9]+/u', $replacement, $this->toTransliterated($input));
    /**
     * Remove first and last replacements
     *
     * @var string $input We assume that `$input` and `$quotedReplacement` are valid UTF-8 strings, so
     * `preg_replace()` never returns `false`.
     */
    $input = preg_replace(
        "/^(?:$quotedReplacement)+|(?:$quotedReplacement)+$/u" . ($lowercase ? 'i' : ''),
        '',
        $input,
    );
    return $lowercase ? strtolower($input) : $input;
}

            

                public function toSnakeCase(string $input, bool $strict = true): string
{
    /**
     * @var string $input We assume that `$input` is valid UTF-8 string, so `preg_replace()` never returns `false`.
     */
    $input = preg_replace('/[^\pL\pN]+/u', '_', $input);
    return $this->pascalCaseToId($input, '_', $strict);
}

            

                public function toTransliterated(string $input, $transliterator = null): string
{
    if ($this->useIntl()) {
        if ($transliterator === null) {
            $transliterator = $this->transliterator;
        }
        /**
         * @noinspection PhpComposerExtensionStubsInspection
         * @var string We assume that `$input` are valid UTF-8 strings and `$transliterator` is valid, so
         * `preg_replace()` never returns `false`.
         */
        return transliterator_transliterate($transliterator, $input);
    }
    return strtr($input, $this->transliterationMap);
}

            

                public function toWords(string $input): string
{
    /**
     * @var string $words We assume that `$input` is valid UTF-8 string, so `preg_replace()` never returns `false`.
     */
    $words = preg_replace('/(?<!\p{Lu})(\p{Lu})|(\p{Lu})(?=\p{Ll})/u', ' \0', $input);
    return mb_strtolower(
        trim(
            str_replace(['-', '_', '.'], ' ', $words)
        )
    );
}

            

                public function withPluralizeRules(array $rules): self
{
    $new = clone $this;
    $new->pluralizeRules = $rules;
    return $new;
}

            

                public function withSingularizeRules(array $rules): self
{
    $new = clone $this;
    $new->singularizeRules = $rules;
    return $new;
}

            

                public function withSpecialRules(array $rules): self
{
    $new = clone $this;
    $new->specialRules = $rules;
    return $new;
}

            

                public function withTransliterationMap(array $transliterationMap): self
{
    $new = clone $this;
    $new->transliterationMap = $transliterationMap;
    return $new;
}

            

                public function withTransliterator($transliterator): self
{
    $new = clone $this;
    $new->transliterator = $transliterator;
    return $new;
}

            

                public function withoutIntl(): self
{
    $new = clone $this;
    $new->withoutIntl = true;
    return $new;
}