Laclic
/
Souke
Следить 5
В избранное 0
Форкнуть 1
Код Задачи 1 Pull Request'ы 0 Релизы 0 Вики Активность
609 коммитов
6 Ветки
Дерево: 15a0e4946a
Souke/vendor/yiisoft/yii2/helpers/BaseInflector.php

586 lines
21KB
Исходник Blame История 

  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.  * BaseInflector provides concrete implementation for [[Inflector]].

  14.  *

  15.  * Do not use BaseInflector. Use [[Inflector]] instead.

  16.  *

  17.  * @author Antonio Ramirez <amigo.cobos@gmail.com>

  18.  * @author Alexander Makarov <sam@rmcreative.ru>

  19.  * @since 2.0

  20.  */

  21. class BaseInflector

  22. {

  23.     /**

  24.      * @var array the rules for converting a word into its plural form.

  25.      * The keys are the regular expressions and the values are the corresponding replacements.

  26.      */

  27.     public static $plurals = [

  28.         '/([nrlm]ese|deer|fish|sheep|measles|ois|pox|media)$/i' => '\1',

  29.         '/^(sea[- ]bass)$/i' => '\1',

  30.         '/(m)ove$/i' => '\1oves',

  31.         '/(f)oot$/i' => '\1eet',

  32.         '/(h)uman$/i' => '\1umans',

  33.         '/(s)tatus$/i' => '\1tatuses',

  34.         '/(s)taff$/i' => '\1taff',

  35.         '/(t)ooth$/i' => '\1eeth',

  36.         '/(quiz)$/i' => '\1zes',

  37.         '/^(ox)$/i' => '\1\2en',

  38.         '/([m|l])ouse$/i' => '\1ice',

  39.         '/(matr|vert|ind)(ix|ex)$/i' => '\1ices',

  40.         '/(x|ch|ss|sh)$/i' => '\1es',

  41.         '/([^aeiouy]|qu)y$/i' => '\1ies',

  42.         '/(hive)$/i' => '\1s',

  43.         '/(?:([^f])fe|([lr])f)$/i' => '\1\2ves',

  44.         '/sis$/i' => 'ses',

  45.         '/([ti])um$/i' => '\1a',

  46.         '/(p)erson$/i' => '\1eople',

  47.         '/(m)an$/i' => '\1en',

  48.         '/(c)hild$/i' => '\1hildren',

  49.         '/(buffal|tomat|potat|ech|her|vet)o$/i' => '\1oes',

  50.         '/(alumn|bacill|cact|foc|fung|nucle|radi|stimul|syllab|termin|vir)us$/i' => '\1i',

  51.         '/us$/i' => 'uses',

  52.         '/(alias)$/i' => '\1es',

  53.         '/(ax|cris|test)is$/i' => '\1es',

  54.         '/s$/' => 's',

  55.         '/^$/' => '',

  56.         '/$/' => 's',

  57.     ];

  58.     /**

  59.      * @var array the rules for converting a word into its singular form.

  60.      * The keys are the regular expressions and the values are the corresponding replacements.

  61.      */

  62.     public static $singulars = [

  63.         '/([nrlm]ese|deer|fish|sheep|measles|ois|pox|media|ss)$/i' => '\1',

  64.         '/^(sea[- ]bass)$/i' => '\1',

  65.         '/(s)tatuses$/i' => '\1tatus',

  66.         '/(f)eet$/i' => '\1oot',

  67.         '/(t)eeth$/i' => '\1ooth',

  68.         '/^(.*)(menu)s$/i' => '\1\2',

  69.         '/(quiz)zes$/i' => '\\1',

  70.         '/(matr)ices$/i' => '\1ix',

  71.         '/(vert|ind)ices$/i' => '\1ex',

  72.         '/^(ox)en/i' => '\1',

  73.         '/(alias)(es)*$/i' => '\1',

  74.         '/(alumn|bacill|cact|foc|fung|nucle|radi|stimul|syllab|termin|viri?)i$/i' => '\1us',

  75.         '/([ftw]ax)es/i' => '\1',

  76.         '/(cris|ax|test)es$/i' => '\1is',

  77.         '/(shoe|slave)s$/i' => '\1',

  78.         '/(o)es$/i' => '\1',

  79.         '/ouses$/' => 'ouse',

  80.         '/([^a])uses$/' => '\1us',

  81.         '/([m|l])ice$/i' => '\1ouse',

  82.         '/(x|ch|ss|sh)es$/i' => '\1',

  83.         '/(m)ovies$/i' => '\1\2ovie',

  84.         '/(s)eries$/i' => '\1\2eries',

  85.         '/([^aeiouy]|qu)ies$/i' => '\1y',

  86.         '/([lr])ves$/i' => '\1f',

  87.         '/(tive)s$/i' => '\1',

  88.         '/(hive)s$/i' => '\1',

  89.         '/(drive)s$/i' => '\1',

  90.         '/([^fo])ves$/i' => '\1fe',

  91.         '/(^analy)ses$/i' => '\1sis',

  92.         '/(analy|diagno|^ba|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i' => '\1\2sis',

  93.         '/([ti])a$/i' => '\1um',

  94.         '/(p)eople$/i' => '\1\2erson',

  95.         '/(m)en$/i' => '\1an',

  96.         '/(c)hildren$/i' => '\1\2hild',

  97.         '/(n)ews$/i' => '\1\2ews',

  98.         '/(n)etherlands$/i' => '\1\2etherlands',

  99.         '/eaus$/' => 'eau',

  100.         '/^(.*us)$/' => '\\1',

  101.         '/s$/i' => '',

  102.     ];

  103.     /**

  104.      * @var array the special rules for converting a word between its plural form and singular form.

  105.      * The keys are the special words in singular form, and the values are the corresponding plural form.

  106.      */

  107.     public static $specials = [

  108.         'atlas' => 'atlases',

  109.         'beef' => 'beefs',

  110.         'brother' => 'brothers',

  111.         'cafe' => 'cafes',

  112.         'child' => 'children',

  113.         'cookie' => 'cookies',

  114.         'corpus' => 'corpuses',

  115.         'cow' => 'cows',

  116.         'curve' => 'curves',

  117.         'foe' => 'foes',

  118.         'ganglion' => 'ganglions',

  119.         'genie' => 'genies',

  120.         'genus' => 'genera',

  121.         'graffito' => 'graffiti',

  122.         'hoof' => 'hoofs',

  123.         'loaf' => 'loaves',

  124.         'man' => 'men',

  125.         'money' => 'monies',

  126.         'mongoose' => 'mongooses',

  127.         'move' => 'moves',

  128.         'mythos' => 'mythoi',

  129.         'niche' => 'niches',

  130.         'numen' => 'numina',

  131.         'occiput' => 'occiputs',

  132.         'octopus' => 'octopuses',

  133.         'opus' => 'opuses',

  134.         'ox' => 'oxen',

  135.         'penis' => 'penises',

  136.         'sex' => 'sexes',

  137.         'soliloquy' => 'soliloquies',

  138.         'testis' => 'testes',

  139.         'trilby' => 'trilbys',

  140.         'turf' => 'turfs',

  141.         'wave' => 'waves',

  142.         'Amoyese' => 'Amoyese',

  143.         'bison' => 'bison',

  144.         'Borghese' => 'Borghese',

  145.         'bream' => 'bream',

  146.         'breeches' => 'breeches',

  147.         'britches' => 'britches',

  148.         'buffalo' => 'buffalo',

  149.         'cantus' => 'cantus',

  150.         'carp' => 'carp',

  151.         'chassis' => 'chassis',

  152.         'clippers' => 'clippers',

  153.         'cod' => 'cod',

  154.         'coitus' => 'coitus',

  155.         'Congoese' => 'Congoese',

  156.         'contretemps' => 'contretemps',

  157.         'corps' => 'corps',

  158.         'debris' => 'debris',

  159.         'diabetes' => 'diabetes',

  160.         'djinn' => 'djinn',

  161.         'eland' => 'eland',

  162.         'elk' => 'elk',

  163.         'equipment' => 'equipment',

  164.         'Faroese' => 'Faroese',

  165.         'flounder' => 'flounder',

  166.         'Foochowese' => 'Foochowese',

  167.         'gallows' => 'gallows',

  168.         'Genevese' => 'Genevese',

  169.         'Genoese' => 'Genoese',

  170.         'Gilbertese' => 'Gilbertese',

  171.         'graffiti' => 'graffiti',

  172.         'headquarters' => 'headquarters',

  173.         'herpes' => 'herpes',

  174.         'hijinks' => 'hijinks',

  175.         'Hottentotese' => 'Hottentotese',

  176.         'information' => 'information',

  177.         'innings' => 'innings',

  178.         'jackanapes' => 'jackanapes',

  179.         'Kiplingese' => 'Kiplingese',

  180.         'Kongoese' => 'Kongoese',

  181.         'Lucchese' => 'Lucchese',

  182.         'mackerel' => 'mackerel',

  183.         'Maltese' => 'Maltese',

  184.         'mews' => 'mews',

  185.         'moose' => 'moose',

  186.         'mumps' => 'mumps',

  187.         'Nankingese' => 'Nankingese',

  188.         'news' => 'news',

  189.         'nexus' => 'nexus',

  190.         'Niasese' => 'Niasese',

  191.         'Pekingese' => 'Pekingese',

  192.         'Piedmontese' => 'Piedmontese',

  193.         'pincers' => 'pincers',

  194.         'Pistoiese' => 'Pistoiese',

  195.         'pliers' => 'pliers',

  196.         'Portuguese' => 'Portuguese',

  197.         'proceedings' => 'proceedings',

  198.         'rabies' => 'rabies',

  199.         'rice' => 'rice',

  200.         'rhinoceros' => 'rhinoceros',

  201.         'salmon' => 'salmon',

  202.         'Sarawakese' => 'Sarawakese',

  203.         'scissors' => 'scissors',

  204.         'series' => 'series',

  205.         'Shavese' => 'Shavese',

  206.         'shears' => 'shears',

  207.         'siemens' => 'siemens',

  208.         'species' => 'species',

  209.         'swine' => 'swine',

  210.         'testes' => 'testes',

  211.         'trousers' => 'trousers',

  212.         'trout' => 'trout',

  213.         'tuna' => 'tuna',

  214.         'Vermontese' => 'Vermontese',

  215.         'Wenchowese' => 'Wenchowese',

  216.         'whiting' => 'whiting',

  217.         'wildebeest' => 'wildebeest',

  218.         'Yengeese' => 'Yengeese',

  219.     ];

  220.     /**

  221.      * @var array fallback map for transliteration used by [[transliterate()]] when intl isn't available.

  222.      */

  223.     public static $transliteration = [

  224.         'À' => 'A', 'Á' => 'A', 'Â' => 'A', 'Ã' => 'A', 'Ä' => 'A', 'Å' => 'A', 'Æ' => 'AE', 'Ç' => 'C',

  225.         'È' => 'E', 'É' => 'E', 'Ê' => 'E', 'Ë' => 'E', 'Ì' => 'I', 'Í' => 'I', 'Î' => 'I', 'Ï' => 'I',

  226.         'Ð' => 'D', 'Ñ' => 'N', 'Ò' => 'O', 'Ó' => 'O', 'Ô' => 'O', 'Õ' => 'O', 'Ö' => 'O', 'Ő' => 'O',

  227.         'Ø' => 'O', 'Ù' => 'U', 'Ú' => 'U', 'Û' => 'U', 'Ü' => 'U', 'Ű' => 'U', 'Ý' => 'Y', 'Þ' => 'TH',

  228.         'ß' => 'ss',

  229.         'à' => 'a', 'á' => 'a', 'â' => 'a', 'ã' => 'a', 'ä' => 'a', 'å' => 'a', 'æ' => 'ae', 'ç' => 'c',

  230.         'è' => 'e', 'é' => 'e', 'ê' => 'e', 'ë' => 'e', 'ì' => 'i', 'í' => 'i', 'î' => 'i', 'ï' => 'i',

  231.         'ð' => 'd', 'ñ' => 'n', 'ò' => 'o', 'ó' => 'o', 'ô' => 'o', 'õ' => 'o', 'ö' => 'o', 'ő' => 'o',

  232.         'ø' => 'o', 'ù' => 'u', 'ú' => 'u', 'û' => 'u', 'ü' => 'u', 'ű' => 'u', 'ý' => 'y', 'þ' => 'th',

  233.         'ÿ' => 'y',

  234.     ];

  235.     /**

  236.      * Shortcut for `Any-Latin; NFKD` transliteration rule. The rule is strict, letters will be transliterated with

  237.      * the closest sound-representation chars. The result may contain any UTF-8 chars. For example:

  238.      * `获取到 どちら Українська: ґ,є, Српска: ђ, њ, џ! ¿Español?` will be transliterated to

  239.      * `huò qǔ dào dochira Ukraí̈nsʹka: g̀,ê, Srpska: đ, n̂, d̂! ¿Español?`

  240.      *

  241.      * Used in [[transliterate()]].

  242.      * For detailed information see [unicode normalization forms](http://unicode.org/reports/tr15/#Normalization_Forms_Table)

  243.      * @see http://unicode.org/reports/tr15/#Normalization_Forms_Table

  244.      * @see transliterate()

  245.      * @since 2.0.7

  246.      */

  247.     const TRANSLITERATE_STRICT = 'Any-Latin; NFKD';

  248.     /**

  249.      * Shortcut for `Any-Latin; Latin-ASCII` transliteration rule. The rule is medium, letters will be

  250.      * transliterated to characters of Latin-1 (ISO 8859-1) ASCII table. For example:

  251.      * `获取到 どちら Українська: ґ,є, Српска: ђ, њ, џ! ¿Español?` will be transliterated to

  252.      * `huo qu dao dochira Ukrainsʹka: g,e, Srpska: d, n, d! ¿Espanol?`

  253.      *

  254.      * Used in [[transliterate()]].

  255.      * For detailed information see [unicode normalization forms](http://unicode.org/reports/tr15/#Normalization_Forms_Table)

  256.      * @see http://unicode.org/reports/tr15/#Normalization_Forms_Table

  257.      * @see transliterate()

  258.      * @since 2.0.7

  259.      */

  260.     const TRANSLITERATE_MEDIUM = 'Any-Latin; Latin-ASCII';

  261.     /**

  262.      * Shortcut for `Any-Latin; Latin-ASCII; [\u0080-\uffff] remove` transliteration rule. The rule is loose,

  263.      * letters will be transliterated with the characters of Basic Latin Unicode Block.

  264.      * For example:

  265.      * `获取到 どちら Українська: ґ,є, Српска: ђ, њ, џ! ¿Español?` will be transliterated to

  266.      * `huo qu dao dochira Ukrainska: g,e, Srpska: d, n, d! Espanol?`

  267.      *

  268.      * Used in [[transliterate()]].

  269.      * For detailed information see [unicode normalization forms](http://unicode.org/reports/tr15/#Normalization_Forms_Table)

  270.      * @see http://unicode.org/reports/tr15/#Normalization_Forms_Table

  271.      * @see transliterate()

  272.      * @since 2.0.7

  273.      */

  274.     const TRANSLITERATE_LOOSE = 'Any-Latin; Latin-ASCII; [\u0080-\uffff] remove';

  275. 

  276.     /**

  277.      * @var mixed Either a [[\Transliterator]], or a string from which a [[\Transliterator]] can be built

  278.      * for transliteration. Used by [[transliterate()]] when intl is available. Defaults to [[TRANSLITERATE_LOOSE]]

  279.      * @see http://php.net/manual/en/transliterator.transliterate.php

  280.      */

  281.     public static $transliterator = self::TRANSLITERATE_LOOSE;

  282. 

  283. 

  284.     /**

  285.      * Converts a word to its plural form.

  286.      * Note that this is for English only!

  287.      * For example, 'apple' will become 'apples', and 'child' will become 'children'.

  288.      * @param string $word the word to be pluralized

  289.      * @return string the pluralized word

  290.      */

  291.     public static function pluralize($word)

  292.     {

  293.         if (isset(static::$specials[$word])) {

  294.             return static::$specials[$word];

  295.         }

  296.         foreach (static::$plurals as $rule => $replacement) {

  297.             if (preg_match($rule, $word)) {

  298.                 return preg_replace($rule, $replacement, $word);

  299.             }

  300.         }

  301. 

  302.         return $word;

  303.     }

  304. 

  305.     /**

  306.      * Returns the singular of the $word

  307.      * @param string $word the english word to singularize

  308.      * @return string Singular noun.

  309.      */

  310.     public static function singularize($word)

  311.     {

  312.         $result = array_search($word, static::$specials, true);

  313.         if ($result !== false) {

  314.             return $result;

  315.         }

  316.         foreach (static::$singulars as $rule => $replacement) {

  317.             if (preg_match($rule, $word)) {

  318.                 return preg_replace($rule, $replacement, $word);

  319.             }

  320.         }

  321. 

  322.         return $word;

  323.     }

  324. 

  325.     /**

  326.      * Converts an underscored or CamelCase word into a English

  327.      * sentence.

  328.      * @param string $words

  329.      * @param boolean $ucAll whether to set all words to uppercase

  330.      * @return string

  331.      */

  332.     public static function titleize($words, $ucAll = false)

  333.     {

  334.         $words = static::humanize(static::underscore($words), $ucAll);

  335. 

  336.         return $ucAll ? ucwords($words) : ucfirst($words);

  337.     }

  338. 

  339.     /**

  340.      * Returns given word as CamelCased

  341.      * Converts a word like "send_email" to "SendEmail". It

  342.      * will remove non alphanumeric character from the word, so

  343.      * "who's online" will be converted to "WhoSOnline"

  344.      * @see variablize()

  345.      * @param string $word the word to CamelCase

  346.      * @return string

  347.      */

  348.     public static function camelize($word)

  349.     {

  350.         return str_replace(' ', '', ucwords(preg_replace('/[^A-Za-z0-9]+/', ' ', $word)));

  351.     }

  352. 

  353.     /**

  354.      * Converts a CamelCase name into space-separated words.

  355.      * For example, 'PostTag' will be converted to 'Post Tag'.

  356.      * @param string $name the string to be converted

  357.      * @param boolean $ucwords whether to capitalize the first letter in each word

  358.      * @return string the resulting words

  359.      */

  360.     public static function camel2words($name, $ucwords = true)

  361.     {

  362.         $label = trim(strtolower(str_replace([

  363.             '-',

  364.             '_',

  365.             '.',

  366.         ], ' ', preg_replace('/(?<![A-Z])[A-Z]/', ' \0', $name))));

  367. 

  368.         return $ucwords ? ucwords($label) : $label;

  369.     }

  370. 

  371.     /**

  372.      * Converts a CamelCase name into an ID in lowercase.

  373.      * Words in the ID may be concatenated using the specified character (defaults to '-').

  374.      * For example, 'PostTag' will be converted to 'post-tag'.

  375.      * @param string $name the string to be converted

  376.      * @param string $separator the character used to concatenate the words in the ID

  377.      * @param boolean|string $strict whether to insert a separator between two consecutive uppercase chars, defaults to false

  378.      * @return string the resulting ID

  379.      */

  380.     public static function camel2id($name, $separator = '-', $strict = false)

  381.     {

  382.         $regex = $strict ? '/[A-Z]/' : '/(?<![A-Z])[A-Z]/';

  383.         if ($separator === '_') {

  384.             return trim(strtolower(preg_replace($regex, '_\0', $name)), '_');

  385.         } else {

  386.             return trim(strtolower(str_replace('_', $separator, preg_replace($regex, $separator . '\0', $name))), $separator);

  387.         }

  388.     }

  389. 

  390.     /**

  391.      * Converts an ID into a CamelCase name.

  392.      * Words in the ID separated by `$separator` (defaults to '-') will be concatenated into a CamelCase name.

  393.      * For example, 'post-tag' is converted to 'PostTag'.

  394.      * @param string $id the ID to be converted

  395.      * @param string $separator the character used to separate the words in the ID

  396.      * @return string the resulting CamelCase name

  397.      */

  398.     public static function id2camel($id, $separator = '-')

  399.     {

  400.         return str_replace(' ', '', ucwords(implode(' ', explode($separator, $id))));

  401.     }

  402. 

  403.     /**

  404.      * Converts any "CamelCased" into an "underscored_word".

  405.      * @param string $words the word(s) to underscore

  406.      * @return string

  407.      */

  408.     public static function underscore($words)

  409.     {

  410.         return strtolower(preg_replace('/(?<=\\w)([A-Z])/', '_\\1', $words));

  411.     }

  412. 

  413.     /**

  414.      * Returns a human-readable string from $word

  415.      * @param string $word the string to humanize

  416.      * @param boolean $ucAll whether to set all words to uppercase or not

  417.      * @return string

  418.      */

  419.     public static function humanize($word, $ucAll = false)

  420.     {

  421.         $word = str_replace('_', ' ', preg_replace('/_id$/', '', $word));

  422. 

  423.         return $ucAll ? ucwords($word) : ucfirst($word);

  424.     }

  425. 

  426.     /**

  427.      * Same as camelize but first char is in lowercase.

  428.      * Converts a word like "send_email" to "sendEmail". It

  429.      * will remove non alphanumeric character from the word, so

  430.      * "who's online" will be converted to "whoSOnline"

  431.      * @param string $word to lowerCamelCase

  432.      * @return string

  433.      */

  434.     public static function variablize($word)

  435.     {

  436.         $word = static::camelize($word);

  437. 

  438.         return strtolower($word[0]) . substr($word, 1);

  439.     }

  440. 

  441.     /**

  442.      * Converts a class name to its table name (pluralized)

  443.      * naming conventions. For example, converts "Person" to "people"

  444.      * @param string $className the class name for getting related table_name

  445.      * @return string

  446.      */

  447.     public static function tableize($className)

  448.     {

  449.         return static::pluralize(static::underscore($className));

  450.     }

  451. 

  452.     /**

  453.      * Returns a string with all spaces converted to given replacement,

  454.      * non word characters removed and the rest of characters transliterated.

  455.      *

  456.      * If intl extension isn't available uses fallback that converts latin characters only

  457.      * and removes the rest. You may customize characters map via $transliteration property

  458.      * of the helper.

  459.      *

  460.      * @param string $string An arbitrary string to convert

  461.      * @param string $replacement The replacement to use for spaces

  462.      * @param boolean $lowercase whether to return the string in lowercase or not. Defaults to `true`.

  463.      * @return string The converted string.

  464.      */

  465.     public static function slug($string, $replacement = '-', $lowercase = true)

  466.     {

  467.         $string = static::transliterate($string);

  468.         $string = preg_replace('/[^a-zA-Z0-9=\s—–-]+/u', '', $string);

  469.         $string = preg_replace('/[=\s—–-]+/u', $replacement, $string);

  470.         $string = trim($string, $replacement);

  471. 

  472.         return $lowercase ? strtolower($string) : $string;

  473.     }

  474. 

  475.     /**

  476.      * Returns transliterated version of a string.

  477.      *

  478.      * If intl extension isn't available uses fallback that converts latin characters only

  479.      * and removes the rest. You may customize characters map via $transliteration property

  480.      * of the helper.

  481.      *

  482.      * @param string $string input string

  483.      * @param string|\Transliterator $transliterator either a [[Transliterator]] or a string

  484.      * from which a [[Transliterator]] can be built.

  485.      * @return string

  486.      * @since 2.0.7 this method is public.

  487.      */

  488.     public static function transliterate($string, $transliterator = null)

  489.     {

  490.         if (static::hasIntl()) {

  491.             if ($transliterator === null) {

  492.                 $transliterator = static::$transliterator;

  493.             }

  494. 

  495.             return transliterator_transliterate($transliterator, $string);

  496.         } else {

  497.             return strtr($string, static::$transliteration);

  498.         }

  499.     }

  500. 

  501.     /**

  502.      * @return boolean if intl extension is loaded

  503.      */

  504.     protected static function hasIntl()

  505.     {

  506.         return extension_loaded('intl');

  507.     }

  508. 

  509.     /**

  510.      * Converts a table name to its class name. For example, converts "people" to "Person"

  511.      * @param string $tableName

  512.      * @return string

  513.      */

  514.     public static function classify($tableName)

  515.     {

  516.         return static::camelize(static::singularize($tableName));

  517.     }

  518. 

  519.     /**

  520.      * Converts number to its ordinal English form. For example, converts 13 to 13th, 2 to 2nd ...

  521.      * @param integer $number the number to get its ordinal value

  522.      * @return string

  523.      */

  524.     public static function ordinalize($number)

  525.     {

  526.         if (in_array($number % 100, range(11, 13))) {

  527.             return $number . 'th';

  528.         }

  529.         switch ($number % 10) {

  530.             case 1:

  531.                 return $number . 'st';

  532.             case 2:

  533.                 return $number . 'nd';

  534.             case 3:

  535.                 return $number . 'rd';

  536.             default:

  537.                 return $number . 'th';

  538.         }

  539.     }

  540. 

  541.     /**

  542.      * Converts a list of words into a sentence.

  543.      *

  544.      * Special treatment is done for the last few words. For example,

  545.      *

  546.      * ```php

  547.      * $words = ['Spain', 'France'];

  548.      * echo Inflector::sentence($words);

  549.      * // output: Spain and France

  550.      *

  551.      * $words = ['Spain', 'France', 'Italy'];

  552.      * echo Inflector::sentence($words);

  553.      * // output: Spain, France and Italy

  554.      *

  555.      * $words = ['Spain', 'France', 'Italy'];

  556.      * echo Inflector::sentence($words, ' & ');

  557.      * // output: Spain, France & Italy

  558.      * ```

  559.      *

  560.      * @param array $words the words to be converted into an string

  561.      * @param string $twoWordsConnector the string connecting words when there are only two

  562.      * @param string $lastWordConnector the string connecting the last two words. If this is null, it will

  563.      * take the value of `$twoWordsConnector`.

  564.      * @param string $connector the string connecting words other than those connected by

  565.      * $lastWordConnector and $twoWordsConnector

  566.      * @return string the generated sentence

  567.      * @since 2.0.1

  568.      */

  569.     public static function sentence(array $words, $twoWordsConnector = ' and ', $lastWordConnector = null, $connector = ', ')

  570.     {

  571.         if ($lastWordConnector === null) {

  572.             $lastWordConnector = $twoWordsConnector;

  573.         }

  574.         switch (count($words)) {

  575.             case 0:

  576.                 return '';

  577.             case 1:

  578.                 return reset($words);

  579.             case 2:

  580.                 return implode($twoWordsConnector, $words);

  581.             default:

  582.                 return implode($connector, array_slice($words, 0, -1)) . $lastWordConnector . end($words);

  583.         }

  584.     }

  585. }