Doctrine\Inflector\Inflector

Complexity

Total Complexity

26

Size/Duplication

Total Lines	480
Duplicated Lines	0 %

Test Coverage

Coverage

55.13%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	pluralize()	0	3	1
A	singularize()	0	3	1
A	urlize()	0	34	4
A	tableize()	0	12	2
A	camelize()	0	3	1
B	seemsUtf8()	0	27	11
A	__construct()	0	4	1
B	unaccent()	0	103	3
A	capitalize()	0	3	1
A	classify()	0	3	1

<?php

declare(strict_types=1);

namespace Doctrine\Inflector;

use RuntimeException;
use function chr;
use function function_exists;
use function lcfirst;
use function mb_strtolower;
use function ord;
use function preg_match;
use function preg_replace;
use function sprintf;
use function str_replace;
use function strlen;
use function strtolower;
use function strtr;
use function trim;
use function ucwords;

class Inflector
{
    private const ACCENTED_CHARACTERS = [
        // Decompositions for Latin-1 Supplement
        "\xC3\x80" => 'A',
        "\xC3\x81" => 'A',
        "\xC3\x82" => 'A',
        "\xC3\x83" => 'A',
        "\xC3\x84" => 'A',
        "\xC3\x85" => 'A',
        "\xC3\x87" => 'C',
        "\xC3\x88" => 'E',
        "\xC3\x89" => 'E',
        "\xC3\x8A" => 'E',
        "\xC3\x8B" => 'E',
        "\xC3\x8C" => 'I',
        "\xC3\x8D" => 'I',
        "\xC3\x8E" => 'I',
        "\xC3\x8F" => 'I',
        "\xC3\x91" => 'N',
        "\xC3\x92" => 'O',
        "\xC3\x93" => 'O',
        "\xC3\x94" => 'O',
        "\xC3\x95" => 'O',
        "\xC3\x96" => 'O',
        "\xC3\x99" => 'U',
        "\xC3\x9A" => 'U',
        "\xC3\x9B" => 'U',
        "\xC3\x9C" => 'U',
        "\xC3\x9D" => 'Y',
        "\xC3\x9F" => 's',
        "\xC3\xA0" => 'a',
        "\xC3\xA1" => 'a',
        "\xC3\xA2" => 'a',
        "\xC3\xA3" => 'a',
        "\xC3\xA4" => 'a',
        "\xC3\xA5" => 'a',
        "\xC3\xA7" => 'c',
        "\xC3\xA8" => 'e',
        "\xC3\xA9" => 'e',
        "\xC3\xAA" => 'e',
        "\xC3\xAB" => 'e',
        "\xC3\xAC" => 'i',
        "\xC3\xAD" => 'i',
        "\xC3\xAE" => 'i',
        "\xC3\xAF" => 'i',
        "\xC3\xB1" => 'n',
        "\xC3\xB2" => 'o',
        "\xC3\xB3" => 'o',
        "\xC3\xB4" => 'o',
        "\xC3\xB5" => 'o',
        "\xC3\xB6" => 'o',
        "\xC3\xB9" => 'u',
        "\xC3\xBA" => 'u',
        "\xC3\xBB" => 'u',
        "\xC3\xBC" => 'u',
        "\xC3\xBD" => 'y',
        "\xC3\xBF" => 'y',
        // Decompositions for Latin Extended-A
        "\xC4\x80" => 'A',
        "\xC4\x81" => 'a',
        "\xC4\x82" => 'A',
        "\xC4\x83" => 'a',
        "\xC4\x84" => 'A',
        "\xC4\x85" => 'a',
        "\xC4\x86" => 'C',
        "\xC4\x87" => 'c',
        "\xC4\x88" => 'C',
        "\xC4\x89" => 'c',
        "\xC4\x8A" => 'C',
        "\xC4\x8B" => 'c',
        "\xC4\x8C" => 'C',
        "\xC4\x8D" => 'c',
        "\xC4\x8E" => 'D',
        "\xC4\x8F" => 'd',
        "\xC4\x90" => 'D',
        "\xC4\x91" => 'd',
        "\xC4\x92" => 'E',
        "\xC4\x93" => 'e',
        "\xC4\x94" => 'E',
        "\xC4\x95" => 'e',
        "\xC4\x96" => 'E',
        "\xC4\x97" => 'e',
        "\xC4\x98" => 'E',
        "\xC4\x99" => 'e',
        "\xC4\x9A" => 'E',
        "\xC4\x9B" => 'e',
        "\xC4\x9C" => 'G',
        "\xC4\x9D" => 'g',
        "\xC4\x9E" => 'G',
        "\xC4\x9F" => 'g',
        "\xC4\xA0" => 'G',
        "\xC4\xA1" => 'g',
        "\xC4\xA2" => 'G',
        "\xC4\xA3" => 'g',
        "\xC4\xA4" => 'H',
        "\xC4\xA5" => 'h',
        "\xC4\xA6" => 'H',
        "\xC4\xA7" => 'h',
        "\xC4\xA8" => 'I',
        "\xC4\xA9" => 'i',
        "\xC4\xAA" => 'I',
        "\xC4\xAB" => 'i',
        "\xC4\xAC" => 'I',
        "\xC4\xAD" => 'i',
        "\xC4\xAE" => 'I',
        "\xC4\xAF" => 'i',
        "\xC4\xB0" => 'I',
        "\xC4\xB1" => 'i',
        "\xC4\xB2" => 'IJ',
        "\xC4\xB3" => 'ij',
        "\xC4\xB4" => 'J',
        "\xC4\xB5" => 'j',
        "\xC4\xB6" => 'K',
        "\xC4\xB7" => 'k',
        "\xC4\xB8" => 'k',
        "\xC4\xB9" => 'L',
        "\xC4\xBA" => 'l',
        "\xC4\xBB" => 'L',
        "\xC4\xBC" => 'l',
        "\xC4\xBD" => 'L',
        "\xC4\xBE" => 'l',
        "\xC4\xBF" => 'L',
        "\xC5\x80" => 'l',
        "\xC5\x81" => 'L',
        "\xC5\x82" => 'l',
        "\xC5\x83" => 'N',
        "\xC5\x84" => 'n',
        "\xC5\x85" => 'N',
        "\xC5\x86" => 'n',
        "\xC5\x87" => 'N',
        "\xC5\x88" => 'n',
        "\xC5\x89" => 'N',
        "\xC5\x8A" => 'n',
        "\xC5\x8B" => 'N',
        "\xC5\x8C" => 'O',
        "\xC5\x8D" => 'o',
        "\xC5\x8E" => 'O',
        "\xC5\x8F" => 'o',
        "\xC5\x90" => 'O',
        "\xC5\x91" => 'o',
        "\xC5\x92" => 'OE',
        "\xC5\x93" => 'oe',
        "\xC5\x94" => 'R',
        "\xC5\x95" => 'r',
        "\xC5\x96" => 'R',
        "\xC5\x97" => 'r',
        "\xC5\x98" => 'R',
        "\xC5\x99" => 'r',
        "\xC5\x9A" => 'S',
        "\xC5\x9B" => 's',
        "\xC5\x9C" => 'S',
        "\xC5\x9D" => 's',
        "\xC5\x9E" => 'S',
        "\xC5\x9F" => 's',
        "\xC5\xA0" => 'S',
        "\xC5\xA1" => 's',
        "\xC5\xA2" => 'T',
        "\xC5\xA3" => 't',
        "\xC5\xA4" => 'T',
        "\xC5\xA5" => 't',
        "\xC5\xA6" => 'T',
        "\xC5\xA7" => 't',
        "\xC5\xA8" => 'U',
        "\xC5\xA9" => 'u',
        "\xC5\xAA" => 'U',
        "\xC5\xAB" => 'u',
        "\xC5\xAC" => 'U',
        "\xC5\xAD" => 'u',
        "\xC5\xAE" => 'U',
        "\xC5\xAF" => 'u',
        "\xC5\xB0" => 'U',
        "\xC5\xB1" => 'u',
        "\xC5\xB2" => 'U',
        "\xC5\xB3" => 'u',
        "\xC5\xB4" => 'W',
        "\xC5\xB5" => 'w',
        "\xC5\xB6" => 'Y',
        "\xC5\xB7" => 'y',
        "\xC5\xB8" => 'Y',
        "\xC5\xB9" => 'Z',
        "\xC5\xBA" => 'z',
        "\xC5\xBB" => 'Z',
        "\xC5\xBC" => 'z',
        "\xC5\xBD" => 'Z',
        "\xC5\xBE" => 'z',
        "\xC5\xBF" => 's',
        // Euro Sign
        "\xE2\x82\xAC" => 'E',
        // GBP (Pound) Sign
        "\xC2\xA3" => '',
    ];

    /** @var WordInflector */
    private $singularizer;

    /** @var WordInflector */
    private $pluralizer;

    public function __construct(WordInflector $singularizer, WordInflector $pluralizer)
    {
        $this->singularizer = $singularizer;
        $this->pluralizer   = $pluralizer;
    }

    /**
     * Converts a word into the format for a Doctrine table name. Converts 'ModelName' to 'model_name'.
     */
    public function tableize(string $word) : string
    {
        $tableized = preg_replace('~(?<=\\w)([A-Z])~u', '_$1', $word);

        if ($tableized === null) {
            throw new RuntimeException(sprintf(
                'preg_replace returned null for value "%s"',
                $word
            ));
        }

        return mb_strtolower($tableized);
    }

    /**
     * Converts a word into the format for a Doctrine class name. Converts 'table_name' to 'TableName'.
     */
    public function classify(string $word) : string
    {
        return str_replace([' ', '_', '-'], '', ucwords($word, ' _-'));
    }

    /**
     * Camelizes a word. This uses the classify() method and turns the first character to lowercase.
     */
    public function camelize(string $word) : string
    {
        return lcfirst($this->classify($word));
    }

    /**
     * Uppercases words with configurable delimiters between words.
     *
     * Takes a string and capitalizes all of the words, like PHP's built-in
     * ucwords function. This extends that behavior, however, by allowing the
     * word delimiters to be configured, rather than only separating on
     * whitespace.
     *
     * Here is an example:
     * <code>
     * <?php
     * $string = 'top-o-the-morning to all_of_you!';
     * echo $inflector->capitalize($string);
     * // Top-O-The-Morning To All_of_you!
     *
     * echo $inflector->capitalize($string, '-_ ');
     * // Top-O-The-Morning To All_Of_You!
     * ?>
     * </code>
     *
     * @param string $string     The string to operate on.
     * @param string $delimiters A list of word separators.
     *
     * @return string The string with all delimiter-separated words capitalized.
     */
    public function capitalize(string $string, string $delimiters = " \n\t\r\0\x0B-") : string
    {
        return ucwords($string, $delimiters);
    }

    /**
     * Checks if the given string seems like it has utf8 characters in it.
     *
     * @param string $string The string to check for utf8 characters in.
     */
    public function seemsUtf8(string $string) : bool
    {
        for ($i = 0; $i < strlen($string); $i++) {
            if (ord($string[$i]) < 0x80) {
                continue; // 0bbbbbbb
            } elseif ((ord($string[$i]) & 0xE0) === 0xC0) {
                $n = 1; // 110bbbbb
            } elseif ((ord($string[$i]) & 0xF0) === 0xE0) {
                $n = 2; // 1110bbbb
            } elseif ((ord($string[$i]) & 0xF8) === 0xF0) {
                $n = 3; // 11110bbb
            } elseif ((ord($string[$i]) & 0xFC) === 0xF8) {
                $n = 4; // 111110bb
            } elseif ((ord($string[$i]) & 0xFE) === 0xFC) {
                $n = 5; // 1111110b
            } else {
                return false; // Does not match any model
            }

            for ($j = 0; $j < $n; $j++) { // n bytes matching 10bbbbbb follow ?
                if (++$i === strlen($string) || ((ord($string[$i]) & 0xC0) !== 0x80)) {
                    return false;
                }
            }
        }

        return true;
    }

    /**
     * Remove any illegal characters, accents, etc.
     *
     * @param  string $string String to unaccent
     *
     * @return string Unaccented string
     */
    public function unaccent(string $string) : string
    {
        if (preg_match('/[\x80-\xff]/', $string) === false) {
            return $string;
        }

        if ($this->seemsUtf8($string)) {
            $string = strtr($string, self::ACCENTED_CHARACTERS);
        } else {
            $characters = [];

            // Assume ISO-8859-1 if not UTF-8
            $characters['in'] =
                  chr(128)
                . chr(131)
                . chr(138)
                . chr(142)
                . chr(154)
                . chr(158)
                . chr(159)
                . chr(162)
                . chr(165)
                . chr(181)
                . chr(192)
                . chr(193)
                . chr(194)
                . chr(195)
                . chr(196)
                . chr(197)
                . chr(199)
                . chr(200)
                . chr(201)
                . chr(202)
                . chr(203)
                . chr(204)
                . chr(205)
                . chr(206)
                . chr(207)
                . chr(209)
                . chr(210)
                . chr(211)
                . chr(212)
                . chr(213)
                . chr(214)
                . chr(216)
                . chr(217)
                . chr(218)
                . chr(219)
                . chr(220)
                . chr(221)
                . chr(224)
                . chr(225)
                . chr(226)
                . chr(227)
                . chr(228)
                . chr(229)
                . chr(231)
                . chr(232)
                . chr(233)
                . chr(234)
                . chr(235)
                . chr(236)
                . chr(237)
                . chr(238)
                . chr(239)
                . chr(241)
                . chr(242)
                . chr(243)
                . chr(244)
                . chr(245)
                . chr(246)
                . chr(248)
                . chr(249)
                . chr(250)
                . chr(251)
                . chr(252)
                . chr(253)
                . chr(255);

            $characters['out'] = 'EfSZszYcYuAAAAAACEEEEIIIINOOOOOOUUUUYaaaaaaceeeeiiiinoooooouuuuyy';

            $string = strtr($string, $characters['in'], $characters['out']);

            $doubleChars = [];

            $doubleChars['in'] = [
                chr(140),
                chr(156),
                chr(198),
                chr(208),
                chr(222),
                chr(223),
                chr(230),
                chr(240),
                chr(254),
            ];

            $doubleChars['out'] = ['OE', 'oe', 'AE', 'DH', 'TH', 'ss', 'ae', 'dh', 'th'];

            $string = str_replace($doubleChars['in'], $doubleChars['out'], $string);
        }

        return $string;
    }

    /**
     * Convert any passed string to a url friendly string.
     * Converts 'My first blog post' to 'my-first-blog-post'
     *
     * @param  string $string String to urlize.
     *
     * @return string Urlized string.
     */
    public function urlize(string $string) : string
    {
        // Remove all non url friendly characters with the unaccent function
        $unaccented = $this->unaccent($string);

        if (function_exists('mb_strtolower')) {
            $lowered = mb_strtolower($unaccented);
        } else {
            $lowered = strtolower($unaccented);
        }

        $replacements = [
            '/\W/' => ' ',
            '/([A-Z]+)([A-Z][a-z])/' => '\1_\2',
            '/([a-z\d])([A-Z])/' => '\1_\2',
            '/[^A-Z^a-z^0-9^\/]+/' => '-',
        ];

        $urlized = $lowered;

        foreach ($replacements as $pattern => $replacement) {
            $replaced = preg_replace($pattern, $replacement, $urlized);

            if ($replaced === null) {
                throw new RuntimeException(sprintf(
                    'preg_replace returned null for value "%s"',
                    $urlized
                ));
            }

            $urlized = $replaced;
        }

        return trim($urlized, '-');
    }

    /**
     * Returns a word in singular form.
     *
     * @param string $word The word in plural form.
     *
     * @return string The word in singular form.
     */
    public function singularize(string $word) : string
    {
        return $this->singularizer->inflect($word);
    }

    /**
     * Returns a word in plural form.
     *
     * @param string $word The word in singular form.
     *
     * @return string The word in plural form.
     */
    public function pluralize(string $word) : string
    {
        return $this->pluralizer->inflect($word);
    }
}