Doctrine Inflector

https://github.com/doctrine/inflector
Admin
Doctrine Inflector is a small PHP library that performs string manipulations, specifically handling...
Tokens:63,514
Snippets:479
Trust Score:9.7
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Pattern usage example

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Pattern.md

Shows how to create a Pattern and use matches(). The first pattern is wrapped with '/i' (case-insensitive), while a pattern starting with '/' is used verbatim.

```php
use Doctrine\Inflector\Rules\Pattern;

$pattern = new Pattern('^ox$');        // compiled as '/^ox$/i'
$pattern->matches('OX');               // true (case-insensitive)
$pattern->matches('oxen');             // false

$explicit = new Pattern('/^(bil)er$/i'); // already a full regex — used verbatim
echo $explicit->getRegex();              // /^(bil)er$/i
```

--------------------------------

### Full assembly example (manual wiring)

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/English.md

Example of manually wiring the inflector with the English rules, demonstrating pluralize and singularize usage.

```APIDOC
## [GET] Full assembly example (manual wiring)

### Description
Demonstrates how to instantiate the Inflector with the English ruleset and use pluralize and singularize methods.

### Method
GET

### Endpoint
Full assembly example (manual wiring)

### Parameters
None

### Request Example
```php
use Doctrine\Inflector\CachedWordInflector;
use Doctrine\Inflector\Inflector;
use Doctrine\Inflector\RulesetInflector;
use Doctrine\Inflector\Rules\English;

$inflector = new Inflector(
    new CachedWordInflector(new RulesetInflector(English\Rules::getSingularRuleset())),
    new CachedWordInflector(new RulesetInflector(English\Rules::getPluralRuleset()))
);

echo $inflector->pluralize('browser');  // browsers
echo $inflector->singularize('people'); // person
```

### Response
#### Success Response (200)
- **output** (string) - The pluralized or singularized word.

#### Response Example
```
browsers
person
```
```

--------------------------------

### Chained custom rules (from the README "Custom Setup" example)

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/LanguageInflectorFactory.md

Creates an inflector with custom singular and plural rules using the InflectorFactory. Demonstrates the use of Ruleset, Transformations, Patterns, and Substitutions classes. The example shows how to define custom transformations, patterns, and substitutions for both singular and plural forms.

```php
use Doctrine\Inflector\InflectorFactory;
use Doctrine\Inflector\Rules\Pattern;
use Doctrine\Inflector\Rules\Patterns;
use Doctrine\Inflector\Rules\Ruleset;
use Doctrine\Inflector\Rules\Substitution;
use Doctrine\Inflector\Rules\Substitutions;
use Doctrine\Inflector\Rules\Transformation;
use Doctrine\Inflector\Rules\Transformations;
use Doctrine\Inflector\Rules\Word;

$inflector = InflectorFactory::create()
    ->withSingularRules(
        new Ruleset(
            new Transformations(
                new Transformation(new Pattern('/^(bil)er$/i'), '\1'),
                new Transformation(new Pattern('/^(inflec|contribu)tors$/i'), '\1ta')
            ),
            new Patterns(new Pattern('singulars')),
            new Substitutions(new Substitution(new Word('spins'), new Word('spinor')))
        )
    )
    ->withPluralRules(
        new Ruleset(
            new Transformations(
                new Transformation(new Pattern('^(bil)er$'), '\1'),
                new Transformation(new Pattern('^(inflec|contribu)tors$'), '\1ta')
            ),
            new Patterns(new Pattern('noflect'), new Pattern('abtuse')),
            new Substitutions(
                new Substitution(new Word('amaze'), new Word('amazable')),
                new Substitution(new Word('phone'), new Word('phonezes'))
            )
        )
    )
    ->build();
```

--------------------------------

### urlize method example

Source: https://github.com/doctrine/inflector/blob/2.1.x/docs/en/index.rst

Generates a URL-friendly string from a string of text. The example converts 'My first blog post' to 'my-first-blog-post'.

```php
echo $inflector->urlize('My first blog post'); // my-first-blog-post
```

--------------------------------

### Full assembly example

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/English.md

Manual wiring of the inflector using CachedWordInflector and RulesetInflector with English rules. Outputs pluralized and singularized examples.

```php
use Doctrine\Inflector\CachedWordInflector;
use Doctrine\Inflector\Inflector;
use Doctrine\Inflector\RulesetInflector;
use Doctrine\Inflector\Rules\English;

$inflector = new Inflector(
    new CachedWordInflector(new RulesetInflector(English\Rules::getSingularRuleset())),
    new CachedWordInflector(new RulesetInflector(English\Rules::getPluralRuleset()))
);

echo $inflector->pluralize('browser');  // browsers
echo $inflector->singularize('people'); // person
```

--------------------------------

### urlize usage examples

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Inflector.md

Examples of using urlize to generate slugs from various strings. The output is shown in comments.

```php
echo $inflector->urlize('My first blog post'); // my-first-blog-post
echo $inflector->urlize('Héllo Wörld!');       // hello-world
echo $inflector->urlize("What's up?");         // what-s-up
```

--------------------------------

### Substitution usage example

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Substitution.md

Creates a Substitution pair and demonstrates getFrom/getTo accessors.

```php
use Doctrine\Inflector\Rules\Substitution;
use Doctrine\Inflector\Rules\Word;

$pair = new Substitution(new Word('child'), new Word('children'));
echo $pair->getFrom()->getWord(); // child
echo $pair->getTo()->getWord();   // children
```

--------------------------------

### Patterns usage example

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Pattern.md

Example usage of Patterns with three Pattern objects. Demonstrates that matches returns true for 'data' and 'SHEEP' (case-insensitive) and false for 'media' because the pattern '\w+media' requires a prefix.

```php
use Doctrine\Inflector\Rules\Pattern;
use Doctrine\Inflector\Rules\Patterns;

$uninflected = new Patterns(
    new Pattern('data'),
    new Pattern('sheep'),
    new Pattern('\\w+media')   // note: as written in source, '\w+media'
);

$uninflected->matches('data');  // true
$uninflected->matches('SHEEP'); // true (case-insensitive)
$uninflected->matches('media'); // false ('media' needs a prefix per '\w+media')
```

--------------------------------

### seemsUtf8 usage examples

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Inflector.md

Shows how to call seemsUtf8 with ASCII, valid UTF-8, and invalid UTF-8 strings. The third example returns false because the byte sequence is invalid.

```php
$inflector->seemsUtf8('hello');     // true  (ASCII)
$inflector->seemsUtf8('año');       // true  (valid UTF-8)
$inflector->seemsUtf8("\xE9t\xE9"); // false (invalid/trailing lead byte)
```

--------------------------------

### singularize method example

Source: https://github.com/doctrine/inflector/blob/2.1.x/docs/en/index.rst

Returns the singular form of a given word. The example shows 'browsers' becoming 'browser'.

```php
echo $inflector->singularize('browsers'); // browser
```

--------------------------------

### tableize usage examples

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Inflector.md

Builds an Inflector via InflectorFactory and demonstrates tableize output for 'ModelName' and 'primaryKey'.

```php
$inflector = InflectorFactory::create()->build();

echo $inflector->tableize('ModelName'); // model_name
echo $inflector->tableize('primaryKey'); // primary_key
```

--------------------------------

### Multiple rulesets example

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/RulesetInflector.md

Shows using InflectorFactory with a custom ruleset and the equivalent manual wiring with RulesetInflector.

```php
// Multiple rulesets: a custom ruleset is evaluated before the default one.
// Because with*Rules() prepends, this mirrors what the factory does internally.
$inflector = InflectorFactory::create()
    ->withPluralRules($myRuleset)   // evaluated first
    ->build();

// Equivalent manual wiring:
$rulesetInflector = new RulesetInflector($myRuleset, English\Rules::getPluralRuleset());
echo $rulesetInflector->inflect('widget'); // widgets
```

--------------------------------

### pluralize method example

Source: https://github.com/doctrine/inflector/blob/2.1.x/docs/en/index.rst

Returns the plural form of a given word. The example shows 'browser' becoming 'browsers'.

```php
echo $inflector->pluralize('browser'); // browsers
```

--------------------------------

### Substitutions usage example

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Substitution.md

Demonstrates plural and singular inflection with irregular substitutions.

```php
use Doctrine\Inflector\Rules\Substitution;
use Doctrine\Inflector\Rules\Substitutions;
use Doctrine\Inflector\Rules\Word;

$irregulars = new Substitutions(
    new Substitution(new Word('child'), new Word('children')),
    new Substitution(new Word('person'), new Word('people'))
);

echo $irregulars->inflect('child');   // children
echo $irregulars->inflect('Child');   // Children  (first letter case preserved)
echo $irregulars->inflect('person');  // people
echo $irregulars->inflect('browser'); // browser  (not irregular — unchanged)
```

```php
// Singular direction is the flipped map:
$singularIrregulars = $irregulars->getFlippedSubstitutions();
echo $singularIrregulars->inflect('children'); // child
echo $singularIrregulars->inflect('People');   // Person
```

--------------------------------

### Install Doctrine Inflector with Composer

Source: https://github.com/doctrine/inflector/blob/2.1.x/docs/en/index.rst

Use this command to install the Doctrine Inflector package via Composer. Run it in your terminal.

```console
$ composer require doctrine/inflector
```

--------------------------------

### singularize usage examples

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Inflector.md

Examples of using singularize to convert plural words to singular, including an irregular rule.

```php
echo $inflector->singularize('browsers'); // browser
echo $inflector->singularize('children'); // child (irregular rule)
```

--------------------------------

### Transformation usage example

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Transformation.md

Shows how to create a Transformation and use inflect() to pluralize words, with a catch-all pattern.

```php
use Doctrine\Inflector\Rules\Pattern;
use Doctrine\Inflector\Rules\Transformation;

$toPlural = new Transformation(new Pattern('(x|ch|ss|sh)$'), '\1es');
echo $toPlural->inflect('box');    // boxes
echo $toPlural->inflect('church'); // churches
echo $toPlural->inflect('dog');    // dog (no match)
```

--------------------------------

### urlize with exception handling

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Inflector.md

Example of catching RuntimeException when urlize fails, falling back to a default slug.

```php
try {
    $slug = $inflector->urlize($content);
} catch (RuntimeException $e) {
    $slug = 'untitled';
}
```

--------------------------------

### Transformations usage example

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Transformation.md

Demonstrates creating a Transformations chain with multiple Transformation rules and inflecting words.

```php
use Doctrine\Inflector\Rules\Pattern;
use Doctrine\Inflector\Rules\Transformation;
use Doctrine\Inflector\Rules\Transformations;

$regularPlural = new Transformations(
    new Transformation(new Pattern('(quiz)$'), '\1zes'),
    new Transformation(new Pattern('([m|l])ouse$'), '\1ice'),
    new Transformation(new Pattern('(x|ch|ss|sh)$'), '\1es'),
    new Transformation(new Pattern('([^aeiouy]|qu)y$'), '\1ies'),
    new Transformation(new Pattern('$'), 's')   // generic catch-all
);

echo $regularPlural->inflect('quiz');    // quizzes
echo $regularPlural->inflect('mouse');   // mice
echo $regularPlural->inflect('box');     // boxes
echo $regularPlural->inflect('party');   // parties
echo $regularPlural->inflect('dog');     // dogs (catch-all)
```

--------------------------------

### capitalize method example

Source: https://github.com/doctrine/inflector/blob/2.1.x/docs/en/index.rst

Capitalizes all words in a string, similar to PHP's ucwords but with configurable delimiters. The first example uses default whitespace delimiters, while the second passes '-_ ' to treat those as word separators.

```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!
```

--------------------------------

### Create an English inflector with InflectorFactory

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/index.md

Conventional starting point for consumers: creates and builds an English inflector instance using InflectorFactory.

```php
use Doctrine\Inflector\InflectorFactory;

$inflector = InflectorFactory::create()->build(); // English
```

--------------------------------

### Using create() to pluralize

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/InflectorFactory.md

Example of using create() to build an inflector and pluralize a word. Outputs 'browsers'.

```php
use Doctrine\Inflector\InflectorFactory;

$inflector = InflectorFactory::create()->build();

echo $inflector->pluralize('browser'); // browsers
```

--------------------------------

### Single ruleset example

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/RulesetInflector.md

Creates a RulesetInflector with the English plural ruleset and demonstrates inflecting 'browser', 'child', and 'sheep'.

```php
use Doctrine\Inflector\RulesetInflector;
use Doctrine\Inflector\Rules\English;

// Single ruleset: default English pluralization rules
$pluralizer = new RulesetInflector(English\Rules::getPluralRuleset());

echo $pluralizer->inflect('browser'); // browsers  (regular transformation)
echo $pluralizer->inflect('child');   // children  (irregular substitution)
echo $pluralizer->inflect('sheep');   // sheep     (uninflected pattern)
```

--------------------------------

### unaccent method example

Source: https://github.com/doctrine/inflector/blob/2.1.x/docs/en/index.rst

Removes accents from a string using the unaccent() method. The example converts 'año' to 'ano'.

```php
echo $inflector->unaccent('año'); // ano
```

--------------------------------

### pluralize usage examples

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Inflector.md

Shows how to call pluralize on an Inflector instance. The first example returns 'browsers' for 'browser', and the second returns 'people' for 'person' using an irregular rule.

```php
echo $inflector->pluralize('browser');  // browsers
echo $inflector->pluralize('person');   // people (irregular rule)
```

--------------------------------

### Example: using English\Rules::getPluralRuleset()

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/English.md

Shows how to create a pluralizer using the English plural ruleset and inflect the word 'analysis' to 'analyses'.

```php
use Doctrine\Inflector\Rules\English;
use Doctrine\Inflector\RulesetInflector;

$pluralizer = new RulesetInflector(English\Rules::getPluralRuleset());
echo $pluralizer->inflect('analysis'); // analyses
```

--------------------------------

### unaccent usage examples

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Inflector.md

Shows how to call unaccent on strings with accented characters, producing ASCII equivalents.

```php
echo $inflector->unaccent('año');      // ano
echo $inflector->unaccent('cœur');     // coeur
echo $inflector->unaccent('straße');   // strasse
```

--------------------------------

### Reading the word value back

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Word.md

Shows how to read the stored word using getWord. The example prints 'person'.

```php
// Reading the value back
use Doctrine\Inflector\Rules\Word;

$word = new Word('person');
echo $word->getWord(); // person
```

--------------------------------

### Using createForLanguage() with Spanish and French

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/InflectorFactory.md

Examples of using createForLanguage() with a Language constant and a string literal, then building and using the inflector. Outputs 'casas' and 'cheval'.

```php
use Doctrine\Inflector\InflectorFactory;
use Doctrine\Inflector\Language;

$spanish = InflectorFactory::createForLanguage(Language::SPANISH)->build();
echo $spanish->pluralize('casa'); // casas

$french = InflectorFactory::createForLanguage('french')->build();
echo $french->singularize('chevaux'); // cheval
```

--------------------------------

### camelize usage examples

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Inflector.md

Shows two calls to camelize converting 'model_name' to 'modelName' and 'order_line_item' to 'orderLineItem'.

```php
echo $inflector->camelize('model_name'); // modelName
echo $inflector->camelize('order_line_item'); // orderLineItem
```

--------------------------------

### Tableize Method Example

Source: https://github.com/doctrine/inflector/blob/2.1.x/docs/en/index.rst

Converts a CamelCase string to snake_case. The output is shown in the comment.

```php
echo $inflector->tableize('ModelName'); // model_name
```

--------------------------------

### Constructing irregular substitutions with Word

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Word.md

Shows how to create a Substitutions collection with two irregular pairs using Word. The example prints 'geese' when inflecting 'goose'.

```php
use Doctrine\Inflector\Rules\Substitution;
use Doctrine\Inflector\Rules\Substitutions;
use Doctrine\Inflector\Rules\Word;

$irregulars = new Substitutions(
    new Substitution(new Word('goose'), new Word('geese')),
    new Substitution(new Word('tooth'), new Word('teeth'))
);

echo $irregulars->inflect('goose'); // geese
```

--------------------------------

### classify usage examples

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Inflector.md

Shows two calls to classify converting 'model_name' to 'ModelName' and 'my-blog post' to 'MyBlogPost'.

```php
echo $inflector->classify('model_name');  // ModelName
echo $inflector->classify('my-blog post'); // MyBlogPost
```

--------------------------------

### NoopWordInflector usage example

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/WordInflector.md

Example usage of NoopWordInflector to disable singularization while using real pluralization, and to create a fully no-op inflector using the Null Object pattern.

```php
use Doctrine\Inflector\Inflector;
use Doctrine\Inflector\NoopWordInflector;
use Doctrine\Inflector\RulesetInflector;
use Doctrine\Inflector\Rules\English;

// Singularization is a no-op while pluralization uses the real English rules:
$inflector = new Inflector(
    new NoopWordInflector(),
    new RulesetInflector(English\Rules::getPluralRuleset())
);

echo $inflector->singularize('browsers'); // browsers (unchanged)
echo $inflector->pluralize('browser');    // browsers

// Both directions as no-ops (Null Object pattern):
$noop = new Inflector(new NoopWordInflector(), new NoopWordInflector());
echo $noop->pluralize('browsers'); // browsers (unchanged)
```

--------------------------------

### Classify Method Example

Source: https://github.com/doctrine/inflector/blob/2.1.x/docs/en/index.rst

Converts a snake_case string to CamelCase. The output is shown in the comment.

```php
echo $inflector->classify('model_name'); // ModelName
```

--------------------------------

### getRegex method

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Pattern.md

Returns the compiled PCRE string: '/' . pattern . '/i', or the verbatim argument when it already starts with '/'.

```php
public function getRegex(): string
```

--------------------------------

### Pattern constructor

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Pattern.md

Constructor signature for Pattern. If the pattern starts with '/', it is used verbatim as a PCRE pattern; otherwise it is wrapped as '/' . $pattern . '/i' (case-insensitive, no anchoring).

```php
public function __construct(string $pattern)
```

--------------------------------

### Doctrine\Inflector\Rules\Pattern

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Pattern.md

Documentation for the Doctrine Inflector Pattern class, including constructor, methods, and examples.

```APIDOC
## Class `Doctrine\Inflector\Rules\Pattern`

### Constructor

```php
public function __construct(string $pattern)
```

**Parameters:**
- `$pattern` (string) - Required - Word pattern. If the first character is `/`, the string is used verbatim as the PCRE pattern; otherwise it is wrapped as `'/' . $pattern . '/i'` (case-insensitive, no anchoring).

### Methods

#### `getPattern`

```php
public function getPattern(): string
```

Returns the original constructor argument verbatim.

#### `getRegex`

```php
public function getRegex(): string
```

Returns the compiled PCRE string (`'/' . pattern . '/i'` or the verbatim argument if it starts with `/`).

#### `matches`

```php
public function matches(string $word): bool
```

**Parameters:**
- `$word` (string) - Required - Word to test.

**Returns:** `bool` - `true` if `preg_match($this->getRegex(), $word) === 1`; otherwise `false`.

**Throws:** None declared; a malformed regex surfaces from `preg_match` at this call site.

### Examples

```php
use Doctrine\Inflector\Rules\Pattern;

$pattern = new Pattern('^ox$');        // compiled as '/^ox$/i'
$pattern->matches('OX');               // true (case-insensitive)
$pattern->matches('oxen');             // false

$explicit = new Pattern('/^(bil)er$/i'); // already a full regex — used verbatim
echo $explicit->getRegex();              // /^(bil)er$/i
```

```php
// Error handling is not intercepted by Pattern itself; a broken regex
// fails inside preg_match() at matches() time rather than at construction.
$broken = new Pattern('[unclosed');
try {
    $broken->matches('anything');
} catch (/* engine-level regex error */) {
    // depends on the PHP runtime's handling of invalid PCRE
}
```
```

--------------------------------

### Camelize Method Example

Source: https://github.com/doctrine/inflector/blob/2.1.x/docs/en/index.rst

Converts a snake_case string to camelCase by first classifying and then lowercasing the first character. The output is shown in the comment.

```php
echo $inflector->camelize('model_name'); // modelName
```

--------------------------------

### Creating a Ruleset instance

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Ruleset.md

Constructs a Ruleset with one regular transformation, one uninflected pattern, and one irregular substitution. Demonstrates the required parameter types.

```php
use Doctrine\Inflector\Rules\Pattern;
use Doctrine\Inflector\Rules\Patterns;
use Doctrine\Inflector\Rules\Ruleset;
use Doctrine\Inflector\Rules\Substitution;
use Doctrine\Inflector\Rules\Substitutions;
use Doctrine\Inflector\Rules\Transformation;
use Doctrine\Inflector\Rules\Transformations;
use Doctrine\Inflector\Rules\Word;

$ruleset = new Ruleset(
    new Transformations(
        new Transformation(new Pattern('^(bil)er$'), '\1')          // regular
    ),
    new Patterns(new Pattern('singulars')),                          // uninflected
    new Substitutions(new Substitution(new Word('spins'), new Word('spinor'))) // irregular
);
```

--------------------------------

### create() method signature

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/InflectorFactory.md

Method signature for create(), which takes no parameters and returns a LanguageInflectorFactory equivalent to createForLanguage(Language::ENGLISH).

```php
public static function create(): LanguageInflectorFactory
```

--------------------------------

### CachedWordInflector usage example

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/WordInflector.md

Example usage of CachedWordInflector wrapping a RulesetInflector with English plural rules. The first call computes and caches the result, the second serves from cache.

```php
use Doctrine\Inflector\CachedWordInflector;
use Doctrine\Inflector\RulesetInflector;
use Doctrine\Inflector\Rules\English;

$cached = new CachedWordInflector(new RulesetInflector(English\Rules::getPluralRuleset()));

echo $cached->inflect('browser'); // browsers   (computed, cached)
echo $cached->inflect('browser'); // browsers   (served from cache)
```

--------------------------------

### getPattern method

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Pattern.md

Returns the original constructor argument verbatim.

```php
public function getPattern(): string
```

--------------------------------

### create

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/InflectorFactory.md

Creates a LanguageInflectorFactory for the default English language.

```APIDOC
## create

### Description
Creates a LanguageInflectorFactory for the default English language.

### Method
create

### Endpoint
InflectorFactory::create()

### Parameters
None

### Return Value
- **LanguageInflectorFactory** - A factory for building English inflectors.

### Example
```php
use Doctrine\Inflector\InflectorFactory;

$inflector = InflectorFactory::create()->build();
echo $inflector->pluralize('browser'); // browsers
```
```

--------------------------------

### Inflector wiring in build()

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/LanguageInflectorFactory.md

Shows how the Inflector is constructed with cached ruleset inflectors for singular and plural rules.

```php
new Inflector(
    new CachedWordInflector(new RulesetInflector(...$this->singularRulesets)),
    new CachedWordInflector(new RulesetInflector(...$this->pluralRulesets))
)
```

--------------------------------

### getTo method

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Substitution.md

Returns the target Word object.

```php
public function getTo(): Word
```

--------------------------------

### getFrom method

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Substitution.md

Returns the source Word object.

```php
public function getFrom(): Word
```

--------------------------------

### Constructor signature

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/RulesetInflector.md

The constructor accepts a first Ruleset and variadic additional rulesets. All are merged into a single array.

```php
public function __construct(Ruleset $ruleset, Ruleset ...$rulesets)
```

--------------------------------

### Rules\Substitutions::__construct

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/configuration.md

Creates a Substitutions collection that stores multiple Substitution objects keyed by the source word.

```APIDOC
## [CONSTRUCTOR] Rules\Substitutions::__construct

### Description
Creates a Substitutions collection that stores multiple Substitution objects keyed by the source word.

### Method
CONSTRUCTOR

### Endpoint
Rules\Substitutions::__construct

### Parameters
#### Constructor Parameters
- **...$substitutions** (Substitution) - Required - Substitutions stored in a map keyed by `getFrom()->getWord()` (lowercased at lookup time in `inflect()`).

### Request Example
```php
public function __construct(Substitution ...$substitutions)
```

### Response
#### Success Response (200)
- No return value (constructor).
```

--------------------------------

### Rules\Substitution::__construct

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/configuration.md

Creates a Substitution object that maps a source word to a replacement word.

```APIDOC
## [CONSTRUCTOR] Rules\Substitution::__construct

### Description
Creates a Substitution object that maps a source word to a replacement word.

### Method
CONSTRUCTOR

### Endpoint
Rules\Substitution::__construct

### Parameters
#### Constructor Parameters
- **$from** (Word) - Required - Source word (lookup key).
- **$to** (Word) - Required - Replacement word.

### Request Example
```php
public function __construct(Word $from, Word $to)
```

### Response
#### Success Response (200)
- No return value (constructor).
```

--------------------------------

### getFlippedSubstitutions method

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Substitution.md

Returns a new Substitutions instance with from/to swapped for each substitution.

```php
public function getFlippedSubstitutions(): Substitutions
```

--------------------------------

### createForLanguage

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/InflectorFactory.md

Creates a LanguageInflectorFactory for a specified language, throwing an exception for unsupported languages.

```APIDOC
## createForLanguage

### Description
Creates a LanguageInflectorFactory for the specified language, dispatching to the appropriate language-specific factory.

### Method
createForLanguage

### Endpoint
InflectorFactory::createForLanguage(string $language)

### Parameters
#### Path Parameters
- **$language** (string) - Required - One of the Language::* constants: 'english', 'esperanto', 'french', 'italian', 'norwegian-bokmal', 'portuguese', 'spanish', 'turkish'.

### Return Value
- **LanguageInflectorFactory** - A factory for the specified language.

### Throws
- **InvalidArgumentException** - If the language is not supported.

### Examples
```php
use Doctrine\Inflector\InflectorFactory;
use Doctrine\Inflector\Language;

$spanish = InflectorFactory::createForLanguage(Language::SPANISH)->build();
echo $spanish->pluralize('casa'); // casas

$french = InflectorFactory::createForLanguage('french')->build();
echo $french->singularize('chevaux'); // cheval
```

### Error Handling
```php
try {
    $factory = InflectorFactory::createForLanguage('latin');
} catch (InvalidArgumentException $e) {
    $factory = InflectorFactory::create();
}
$inflector = $factory->build();
```

### Language Dispatch Table
| Language::* constant | Value | Returned factory class |
|----------------------|-------|------------------------|
| Language::ENGLISH | 'english' | Rules\English\InflectorFactory |
| Language::ESPERANTO | 'esperanto' | Rules\Esperanto\InflectorFactory |
| Language::FRENCH | 'french' | Rules\French\InflectorFactory |
| Language::ITALIAN | 'italian' | Rules\Italian\InflectorFactory |
| Language::NORWEGIAN_BOKMAL | 'norwegian-bokmal' | Rules\NorwegianBokmal\InflectorFactory |
| Language::PORTUGUESE | 'portuguese' | Rules\Portuguese\InflectorFactory |
| Language::SPANISH | 'spanish' | Rules\Spanish\InflectorFactory |
| Language::TURKISH | 'turkish' | Rules\Turkish\InflectorFactory |
```

--------------------------------

### Substitution::__construct

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Substitution.md

Creates a new Substitution instance pairing a source word with a target word.

```APIDOC
## Substitution::__construct

### Description
Creates a new Substitution instance that pairs a source word (the form to replace) with a target word (the replacement form).

### Method
Constructor

### Signature
```php
public function __construct(Word $from, Word $to)
```

### Parameters
- **$from** (Word) - Required - Source word (the form to replace).
- **$to** (Word) - Required - Target word (the replacement form).

### Request Example
```php
$pair = new Substitution(new Word('child'), new Word('children'));
```

### Response
#### Success Response
No return value.

#### Response Example
No response body.
```

--------------------------------

### Rules\Transformations::__construct

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/configuration.md

Creates a Transformations collection that applies the first matching transformation in order.

```APIDOC
## [CONSTRUCTOR] Rules\Transformations::__construct

### Description
Creates a Transformations collection that applies the first matching transformation in order.

### Method
CONSTRUCTOR

### Endpoint
Rules\Transformations::__construct

### Parameters
#### Constructor Parameters
- **...$transformations** (Transformation) - Required - Ordered chain; `inflect()` applies the **first** transformation whose pattern matches.

### Request Example
```php
public function __construct(Transformation ...$transformations)
```

### Response
#### Success Response (200)
- No return value (constructor).
```

--------------------------------

### Substitution constructor

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Substitution.md

Constructor signature for Substitution accepting a source Word and a target Word.

```php
public function __construct(Word $from, Word $to)
```

--------------------------------

### Substitutions::__construct

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Substitution.md

Creates a new Substitutions instance with a variadic list of Substitution objects.

```APIDOC
## Substitutions::__construct

### Description
Creates a new Substitutions instance that stores a map of irregular substitutions keyed by the exact 'from' word.

### Method
Constructor

### Signature
```php
public function __construct(Substitution ...$substitutions)
```

### Parameters
- **...$substitutions** (Substitution, variadic) - Required - Substitutions to store in the map.

### Request Example
```php
$irregulars = new Substitutions(
    new Substitution(new Word('child'), new Word('children')),
    new Substitution(new Word('person'), new Word('people'))
);
```

### Response
#### Success Response
No return value.

#### Response Example
No response body.
```

--------------------------------

### Rules\Transformation::__construct

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/configuration.md

Creates a Transformation object that defines a pattern and replacement for inflecting words.

```APIDOC
## [CONSTRUCTOR] Rules\Transformation::__construct

### Description
Creates a Transformation object that defines a pattern and replacement for inflecting words.

### Method
CONSTRUCTOR

### Endpoint
Rules\Transformation::__construct

### Parameters
#### Constructor Parameters
- **$pattern** (Pattern) - Required - Match pattern (used by `getPattern()->matches()` and `preg_replace`).
- **$replacement** (string) - Required - PCRE replacement string (`$1`/`\1` backreferences supported).

### Request Example
```php
public function __construct(Pattern $pattern, string $replacement)
```

### Response
#### Success Response (200)
- No return value (constructor).
```

--------------------------------

### build() method signature

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/LanguageInflectorFactory.md

Final build method that returns a new Inflector instance.

```php
final public function build(): Inflector
```

--------------------------------

### Transformation constructor

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Transformation.md

Constructor for Transformation, accepting a Pattern and replacement string.

```php
public function __construct(Pattern $pattern, string $replacement)
```

--------------------------------

### Substitutions constructor

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Substitution.md

Constructor accepting variadic Substitution objects.

```php
public function __construct(Substitution ...$substitutions)
```

--------------------------------

### Rules\Ruleset::__construct

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/configuration.md

Creates a Ruleset that groups regular, uninflected, and irregular rules.

```APIDOC
## [CONSTRUCTOR] Rules\Ruleset::__construct

### Description
Creates a Ruleset that groups regular, uninflected, and irregular rules.

### Method
CONSTRUCTOR

### Endpoint
Rules\Ruleset::__construct

### Parameters
#### Constructor Parameters
- **$regular** (Transformations) - Required - Regular (transformation) rules.
- **$uninflected** (Patterns) - Required - Patterns whose matches are never inflected.
- **$irregular** (Substitutions) - Required - Irregular word substitutions.

### Request Example
```php
public function __construct(Transformations $regular, Patterns $uninflected, Substitutions $irregular)
```

### Response
#### Success Response (200)
- No return value (constructor).
```

--------------------------------

### Rules\Pattern::__construct

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/configuration.md

Creates a new Pattern object that holds a word pattern used for matching.

```APIDOC
## [CONSTRUCTOR] Rules\Pattern::__construct

### Description
Creates a new Pattern object that holds a word pattern used for matching.

### Method
CONSTRUCTOR

### Endpoint
Rules\Pattern::__construct

### Parameters
#### Constructor Parameters
- **$pattern** (string) - Required - Word pattern. If the first character is `/`, the string is used verbatim as a PCRE pattern. Otherwise it is wrapped as `'/' . $pattern . '/i'` (case-insensitive).

### Request Example
```php
public function __construct(string $pattern)
```

### Response
#### Success Response (200)
- No return value (constructor).
```

--------------------------------

### Transformation getReplacement method

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Transformation.md

Returns the configured replacement template string.

```php
public function getReplacement(): string
```

--------------------------------

### Transformation getPattern method

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Transformation.md

Returns the configured Pattern object.

```php
public function getPattern(): Pattern
```

--------------------------------

### Substitution::getTo

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Substitution.md

Returns the target word object of the substitution.

```APIDOC
## Substitution::getTo

### Description
Returns the target word object (the replacement form) of the substitution.

### Method
Getter

### Signature
```php
public function getTo(): Word
```

### Parameters
None.

### Request Example
```php
$to = $pair->getTo();
```

### Response
#### Success Response
- **Word** - The target word object.

#### Response Example
```php
Word('children')
```
```

--------------------------------

### Create Inflector with NoopWordInflector

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Inflector.md

Creates an Inflector instance using NoopWordInflector for both strategies, resulting in identity singularization and pluralization.

```php
use Doctrine\Inflector\Inflector;
use Doctrine\Inflector\NoopWordInflector;

// Inflector that singularizes and pluralizes as identity
$inflector = new Inflector(new NoopWordInflector(), new NoopWordInflector());
```

--------------------------------

### Inflector class declaration and constructor

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Inflector.md

Shows the class declaration and constructor signature of the Inflector facade. The constructor accepts two WordInflector strategies, one for singularization and one for pluralization.

```php
class Inflector
{
    private const ACCENTED_CHARACTERS = [ ... ]; // 193 accent → ASCII mappings, see below
    // ...
    public function __construct(WordInflector $singularizer, WordInflector $pluralizer)
}
```

--------------------------------

### Multiple rulesets and precedence

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/LanguageInflectorFactory.md

Demonstrates how multiple rulesets are evaluated. Because each `with*Rules()` call unshifts onto the front, later-registered rulesets win over earlier ones and over the language defaults. The `RulesetInflector` evaluates rulesets in order and stops at the first that changes the word.

```php
use Doctrine\Inflector\InflectorFactory;

$inflector = InflectorFactory::create()
    ->withPluralRules($customRulesetA)      // evaluated second
    ->withPluralRules($customRulesetB)      // evaluated first
    ->build();
```

--------------------------------

### Ruleset constructor

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Ruleset.md

Constructor signature requiring all three rule categories. No defaults or nullability are allowed.

```php
public function __construct(Transformations $regular, Patterns $uninflected, Substitutions $irregular)
```

--------------------------------

### Constructor signature

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/LanguageInflectorFactory.md

Final constructor that seeds the rule arrays with language defaults. Subclasses only implement the abstract getters.

```php
final public function __construct()
```

--------------------------------

### capitalize(string $string, string $delimiters = " \n\t\r\0\x0B-"): string

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Inflector.md

Uppercases the first letter of each word, using configurable delimiters.

```APIDOC
## `capitalize`

### Description
Uppercases the first letter of each word, using configurable delimiters.

### Method
`public function capitalize(string $string, string $delimiters = " \n\t\r\0\x0B-"): string`

### Parameters
- **$string** (string) - Required - The string to operate on.
- **$delimiters** (string) - Optional - Default: `" \n\t\r\0\x0B-"` - List of characters treated as word separators.

### Return
- **string** - `ucwords($string, $delimiters)`, the input with each delimiter-separated word capitalized.

### Examples
```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!
```

```php
// Non-trivial delimiter set: treat '-' and '.' as word boundaries
echo $inflector->capitalize('one-two.three', '-.'); // One-Two.Three
```
```

--------------------------------

### camelize(string $word): string

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Inflector.md

CamelCase conversion; delegates to classify() then lowercases the first character.

```APIDOC
## `camelize`

### Description
CamelCase conversion; delegates to `classify()` then lowercases the first character.

### Method
`public function camelize(string $word): string`

### Parameters
- **$word** (string) - Required - Word to convert.

### Return
- **string** - `lcfirst($this->classify($word))`.

### Throws
- none (inherits none from `classify`, which has no guard).

### Examples
```php
echo $inflector->camelize('model_name'); // modelName
echo $inflector->camelize('order_line_item'); // orderLineItem
```
```

--------------------------------

### Define the WordInflector interface with the inflect method

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/types.md

Defines the interface, (interface method,

```PHP
interface WordInf
```

--------------------------------

### InflectorFactory class signature

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/InflectorFactory.md

Shows the class signature and the two static factory methods that return a LanguageInflectorFactory. The class is final and cannot be instantiated.

```php
final class InflectorFactory
{
    public static function create(): LanguageInflectorFactory
    public static function createForLanguage(string $language): LanguageInflectorFactory
}
```

--------------------------------

### Catch RuntimeException from tableize()

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/errors.md

Shows how to catch the RuntimeException from tableize() in consumer code. The catch block logs the exception message, useful when the input may contain invalid UTF-8.

```php
use Doctrine\Inflector\InflectorFactory;

$inflector = InflectorFactory::create()->build();

try {
    $name = $inflector->tableize($possiblyInvalidUtf8);
} catch (RuntimeException $e) {
    // e.g. invalid UTF-8 byte sequence in $possiblyInvalidUtf8
    error_log($e->getMessage());
}
```

--------------------------------

### urlize() replacement pipeline

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/errors.md

The four-step preg_replace pipeline inside Inflector::urlize(). Any step returning null triggers a RuntimeException; invalid UTF-8 is the most plausible cause since the patterns lack the u modifier.

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

--------------------------------

### Reset semantics

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/LanguageInflectorFactory.md

Shows how to discard all default English rules and register a single custom singular ruleset. The second argument `true` to `withSingularRules()` triggers the reset behavior.

```php
use Doctrine\Inflector\InflectorFactory;

// Discard all default English rules, then register one custom singular ruleset
$factory = InflectorFactory::create()->withSingularRules($onlyRuleset, true);
$inflector = $factory->build();
```

--------------------------------

### Substitution class definition

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Substitution.md

Shows the internal structure of the Substitution class with private $from and $to Word properties.

```php
final class Substitution
{
    /** @var Word */
    private $from;

    /** @var Word */
    private $to;
}
```

--------------------------------

### urlize method signature

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Inflector.md

Method signature for urlize, which generates a URL-friendly slug from arbitrary text. It returns a string and throws RuntimeException if any preg_replace step returns null.

```php
public function urlize(string $string): string
```

--------------------------------

### Create Inflector with Default English Language

Source: https://github.com/doctrine/inflector/blob/2.1.x/docs/en/index.rst

Creates an inflector instance using the default English language. Use this when you need standard English pluralization and singularization.

```php
use Doctrine\Inflector\InflectorFactory;

$inflector = InflectorFactory::create()->build();
```

--------------------------------

### urlize

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Inflector.md

Generates a URL-friendly slug from arbitrary text by applying a pipeline of transformations including unaccenting, lowercasing, and regex replacements.

```APIDOC
## `urlize`

### Description
Generates a URL-friendly slug from arbitrary text.

### Method
`public function urlize(string $string): string`

### Parameters
- **$string** (string) - Required - String to urlize.

### Return Value
- **string** - The urlized slug.

### Throws
- **RuntimeException** if any `preg_replace` step returns `null`.

### Examples
```php
echo $inflector->urlize('My first blog post'); // my-first-blog-post
echo $inflector->urlize('Héllo Wörld!');       // hello-world
echo $inflector->urlize("What's up?");         // what-s-up
```

```php
try {
    $slug = $inflector->urlize($content);
} catch (RuntimeException $e) {
    $slug = 'untitled';
}
```
```

--------------------------------

### Word constructor signature

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Word.md

Declares the public constructor that accepts a single string $word. No validation, trimming, or normalization is performed; an empty string is legal.

```php
public function __construct(string $word)
```

--------------------------------

### Word::__construct

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/Word.md

Creates a new Word instance with the given string value. No validation or normalization is performed.

```APIDOC
## Word::__construct

### Description
Creates a new Word instance with the given string value. No validation, trimming, or normalization is performed; an empty string is legal.

### Method
Constructor

### Parameters
- **$word** (string) - Required - The word value to store.

### Return
- No return value (void).

### Example
```php
$word = new Word('goose');
```
```

--------------------------------

### Rules::getSingularRuleset() and getPluralRuleset()

Source: https://github.com/doctrine/inflector/blob/2.1.x/_autodocs/api-reference/Rules/OtherLanguages.md

Assembles the singular and plural rulesets for a non-English language package. The singular ruleset flips irregular substitutions, while the plural ruleset uses them directly. Both methods are overridden in each language's InflectorFactory.

```php
public static function getSingularRuleset(): Ruleset
{
    return new Ruleset(
        new Transformations(...Inflectible::getSingular()),
        new Patterns(...Uninflected::getSingular()),
        (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
    );
}

public static function getPluralRuleset(): Ruleset
{
    return new Ruleset(
        new Transformations(...Inflectible::getPlural()),
        new Patterns(...Uninflected::getPlural()),
        new Substitutions(...Inflectible::getIrregular())
    );
}
```
Tokens:
Raw