Doctrine\Inflector\Inflector

Complexity

Total Complexity

10

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	tableize()	0	3	1
A	camelize()	0	3	1
A	pluralize()	0	3	1
A	rules()	0	6	2
A	reset()	0	3	1
A	singularize()	0	3	1
A	ucwords()	0	3	1
A	initialize()	0	7	1
A	classify()	0	3	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();