Source for file inflector.php

Documentation is available at inflector.php

  1. <?php
  2. /**
  3.  * @package     FrameworkOnFramework
  4.  * @subpackage  inflector
  5.  * @copyright   Copyright (C) 2010 - 2012 Akeeba Ltd. All rights reserved.
  6.  * @license     GNU General Public License version 2 or later; see LICENSE.txt
  7.  */
  8. defined('_JEXEC') or die;
  9.  
  10. /**
  11.  * The FOFInflector is an adaptation of the Akelos PHP Inflector which is a PHP
  12.  * port from a Ruby on Rails project.
  13.  */
  14.  
  15. /**
  16.  * FOFInflector to pluralize and singularize English nouns.
  17.  *
  18.  * @package  FrameworkOnFramework
  19.  * @since    1.0
  20.  */
  21. class FOFInflector
  22. {
  23.     /**
  24.      * Rules for pluralizing and singularizing of nouns.
  25.      *
  26.      * @var array 
  27.      */
  28.     protected static $_rules = array
  29.     (
  30.         'pluralization'   => array(
  31.             '/move$/i'                      => 'moves',
  32.             '/sex$/i'                       => 'sexes',
  33.             '/child$/i'                     => 'children',
  34.             '/man$/i'                       => 'men',
  35.             '/foot$/i'                      => 'feet',
  36.             '/person$/i'                    => 'people',
  37.             '/taxon$/i'                     => 'taxa',
  38.             '/(quiz)$/i'                    => '$1zes',
  39.             '/^(ox)$/i'                     => '$1en',
  40.             '/(m|l)ouse$/i'                 => '$1ice',
  41.             '/(matr|vert|ind|suff)ix|ex$/i' => '$1ices',
  42.             '/(x|ch|ss|sh)$/i'              => '$1es',
  43.             '/([^aeiouy]|qu)y$/i'           => '$1ies',
  44.             '/(?:([^f])fe|([lr])f)$/i'      => '$1$2ves',
  45.             '/sis$/i'                       => 'ses',
  46.             '/([ti]|addend)um$/i'           => '$1a',
  47.             '/(alumn|formul)a$/i'           => '$1ae',
  48.             '/(buffal|tomat|her)o$/i'       => '$1oes',
  49.             '/(bu)s$/i'                     => '$1ses',
  50.             '/(alias|status)$/i'            => '$1es',
  51.             '/(octop|vir)us$/i'             => '$1i',
  52.             '/(gen)us$/i'                   => '$1era',
  53.             '/(ax|test)is$/i'               => '$1es',
  54.             '/s$/i'                         => 's',
  55.             '/$/'                           => 's',
  56.         ),
  57.         'singularization' => array(
  58.             '/cookies$/i'                                                      => 'cookie',
  59.             '/moves$/i'                                                        => 'move',
  60.             '/sexes$/i'                                                        => 'sex',
  61.             '/children$/i'                                                     => 'child',
  62.             '/men$/i'                                                          => 'man',
  63.             '/feet$/i'                                                         => 'foot',
  64.             '/people$/i'                                                       => 'person',
  65.             '/taxa$/i'                                                         => 'taxon',
  66.             '/databases$/i'                                                    => 'database',
  67.             '/(quiz)zes$/i'                                                    => '\1',
  68.             '/(matr|suff)ices$/i'                                              => '\1ix',
  69.             '/(vert|ind)ices$/i'                                               => '\1ex',
  70.             '/^(ox)en/i'                                                       => '\1',
  71.             '/(alias|status)es$/i'                                             => '\1',
  72.             '/(tomato|hero|buffalo)es$/i'                                      => '\1',
  73.             '/([octop|vir])i$/i'                                               => '\1us',
  74.             '/(gen)era$/i'                                                     => '\1us',
  75.             '/(cris|^ax|test)es$/i'                                            => '\1is',
  76.             '/(shoe)s$/i'                                                      => '\1',
  77.             '/(o)es$/i'                                                        => '\1',
  78.             '/(bus)es$/i'                                                      => '\1',
  79.             '/([m|l])ice$/i'                                                   => '\1ouse',
  80.             '/(x|ch|ss|sh)es$/i'                                               => '\1',
  81.             '/(m)ovies$/i'                                                     => '\1ovie',
  82.             '/(s)eries$/i'                                                     => '\1eries',
  83.             '/([^aeiouy]|qu)ies$/i'                                            => '\1y',
  84.             '/([lr])ves$/i'                                                    => '\1f',
  85.             '/(tive)s$/i'                                                      => '\1',
  86.             '/(hive)s$/i'                                                      => '\1',
  87.             '/([^f])ves$/i'                                                    => '\1fe',
  88.             '/(^analy)ses$/i'                                                  => '\1sis',
  89.             '/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i' => '\1\2sis',
  90.             '/([ti]|addend)a$/i'                                               => '\1um',
  91.             '/(alumn|formul)ae$/i'                                             => '$1a',
  92.             '/(n)ews$/i'                                                       => '\1ews',
  93.             '/(.*)ss$/i'                                                       => '\1ss',
  94.             '/(.*)s$/i'                                                        => '\1',
  95.         ),
  96.         'countable'       => array(
  97.             'aircraft',
  98.             'cannon',
  99.             'deer',
  100.             'equipment',
  101.             'fish',
  102.             'information',
  103.             'money',
  104.             'moose',
  105.             'rice',
  106.             'series',
  107.             'sheep',
  108.             'species',
  109.             'swine',
  110.         )
  111.     );
  112.  
  113.     /**
  114.      * Cache of pluralized and singularized nouns.
  115.      *
  116.      * @var array 
  117.      */
  118.     protected static $_cache = array(
  119.         'singularized' => array(),
  120.         'pluralized'   => array()
  121.     );
  122.  
  123.     /**
  124.      * Constructor
  125.      *
  126.      * Prevent creating instances of this class by making the contructor private
  127.      */
  128.     private function __construct()
  129.     {
  130.     }
  131.  
  132.     /**
  133.      * Add a word to the cache, useful to make exceptions or to add words in other languages.
  134.      *
  135.      * @param   string  $singular  word.
  136.      * @param   string  $plural    word.
  137.      *
  138.      * @return  void 
  139.      */
  140.     public static function addWord($singular, $plural)
  141.     {
  142.         self::$_cache['pluralized'][$singular] = $plural;
  143.         self::$_cache['singularized'][$plural] = $singular;
  144.     }
  145.  
  146.     /**
  147.      * Singular English word to plural.
  148.      *
  149.      * @param   string  $word  word to pluralize.
  150.      *
  151.      * @return  string Plural noun.
  152.      */
  153.     public static function pluralize($word)
  154.     {
  155.         // Get the cached noun of it exists
  156.         if (isset(self::$_cache['pluralized'][$word]))
  157.         {
  158.             return self::$_cache['pluralized'][$word];
  159.         }
  160.  
  161.         // Create the plural noun
  162.         if (in_array($word, self::$_rules['countable']))
  163.         {
  164.             $_cache['pluralized'][$word] = $word;
  165.  
  166.             return $word;
  167.         }
  168.  
  169.         foreach (self::$_rules['pluralization'] as $regexp => $replacement)
  170.         {
  171.             $matches = null;
  172.             $plural  = preg_replace($regexp, $replacement, $word, -1, $matches);
  173.  
  174.             if ($matches > 0)
  175.             {
  176.                 $_cache['pluralized'][$word] = $plural;
  177.  
  178.                 return $plural;
  179.             }
  180.         }
  181.  
  182.         return $word;
  183.     }
  184.  
  185.     /**
  186.      * Plural English word to singular.
  187.      *
  188.      * @param   string  $word  Word to singularize.
  189.      *
  190.      * @return  string Singular noun.
  191.      */
  192.     public static function singularize($word)
  193.     {
  194.         // Get the cached noun of it exists
  195.         if (isset(self::$_cache['singularized'][$word]))
  196.         {
  197.             return self::$_cache['singularized'][$word];
  198.         }
  199.  
  200.         // Create the singular noun
  201.         if (in_array($word, self::$_rules['countable']))
  202.         {
  203.             $_cache['singularized'][$word] = $word;
  204.  
  205.             return $word;
  206.         }
  207.  
  208.         foreach (self::$_rules['singularization'] as $regexp => $replacement)
  209.         {
  210.             $matches  = null;
  211.             $singular = preg_replace($regexp, $replacement, $word, -1, $matches);
  212.  
  213.             if ($matches > 0)
  214.             {
  215.                 $_cache['singularized'][$word] = $singular;
  216.  
  217.                 return $singular;
  218.             }
  219.         }
  220.  
  221.         return $word;
  222.     }
  223.  
  224.     /**
  225.      * Returns given word as CamelCased.
  226.      *
  227.      * Converts a word like "foo_bar" or "foo bar" to "FooBar". It
  228.      * will remove non alphanumeric characters from the word, so
  229.      * "who's online" will be converted to "WhoSOnline"
  230.      *
  231.      * @param   string  $word  Word to convert to camel case.
  232.      *
  233.      * @return  string  UpperCamelCasedWord
  234.      */
  235.     public static function camelize($word)
  236.     {
  237.         $word = preg_replace('/[^a-zA-Z0-9\s]/', ' ', $word);
  238.         $word = str_replace(' ', '', ucwords(strtolower(str_replace('_', ' ', $word))));
  239.  
  240.         return $word;
  241.     }
  242.  
  243.     /**
  244.      * Converts a word "into_it_s_underscored_version"
  245.      *
  246.      * Convert any "CamelCased" or "ordinary Word" into an "underscored_word".
  247.      *
  248.      * @param   string  $word  Word to underscore
  249.      *
  250.      * @return string Underscored word
  251.      */
  252.     public static function underscore($word)
  253.     {
  254.         $word = preg_replace('/(\s)+/', '_', $word);
  255.         $word = strtolower(preg_replace('/(?<=\\w)([A-Z])/', '_\\1', $word));
  256.  
  257.         return $word;
  258.     }
  259.  
  260.     /**
  261.      * Convert any "CamelCased" word into an array of strings
  262.      *
  263.      * Returns an array of strings each of which is a substring of string formed
  264.      * by splitting it at the camelcased letters.
  265.      *
  266.      * @param   string  $word  Word to explode
  267.      *
  268.      * @return  array   Array of strings
  269.      */
  270.     public static function explode($word)
  271.     {
  272.         $result = explode('_', self::underscore($word));
  273.  
  274.         return $result;
  275.     }
  276.  
  277.     /**
  278.      * Convert  an array of strings into a "CamelCased" word.
  279.      *
  280.      * @param   array  $words  Array to implode
  281.      *
  282.      * @return  string UpperCamelCasedWord
  283.      */
  284.     public static function implode($words)
  285.     {
  286.         $result = self::camelize(implode('_', $words));
  287.  
  288.         return $result;
  289.     }
  290.  
  291.     /**
  292.      * Returns a human-readable string from $word.
  293.      *
  294.      * Returns a human-readable string from $word, by replacing
  295.      * underscores with a space, and by upper-casing the initial
  296.      * character by default.
  297.      *
  298.      * @param   string  $word  String to "humanize"
  299.      *
  300.      * @return string Human-readable word
  301.      */
  302.     public static function humanize($word)
  303.     {
  304.         $result = ucwords(strtolower(str_replace("_", " ", $word)));
  305.  
  306.         return $result;
  307.     }
  308.  
  309.     /**
  310.      * Converts a class name to its table name according to Koowa
  311.      * naming conventions.
  312.      *
  313.      * Converts "Person" to "people"
  314.      *
  315.      * @param   string  $className  Class name for getting related table_name.
  316.      *
  317.      * @return  string  plural_table_name
  318.      *
  319.      * @see classify
  320.      */
  321.     public static function tableize($className)
  322.     {
  323.         $result = self::underscore($className);
  324.  
  325.         if (!self::isPlural($className))
  326.         {
  327.             $result = self::pluralize($result);
  328.         }
  329.  
  330.         return $result;
  331.     }
  332.  
  333.     /**
  334.      * Converts a table name to its class name according to Koowa naming conventions.
  335.      *
  336.      * @param   string  $tableName  Table name for getting related ClassName.
  337.      *
  338.      * @return string SingularClassName
  339.      *
  340.      * @example  Converts "people" to "Person"
  341.      * @see tableize
  342.      */
  343.     public static function classify($tableName)
  344.     {
  345.         $result = self::camelize(self::singularize($tableName));
  346.  
  347.         return $result;
  348.     }
  349.  
  350.     /**
  351.      * Returns camelBacked version of a string. Same as camelize but first char is lowercased.
  352.      *
  353.      * @param   string  $string  String to be camelBacked.
  354.      *
  355.      * @return string 
  356.      *
  357.      * @see camelize
  358.      */
  359.     public static function variablize($string)
  360.     {
  361.         $string   = self::camelize(self::underscore($string));
  362.         $result   = strtolower(substr($string, 0, 1));
  363.         $variable = preg_replace('/\\w/', $result, $string, 1);
  364.  
  365.         return $variable;
  366.     }
  367.  
  368.     /**
  369.      * Check to see if an English word is singular
  370.      *
  371.      * @param   string  $string  The word to check
  372.      *
  373.      * @return boolean 
  374.      */
  375.     public static function isSingular($string)
  376.     {
  377.         // Check cache assuming the string is plural.
  378.         $singular = isset(self::$_cache['singularized'][$string]) ? self::$_cache['singularized'][$string] : null;
  379.         $plural   = $singular && isset(self::$_cache['pluralized'][$singular]) ? self::$_cache['pluralized'][$singular] : null;
  380.  
  381.         if ($singular && $plural)
  382.         {
  383.             return $plural != $string;
  384.         }
  385.  
  386.         // If string is not in the cache, try to pluralize and singularize it.
  387.         return self::singularize(self::pluralize($string)) == $string;
  388.     }
  389.  
  390.     /**
  391.      * Check to see if an Enlish word is plural.
  392.      *
  393.      * @param   string  $string  String to be checked.
  394.      *
  395.      * @return boolean 
  396.      */
  397.     public static function isPlural($string)
  398.     {
  399.         // Check cache assuming the string is singular.
  400.         $plural   = isset(self::$_cache['pluralized'][$string]) ? self::$_cache['pluralized'][$string] : null;
  401.         $singular = $plural && isset(self::$_cache['singularized'][$plural]) ? self::$_cache['singularized'][$plural] : null;
  402.  
  403.         if ($plural && $singular)
  404.         {
  405.             return $singular != $string;
  406.         }
  407.  
  408.         // If string is not in the cache, try to singularize and pluralize it.
  409.         return self::pluralize(self::singularize($string)) == $string;
  410.     }
  411.  
  412.     /**
  413.      * Gets a part of a CamelCased word by index.
  414.      *
  415.      * Use a negative index to start at the last part of the word (-1 is the
  416.      * last part)
  417.      *
  418.      * @param   string   $string   Word
  419.      * @param   integer  $index    Index of the part
  420.      * @param   string   $default  Default value
  421.      *
  422.      * @return string 
  423.      */
  424.     public static function getPart($string, $index, $default = null)
  425.     {
  426.         $parts = self::explode($string);
  427.  
  428.         if ($index < 0)
  429.         {
  430.             $index = count($parts) + $index;
  431.         }
  432.  
  433.         return isset($parts[$index]) ? $parts[$index] : $default;
  434.     }
  435. }

Documentation generated on Tue, 19 Nov 2013 15:05:33 +0100 by phpDocumentor 1.4.3