Inflector::singularize() - Code Metrics - Inspection of "Doctrine Inflector 2.0" - doctrine/inflector - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#90)

by Jonathan

created 2018-06-11 20:44 UTC

Inflector::singularize() A

↳ Parent: Inflector

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	3
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	1
nc	1
nop	1
crap	1

<?php

declare(strict_types=1);

namespace Doctrine\Inflector;

use Doctrine\Inflector\Rules\Uninflected;

/**
 * Doctrine inflector has static methods for inflecting text.
 *
 * The methods in these classes are from several different sources collected
 * across several different php projects and several different authors. The
 * original author names and emails are not known.
 *
 * Pluralize & Singularize implementation are borrowed from CakePHP with some modifications.
 *
 * @deprecated
 */
class Inflector
{
    /** @var Pluralizer */
    private static $pluralizer;

    /** @var Singularizer */
    private static $singularizer;

    /** @var Inflect */
    private static $inflect;

    public static function initialize() : void
    {
        $uninflected        = new Uninflected(Uninflected::DEFAULT);
        self::$pluralizer   = new Pluralizer($uninflected);
        self::$singularizer = new Singularizer($uninflected, self::$pluralizer);

        self::$inflect = new Inflect(self::$singularizer, self::$pluralizer);
    }

    /**
     * Converts a word into the format for a Doctrine table name. Converts 'ModelName' to 'model_name'.
     */
    public static function tableize(string $word) : string
    {
        return self::$inflect->tableize($word);
    }

    /**
     * Converts a word into the format for a Doctrine class name. Converts 'table_name' to 'TableName'.
     */
    public static function classify(string $word) : string
    {
        return self::$inflect->classify($word);
    }

    /**
     * Camelizes a word. This uses the classify() method and turns the first character to lowercase.
     */
    public static function camelize(string $word) : string
    {
        return self::$inflect->camelize($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 \Doctrine\Common\Inflector\Inflector::ucwords($string);
     * // Top-O-The-Morning To All_of_you!
     *
     * echo \Doctrine\Common\Inflector\Inflector::ucwords($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 static function ucwords(string $string, string $delimiters = " \n\t\r\0\x0B-") : string
    {
        return self::$inflect->ucwords($string, $delimiters);
    }

    /**
     * Clears Inflectors inflected value caches, and resets the inflection
     * rules to the initial values.
     */
    public static function reset() : void
    {
        self::initialize();
    }

    /**
     * Adds custom inflection $rules, of either 'plural' or 'singular' $type.
     *
     * ### Usage:
     *
     * {{{
     * Inflector::rules('plural', ['/^(inflect)or$/i' => '\1ables']);
     * Inflector::rules('plural', [
     *     'rules' => ['/^(inflect)ors$/i' => '\1ables'],
     *     'uninflected' => ['dontinflectme'],
     *     'irregular' => ['red' => 'redlings']
     * ]);
     * }}}
     *
     * @param string        $type  The type of inflection, either 'plural' or 'singular'
     * @param array|mixed[] $rules An array of rules to be added.
     *                             new rules that are being defined in $rules.
     * @param bool          $reset If true, will unset default inflections for all
     *                             new rules that are being defined in $rules.
     */
    public static function rules(string $type, array $rules, bool $reset = false) : void
    {
        if ($type === 'plural') {
            self::$pluralizer->addRules($rules, $reset);
        } else {
            self::$singularizer->addRules($rules, $reset);
        }
    }

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

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

Inflector::initialize();


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Doctrine\Inflector;
6
7		use Doctrine\Inflector\Rules\Uninflected;
8
9		/**
10		* Doctrine inflector has static methods for inflecting text.
11		*
12		* The methods in these classes are from several different sources collected
13		* across several different php projects and several different authors. The
14		* original author names and emails are not known.
15		*
16		* Pluralize & Singularize implementation are borrowed from CakePHP with some modifications.
17		*
18		* @deprecated
19		*/
20		class Inflector
21		{
22		/** @var Pluralizer */
23		private static $pluralizer;
24
25		/** @var Singularizer */
26		private static $singularizer;
27
28		/** @var Inflect */
29		private static $inflect;
30
31	4	public static function initialize() : void
32		{
33	4	$uninflected = new Uninflected(Uninflected::DEFAULT);
34	4	self::$pluralizer = new Pluralizer($uninflected);
35	4	self::$singularizer = new Singularizer($uninflected, self::$pluralizer);
36
37	4	self::$inflect = new Inflect(self::$singularizer, self::$pluralizer);
38	4	}
39
40		/**
41		* Converts a word into the format for a Doctrine table name. Converts 'ModelName' to 'model_name'.
42		*/
43	3	public static function tableize(string $word) : string
44		{
45	3	return self::$inflect->tableize($word);
46		}
47
48		/**
49		* Converts a word into the format for a Doctrine class name. Converts 'table_name' to 'TableName'.
50		*/
51	6	public static function classify(string $word) : string
52		{
53	6	return self::$inflect->classify($word);
54		}
55
56		/**
57		* Camelizes a word. This uses the classify() method and turns the first character to lowercase.
58		*/
59	5	public static function camelize(string $word) : string
60		{
61	5	return self::$inflect->camelize($word);
62		}
63
64		/**
65		* Uppercases words with configurable delimiters between words.
66		*
67		* Takes a string and capitalizes all of the words, like PHP's built-in
68		* ucwords function. This extends that behavior, however, by allowing the
69		* word delimiters to be configured, rather than only separating on
70		* whitespace.
71		*
72		* Here is an example:
73		* <code>
74		* <?php
75		* $string = 'top-o-the-morning to all_of_you!';
76		* echo \Doctrine\Common\Inflector\Inflector::ucwords($string);
77		* // Top-O-The-Morning To All_of_you!
78		*
79		* echo \Doctrine\Common\Inflector\Inflector::ucwords($string, '-_ ');
80		* // Top-O-The-Morning To All_Of_You!
81		* ?>
82		* </code>
83		*
84		* @param string $string The string to operate on.
85		* @param string $delimiters A list of word separators.
86		*
87		* @return string The string with all delimiter-separated words capitalized.
88		*/
89	2	public static function ucwords(string $string, string $delimiters = " \n\t\r\0\x0B-") : string
90		{
91	2	return self::$inflect->ucwords($string, $delimiters);
92		}
93
94		/**
95		* Clears Inflectors inflected value caches, and resets the inflection
96		* rules to the initial values.
97		*/
98	4	public static function reset() : void
99		{
100	4	self::initialize();
101	4	}
102
103		/**
104		* Adds custom inflection $rules, of either 'plural' or 'singular' $type.
105		*
106		* ### Usage:
107		*
108		* {{{
109		* Inflector::rules('plural', ['/^(inflect)or$/i' => '\1ables']);
110		* Inflector::rules('plural', [
111		* 'rules' => ['/^(inflect)ors$/i' => '\1ables'],
112		* 'uninflected' => ['dontinflectme'],
113		* 'irregular' => ['red' => 'redlings']
114		* ]);
115		* }}}
116		*
117		* @param string $type The type of inflection, either 'plural' or 'singular'
118		* @param array\|mixed[] $rules An array of rules to be added.
119		* new rules that are being defined in $rules.
120		* @param bool $reset If true, will unset default inflections for all
121		* new rules that are being defined in $rules.
122		*/
123	4	public static function rules(string $type, array $rules, bool $reset = false) : void
124		{
125	4	if ($type === 'plural') {
126	3	self::$pluralizer->addRules($rules, $reset);
127		} else {
128	3	self::$singularizer->addRules($rules, $reset);
129		}
130	4	}
131
132		/**
133		* Returns a word in plural form.
134		*
135		* @param string $word The word in singular form.
136		*
137		* @return string The word in plural form.
138		*/
139	256	public static function pluralize(string $word) : string
140		{
141	256	return self::$inflect->pluralize($word);
142		}
143
144		/**
145		* Returns a word in singular form.
146		*
147		* @param string $word The word in plural form.
148		*
149		* @return string The word in singular form.
150		*/
151	256	public static function singularize(string $word) : string
152		{
153	256	return self::$inflect->singularize($word);
154		}
155		}
156
157		Inflector::initialize();
158

doctrine / inflector

Pull Request — master (#90)

Inflector::singularize() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like