Alice

https://github.com/nelmio/alice
Admin
Alice is an expressive fixtures generator that uses FakerPHP/Faker to create a ton of fake data for...
Tokens:132,798
Snippets:778
Trust Score:6.9
License:MIT
Update:1 week ago
Show doc for...
Tokens:
Raw
### PHP fixture example

Source: https://github.com/nelmio/alice/blob/main/doc/getting-started.md

Defines the same fixtures as the YAML example but in PHP array format, using class constants and faker functions.

```php
<?php
// Example of PHP file

return [
    \Nelmio\Entity\User::class => [
        'user{1..10}' => [
            'username' => '<username()>',
            'fullname' => '<firstName()> <lastName()>',
            'birthDate' => '<date_create()>',
            'email' => '<email()>',
            'favoriteNumber' => '50%? <numberBetween(1, 200)>',
        ],
    ],
    \Nelmio\Entity\Group::class => [
        'group1' => [
            'name' => 'Admins',
            'owner' => '@user1',
            'members' => '<numberBetween(1, 10)>x @user*',
            'created' => '<dateTimeBetween("-200 days", "now")>',
            'updated' => '<dateTimeBetween($created, "now")>',
        ],
    ],
];
```

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

### Method arguments with parameters (PHP equivalent)

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

PHP array equivalent of the YAML example above, showing the same structure with parameters and argument references.

```php
[
    'parameters' => [
        'foo' => 'bar',
    ],
    Nelmio\Entity\Dummy::class => [
        'dummy{1..10}' => [
            '__calls' => [
                'setLocation' => [
                    'arg0' => '<{foo}>',
                    'arg1' => '$arg0',
                    500,
                    '$3',
                ],
            ],
        ],
    ],
],
```

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

### Install Nelmio Alice via Composer

Source: https://github.com/nelmio/alice/blob/main/README.md

Install the nelmio/alice package as a development dependency using Composer.

```bash
composer require --dev nelmio/alice
```

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

### YAML fixture example

Source: https://github.com/nelmio/alice/blob/main/doc/getting-started.md

Defines fixtures for User and Group entities in YAML format. Uses faker functions and references like '@user1' and '@user*'.

```yaml
# Example of YAML file

Nelmio\Entity\User:
    user{1..10}:
        username: '<username()>'
        fullname: '<firstName()> <lastName()>'
        birthDate: '<date_create()>'
        email: '<email()>'
        favoriteNumber: '50%? <numberBetween(1, 200)>'

Nelmio\Entity\Group:
    group1:
        name: Admins
        owner: '@user1'
        members: '<numberBetween(1, 10)>x @user*'
        created: '<dateTimeBetween("-200 days", "now")>'
        updated: '<dateTimeBetween($created, "now")>'
```

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

### YAML Fixture Declaration Example

Source: https://github.com/nelmio/alice/blob/main/README.md

Complete example of entity declarations in YAML format, defining users and groups with various properties and references.

```yaml
Nelmio\Entity\User:
    user{1..10}:
        username: '<username()>'
        fullname: '<firstName()> <lastName()>'
        birthDate: '<date_create()>'
        email: '<email()>'
        favoriteNumber: '50%? <numberBetween(1, 200)>'

Nelmio\Entity\Group:
    group1:
        name: Admins
        owner: '@user1'
        members: '<numberBetween(1, 10)>x @user*'
        created: '<dateTimeBetween("-200 days", "now")>'
        updated: '<dateTimeBetween($created, "now")>'
```

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

### Calling a method with array arguments

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Calls a method (e.g., setLocation) with an array of arguments using the __calls syntax.

```yaml
Nelmio\Entity\User:
    user1:
        username: '<username()>'
        __calls:
            - setLocation: [40.689269, -74.044737]
```

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

### Identity with variables and references

Source: https://github.com/nelmio/alice/blob/main/doc/advanced-guide.md

Shows the identity function with a single fixture. The output is identical to the previous example, but the source does not explain the discrepancy.

```yaml
# Example with variables and references
stdClass:
    dummy1:
        foo: '<($current)>'
```

```text
[
    'dummy1' => stdClass {
        +"foo": "1",
    },
    'dummy2' => stdClass {
        +"foo": "2",
    }
]
```

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

### Load data with parameters and objects

Source: https://github.com/nelmio/alice/blob/main/doc/getting-started.md

Passes parameters and objects to loadData() to inject values into fixtures.

```php
$loader = new Nelmio\Alice\Loader\NativeLoader();
$objectSet = $loader->loadData(
    [
        \Nelmio\Entity\Group::class => [
            'group1' => [
                'name' => '<{name}>',
                'owner' => '@user1',
            ],
        ],
    ],
    ['name' => 'Admins'],
    ['user1' => $user1]
);
```

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

### PHP fixture definition returning array

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Defines fixtures in PHP by returning an array where each key is the fully qualified class name and the value is a map of fixture names to property values. This example creates two User fixtures with static data.

```php
<?php

return [
    'Nelmio\Alice\support\models\User' => [
        'user1' => [
            'username' => 'bob',
            'fullname' => 'Bob',
        ],
        'user2' => [
            'username' => 'alice',
            'fullname' => 'Alice',
        ],
    ],
];

```

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

### JSON fixture definition

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Defines fixtures in a JSON file. The top-level key is the fully qualified class name, followed by a map of fixture names to property values. This example creates a single User fixture with a fullname property.

```json
{
    "Nelmio\\Alice\\support\\models\\User": {
        "user0": {
            "fullname": "John Doe"
        }
    }
}

```

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

### Custom Instantiator Decorator Example

Source: https://github.com/nelmio/alice/blob/main/doc/advanced-guide.md

Decorates the built-in instantiator to handle a specific fixture class. If the fixture class is 'App\Dummy', it creates a new Dummy instance and adds it to the fixture set; otherwise, it delegates to the decorated instantiator.

```php
<?php

namespace App;

use Nelmio\Alice\Definition\Object\SimpleObject;
use Nelmio\Alice\FixtureInterface;
use Nelmio\Alice\Generator\GenerationContext;
use Nelmio\Alice\Generator\InstantiatorInterface;
use Nelmio\Alice\Generator\ResolvedFixtureSet;

final class DummyInstantiator implements InstantiatorInterface
{
    private $instantiator;

    public function __construct(InstantiatorInterface $decoratedInstantiator)
    {
        $this->instantiator = $decoratedInstantiator;
    }

    /**
     * @inheritdoc
     */
    public function instantiate(
        FixtureInterface $fixture,
        ResolvedFixtureSet $fixtureSet,
        GenerationContext $context
    ): ResolvedFixtureSet
    {
        if ('App\Dummy' === $fixture->getClassName()) {
            $instance = new Dummy();

            $objects = $fixtureSet->getObjects()->with(
                new SimpleObject(
                    $fixture->getId(),
                    $instance
                )
            );

            return $fixtureSet->withObjects($objects);
        }

        return $this->instantiator->instantiate($fixture, $fixtureSet, $context);
    }
}
```

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

### Optional method call with percentage flag

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Makes a method call optional with a percentage flag. In this example, setLocation() has an 80% chance of being called.

```yaml
Nelmio\Entity\User:
    user1:
        username: '<username()>'
        __calls:
            - setLocation (80%?): [40.689269, -74.044737]
```

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

### Identity: '<(X)>' simple example

Source: https://github.com/nelmio/alice/blob/main/doc/advanced-guide.md

Uses the identity shortcut '<(strtolower("BAR"))>' to evaluate a PHP expression. The result is 'bar'.

```yaml
# Simple example
stdClass:
    dummy:
        foo: '<(strtolower("BAR"))>'
```

```text
[
    'dummy' => stdClass {
        +"foo": "bar",
    }
]
```

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

### Load dependent files successively

Source: https://github.com/nelmio/alice/blob/main/doc/getting-started.md

Loads users.yml then groups.yml, passing parameters and objects from the first load to the second to handle dependencies.

```php
$loader = new Nelmio\Alice\Loader\NativeLoader();

$objectSet = $loader->loadFile(__DIR__.'/users.yml');
$objectSet = $loader->loadFile(
    __DIR__.'/groups.yml',
    $objectSet->getParameters(),
    $objectSet->getObjects()
);
```

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

### Define constructor arguments with __construct

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Use this YAML fixture to pass arguments to a mandatory constructor. The value '<username()>' is a placeholder that Alice will replace with generated data.

```yaml
Nelmio\Entity\User:
    user1:
        __construct: ['<username()>']
```

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

### Unique flag on a property (username)

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Use the (unique) flag on a property to ensure each generated fixture has a unique value for that property. In this example, usernames for users user1 through user10 are guaranteed to be unique.

```yaml
Nelmio\Entity\User:
    user{1..10}:
        username (unique): '<username()>'

```

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

### Configure NelmioAliceBundle in config_dev.yml

Source: https://github.com/nelmio/alice/blob/main/doc/getting-started.md

YAML configuration for the NelmioAliceBundle, setting locale, seed, functions blacklist, loading limit, and max unique values retry. Place in app/config/config_dev.yml.

```yaml
# app/config/config_dev.yml

nelmio_alice:
    locale: 'en_US' # Default locale for the Faker Generator
    seed: 1 # Value used to make sure Faker generates data consistently across
            # runs, set to null to disable.
    functions_blacklist: # Some Faker formatter may have the same name as PHP
        - 'current'      # native functions. PHP functions have the priority,
                         # so if you want to use a Faker formatter instead,
                         # blacklist this function here
    loading_limit: 5 # Alice may do some recursion to resolve certain values.
                     # This parameter defines a limit which will stop the
                     # resolution once reached.
    max_unique_values_retry: 150 # Maximum number of time Alice can try to
                                   # generate a unique value before stopping and
                                   # failing.
```

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

### Define a fixture range with step argument user{1..10, 2}

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Generates five user fixtures with IDs user1, user3, user5, user7, and user9 by adding a step argument to the range. The step value controls the gap between generated IDs.

```yaml
Nelmio\Entity\User:
    user{1..10, 2}:
        username: bob
        fullname: Bob
        birthDate: 1980-10-10
        email: bob@example.org
        favoriteNumber: 42
```

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

### Method arguments with unique flags

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Specifies a flag on a specific argument, here (unique) ensures unique values for latitude and longitude.

```yaml
Nelmio\Entity\User:
    user{1..10}:
        username: '<username()>'
        __calls:
            - setLocation:
                0 (unique): '<latitude()>'
                1 (unique): '<longitude()>'
```

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

### Enable NelmioAliceBundle in AppKernel

Source: https://github.com/nelmio/alice/blob/main/doc/getting-started.md

Registers the NelmioAliceBundle in the Symfony application kernel for dev and test environments. Place this method in app/AppKernel.php.

```php
<?php
// app/AppKernel.php

public function registerBundles()
{
    //...
    if (in_array($this->getEnvironment(), ['dev', 'test'])) {
        //...
        $bundles[] = new Nelmio\Alice\Bridge\Symfony\NelmioAliceBundle();
    }

    return $bundles;
}
```

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

### Define a fixture range with user{1..10}

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Creates ten user fixtures with IDs user1 to user10, all with identical property values. Use a range in the fixture name to generate multiple copies of an object.

```yaml
Nelmio\Entity\User:
    user{1..10}:
        username: bob
        fullname: Bob
        birthDate: 1980-10-10
        email: bob@example.org
        favoriteNumber: 42
```

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

### Fixture reference with wildcard (@user_*)

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Defines a list of user fixtures and references them all in a UserDetail fixture using a wildcard reference. The <current()> function holds the value of the referenced fixture.

```yaml
Nelmio\Entity\User:
    user_{1..10}:
        username: '<name()>'

Nelmio\Entity\UserDetail:
    userdetail_{@user_*}:  # is going to generate `userdetail_user_1`, `userdetail_user_2`, ..., `userdetail_user_10`
        user: <current()>
        email: '<email()>'
```

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

### Instantiate without constructor using __construct: false

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Set __construct to false to create the object without calling its constructor. Useful when the constructor has side effects or is not needed.

```yaml
Nelmio\Entity\User:
    user1:
        __construct: false
```

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

### Fixture reference with full name (@user_bob)

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

References a single previously created fixture by its full name. The <current()> function holds the value of the referenced fixture.

```yaml
Nelmio\Entity\User:
    user_bob:
        username: 'bob'

Nelmio\Entity\UserDetail:
    userdetail_{@user_bob}:
        user: <current()>   # holds `@user_bob`
        email: 'bob@test.de'
```

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

### Method arguments with parameters (YAML)

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Uses parameters and argument references within a method call. Arguments can be used as parameters but only within the scope of that function. The numerical key is a random number because YAML cannot mix keys with array values.

```yaml
parameters:
    foo: bar

Nelmio\Entity\Dummy:
    dummy{1..10}:
        __calls:
            - setLocation:
                arg0: '<{foo}>'
                arg1: '$arg0' # will be resolved info 'bar'
                3: 500  # the numerical key here is just a random number as in YAML you cannot mix keys with array values
                4: '$3' # `3` here refers to the *third* argument, i.e. 500
```

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

### Define a fixture list with user_{alice, bob}

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Creates two user fixtures with IDs user_alice and user_bob. Uses the <current()> function to insert the current list value into fields, and escapes the @ in the email to prevent reference evaluation. <current()> only works in collection contexts; using it elsewhere throws an exception.

```yaml
Nelmio\Entity\User:
    user_{alice, bob}:
        username: '<current()>'
        fullname: '<current()>'
        birthDate: 1980-10-10
        email: '<current()>\@example.org'
        favoriteNumber: 42
```

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

### Equivalent PHP array for constructor usage

Source: https://github.com/nelmio/alice/blob/main/doc/fixtures-refactoring.md

PHP array equivalent of the YAML example above, showing the same structure.

```php
[
    'parameters' => [
        'foo' => 'bar',
    ],
    Nelmio\Entity\Dummy::class => [
        'dummy{1..10}' => [
            '__construct' => [
                'arg0' => '<{foo}>',
                'arg1' => '$arg0',
                500,
                '$3',
            ],
        ],
    ],
],
```

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

### Call static factory from another class with __factory

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Use __factory with a fully qualified class name and method to call a static factory that belongs to another class. The syntax is 'ClassName::method'.

```yaml
Nelmio\Entity\User:
    user1:
        __factory: { 'Nelmio\User\UserFactory::create': ['<username()>'] }
```

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

### Unique flag on a constructor argument

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Apply the (unique) flag to a constructor argument (here, argument 0) to ensure unique values are passed to the constructor for each generated fixture.

```yaml
Nelmio\Entity\User:
    user{1..10}:
        __construct:
            0 (unique): '<username()>'

```

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

### Call static factory method with __factory

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Use __factory to call a static factory method (named constructor) on the same class. Note: __construct for factories is deprecated as of 3.0.0 and will be removed in 4.0.0; use __factory instead.

```yaml
Nelmio\Entity\User:
    user1:
        __factory: { create: ['<username()>'] }
```

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

### Access property from another object with @self->property

Source: https://github.com/nelmio/alice/blob/main/doc/fixtures-refactoring.md

Use `@self->property` to access a property from another object that is a property of the current object. The example shows `created` referencing `@self->created_by.created` to get the creation date of the related user. Multi-depth access is possible with more dots, e.g., `@self->created_by.info.created`.

```yaml
Nelmio\Entity\User:
    user1:
        # ...
        created: '<dateTimeBetween("-200 days", "now")>'

Nelmio\Entity\Group:
    group1:
        # ...
        created_by: '@user1'
        created: '<dateTimeBetween(@self->created_by.created, "now")>'
        updated: '<dateTimeBetween($created, "now")>'

```

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

### Optional data with percentage notation

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Use the '50%? value' notation to make a field optional. Here, favoriteNumber is filled in only 50% of the time; the empty value defaults to null when omitted.

```yaml
Nelmio\Entity\User:
    user{1..10}:
        username: '<username()>'
        fullname: '<firstName()> <lastName()>'
        birthDate: '<date_create()>'
        email: '<email()>'
        favoriteNumber: '50%? <numberBetween(1, 200)>'
```

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

### Workaround for dynamic parameters in 3.x

Source: https://github.com/nelmio/alice/blob/main/doc/fixtures-refactoring.md

Workaround to use parameters that benefit from evaluation in 3.x, but all instances get the same ID.

```yaml
stdClass:
    parameters:
        shop_id: '<uniqid()>'

Nelmio\Entity\Shop:
    shop{1..10}:
        id: '@parameters->shop_id'
```

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

### YAML fixture definition for multiple classes

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

Defines static fixtures for Nelmio\Entity\User and Nelmio\Entity\Group in a YAML file. Each fixture is identified by a unique key (e.g., user0, group1) under the class name. Values are static and not dynamic.

```yaml
Nelmio\Entity\User:
    user0:
        username: bob
        fullname: Bob
        birthDate: 1980-10-10
        email: bob@example.org
        favoriteNumber: 42

    user1:
        username: alice
        fullname: Alice
        birthDate: 1978-07-12
        email: alice@example.org
        favoriteNumber: 27

Nelmio\Entity\Group:
    group1:
        name: Admins

```

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

### Parameters not evaluated in 3.x

Source: https://github.com/nelmio/alice/blob/main/doc/fixtures-refactoring.md

Shows that parameters are not evaluated in 3.x, so '<{shop_id}>' remains literal. This is a warning example.

```yaml
parameters:
    shop_id: '<uniqid()>'

Nelmio\Entity\Shop:
    shop{1..10}:
        id: '<{shop_id}>'
```

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

### Unique flag on an array property

Source: https://github.com/nelmio/alice/blob/main/doc/complete-reference.md

When the property is an array, the (unique) flag applies only to the fixture itself, not across all fixtures. Here, each user's friends array is unique per fixture, but user1#friends and user2#friends may contain duplicates.

```yaml
Nelmio\Entity\User:
    friends{1..2}:
        username (unique): '<username()>'
    user{1..2}:
        friends (unique): '@friends*' # array value

```

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

### YAML: Custom method calls must use __calls key

Source: https://github.com/nelmio/alice/blob/main/UPGRADE.md

In Alice 3.0, calls to custom methods (not setters) must be placed under the special `__calls` key. The example shows a `markAsInvited` call with an empty argument list.

```yaml
User:
    user_{A, B}:
        __calls:
            - markAsInvited: []
```

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

### Reference property with $variable notation

Source: https://github.com/nelmio/alice/blob/main/doc/fixtures-refactoring.md

Use the traditional PHP `$variable` notation to reference another property of the same object. In this example, `updated` uses `$created` to ensure the update date is after the creation date.

```yaml
Nelmio\Entity\User:
    # ...

Nelmio\Entity\Group:
    group1:
        name: Admins
        owner: '@user1'
        members: '<numberBetween(1, 10)>x @user*'
        created: '<dateTimeBetween("-200 days", "now")>'
        updated: '<dateTimeBetween($created, "now")>'

```

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

### Including files with top-level include key

Source: https://github.com/nelmio/alice/blob/main/doc/fixtures-refactoring.md

Use the top-level `include` key to merge other fixture files into the current data set. The includer's content takes precedence over included files' fixtures in case of duplicate keys. The example shows the main file including two files and defining a user that extends templates from both included files.

```yaml
include:
    - relative/path/to/file.yml
    - /absolute/path/to/another/file.yml

Nelmio\Entity\User:
    user1 (extends user, extends user_young):
        name: '<firstName()>'
        lastname: '<lastName()>'
        city: '<city()>'

```

```yaml
Nelmio\Entity\User:
    user (template):
        username: '<username()>'
        age: '<numberBetween(1, 40)>'

```

```yaml
Nelmio\Entity\User:
    user_young (template):
        age: '<numberBetween(1, 20)>'

```

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

### Load Fixtures from Array with NativeLoader

Source: https://github.com/nelmio/alice/blob/main/README.md

PHP code to load fixture data directly from an array using Nelmio\Alice\Loader\NativeLoader.

```php
$loader = new Nelmio\Alice\Loader\NativeLoader();
$objectSet = $loader->loadData([
    \Nelmio\Entity\User::class => [
        'user{1..10}' => [
            'username' => '<username()>',
            'fullname' => '<firstName()> <lastName()>',
            'birthDate' => '<date_create()>',
            'email' => '<email()>',
            'favoriteNumber' => '50%? <numberBetween(1, 200)>',
        ],
    ],
    \Nelmio\Entity\Group::class => [
        'group1' => [
            'name' => 'Admins',
            'owner' => '@user1',
            'members' => '<numberBetween(1, 10)>x @user*',
            'created' => '<dateTimeBetween("-200 days", "now")>',
            'updated' => '<dateTimeBetween($created, "now")>',
        ],
    ],
]);
```

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

### Load Fixtures from File with NativeLoader

Source: https://github.com/nelmio/alice/blob/main/README.md

PHP code to load fixture data from a YAML file using Nelmio\Alice\Loader\NativeLoader.

```php
$loader = new Nelmio\Alice\Loader\NativeLoader();
$objectSet = $loader->loadFile(__DIR__.'/fixtures.yml');
```

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

### Reference with wildcard

Source: https://github.com/nelmio/alice/blob/main/doc/relations-handling.md

Use a wildcard in a reference to pick any object whose name matches the pattern, where * can be any string.

```yaml
Nelmio\Entity\User:
    # ...

Nelmio\Entity\Group:
    group1:
        name: Admins
        owner: '@user*'
```

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

### Define multiple references with wildcard and count

Source: https://github.com/nelmio/alice/blob/main/doc/relations-handling.md

Use a wildcard with a count prefix (e.g., '5x @user*') to pick a fixed number of objects matching the pattern.

```yaml
Nelmio\Entity\User:
    # ...

Nelmio\Entity\Group:
    group1:
        name: Admins
        owner: '@user1'
        members: '5x @user*'
```

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

### Use fixture range syntax for static multiple references

Source: https://github.com/nelmio/alice/blob/main/doc/relations-handling.md

Use the same syntax as fixture ranges to define a static set of references, e.g., '@user{1..10}'.

```yaml
Nelmio\Entity\User:
    # ...

Nelmio\Entity\Group:
    group{1..10}:
        members: '@user{1..10}'
```

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

### Decorate nelmio_alice.property_accessor with ReflectionPropertyAccessor (YAML)

Source: https://github.com/nelmio/alice/blob/main/doc/advanced-guide.md

Use this YAML service configuration to replace Alice's default property accessor with Nelmio\Alice\PropertyAccess\ReflectionPropertyAccessor via Symfony DI decoration. Set decoration_priority to -10 and pass the inner service as an argument. This is one of two ways to extend accessor behavior.

```yaml
services:
    app.fixtures.reflection_property_accessor:
        class: Nelmio\Alice\PropertyAccess\ReflectionPropertyAccessor
        public: false
        decorates: nelmio_alice.property_accessor
        decoration_priority: -10
        arguments: ['@app.fixtures.reflection_property_accessor.inner']

```

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

### Randomize the amount of multiple references

Source: https://github.com/nelmio/alice/blob/main/doc/relations-handling.md

Combine a provider like <numberBetween(1, 10)> with the wildcard count syntax to randomize the number of objects picked.

```yaml
    # ...
        members: '<numberBetween(1, 10)>x @user*'
```

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

### Output: Result in 2.x for non-template extension

Source: https://github.com/nelmio/alice/blob/main/UPGRADE.md

Shows the resulting fixtures in Alice 2.x when extending from a non-template fixture: `dummy_A` has all three properties (`var1`, `var2`, `var`), while `dummy_B` has `var1` and `var2`.

```text
dummy_A: #stdClass {
    +var1: 'foo'
    +var2: 'bar'
    +var: 'A'
}
dummy_B: #stdClass {
    +var1: 'foo'
    +var2: 'bar'
}
```

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

### Using PHP internals for casting

Source: https://github.com/nelmio/alice/blob/main/doc/customizing-data-generation.md

Shows how to use PHP internals like `intval` and `boolval` instead of the cast method. The cast method was added but should be avoided in favor of these PHP functions.

```yaml
stdClass:
    dummy{1..2}:
        intval: <intval("1")>
        boolval: <boolval(1)>
```

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

### Parameters: '<{X}>' and escaped '"<{X}>"'

Source: https://github.com/nelmio/alice/blob/main/doc/advanced-guide.md

Defines a parameter 'foo' and uses it in a fixture with '<{foo}>'. The escaped form '\<{foo}>' returns the literal string '<{foo}>'. Nested parameters are not supported.

```yaml
parameters:
    foo: 'bar'

stdClass:
    dummy:
        foo: '<{foo}>'
        escapedFoo: '\<{foo}>'
```

```text
[
    'dummy' => stdClass {
       +"foo": "bar",
       +"escapedFoo": "<{foo}>",
    }
]
```

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

### Define an array of references

Source: https://github.com/nelmio/alice/blob/main/doc/relations-handling.md

Define an array of references to have a fixed set of members.

```yaml
Nelmio\Entity\User:
    # ...

Nelmio\Entity\Group:
    group1:
        name: Admins
        owner: '@user1'
        members: ['@user2', '@user3']
```

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

### Pass references to providers

Source: https://github.com/nelmio/alice/blob/main/doc/relations-handling.md

Pass references to providers much like passing variables. The reference is evaluated before being passed to the provider.

```yaml
Nelmio\Entity\Group:
    group1:
        owner: '<numberBetween(1, 200)>'

    group2:
        owner: '<numberBetween(@group1->owner, 200)>'
```

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

### Custom PropertyHydratorInterface implementation (PHP)

Source: https://github.com/nelmio/alice/blob/main/doc/advanced-guide.md

Implements PropertyHydratorInterface to customize property hydration. The hydrate method checks for a property named 'key' and returns a new SimpleObject with a modified instance; otherwise it delegates to the decorated hydrator. Use this to extend the default SymfonyPropertyAccessorHydrator behavior.

```php
<?php

namespace App;

use Nelmio\Alice\Definition\Object\SimpleObject;
use Nelmio\Alice\Definition\Property;
use Nelmio\Alice\Generator\GenerationContext;
use Nelmio\Alice\Generator\Hydrator\PropertyHydratorInterface;
use Nelmio\Alice\ObjectInterface;

final class DummyPropertyHydrator implements PropertyHydratorInterface
{
    private $hydrator;

    public function __construct(PropertyHydratorInterface $decoratedPropertyHydrator)
    {
        $this->hydrator = $decoratedPropertyHydrator;
    }

    /**
     * @inheritdoc
     */
    public function hydrate(ObjectInterface $object, Property $property, GenerationContext $context): ObjectInterface
    {
        if ('key' === $property->getName()) {
            $instance = $object->getInstance()->withKey($property->getValue());

            return new SimpleObject($object->getId(), $instance);
        }

        return $this->hydrator->hydrate($object, $property, $context);
    }
}

```

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

### Output: Result in 3.0 for non-template extension

Source: https://github.com/nelmio/alice/blob/main/UPGRADE.md

Shows the resulting fixtures in Alice 3.0 when extending from a non-template fixture: `dummy_A` only has `var: 'A'`, while `dummy_B` retains `var1` and `var2`.

```text
dummy_A: #stdClass {
    +var: 'A'
}
dummy_B: #stdClass {
    +var1: 'foo'
    +var2: 'bar'
}
```

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

### Usage with functions (constructor included) in YAML

Source: https://github.com/nelmio/alice/blob/main/doc/fixtures-refactoring.md

Shows how to use parameters inside constructor arguments, with reference to previous arguments using '$arg0' and '$3'.

```yaml
parameters:
    foo: bar

Nelmio\Entity\Dummy:
    dummy{1..10}:
        __construct:
            arg0: '<{foo}>'
            arg1: '$arg0' # will be resolved info 'bar'
            3: 500  # the numerical key here is just a random number as in YAML you cannot mix keys with array values
            4: '$3' # `3` here refers to the *third* argument, i.e. 500
```

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

### Functions: '<function(X)>' and escaped '"<function(X)>"'

Source: https://github.com/nelmio/alice/blob/main/doc/advanced-guide.md

Uses PHP native function strtolower and nested expressions with '<(implode(...))>' and escaped '<foo()>'. The output shows 'hellow world' (note the typo in the source) and literal '<foo()> <bar()>'.

```yaml
stdClass:
    dummy:
        functionValue: '<strtolower("BAR")>'
        nestedFunctionValue: '<strtolower(<(implode(" ", ["HELLO", "WORLD", \<foo()>]))>)> \<bar()>'
```

```text
[
    'dummy' => stdClass {
        +"functionValue": "bar",
        +"nestedFunctionValue": "hellow world <foo()> <bar()>",
    }
]
```

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

### Identity with current: '<($current)>'

Source: https://github.com/nelmio/alice/blob/main/doc/advanced-guide.md

Uses the identity function with the $current variable to output the current fixture index. For a range {1..2}, the result is '1' and '2'.

```yaml
# Example with current
stdClass:
    dummy{1..2}:
        foo: '<($current)>'
```

```text
[
    'dummy1' => stdClass {
        +"foo": "1",
    },
    'dummy2' => stdClass {
        +"foo": "2",
    }
]
```

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

### Custom Faker Provider Class (JobProvider)

Source: https://github.com/nelmio/alice/blob/main/doc/customizing-data-generation.md

Define a custom Faker provider by extending Faker\Provider\Base. The class provides jobTitle() and jobAbbreviation() methods that return random values from static arrays. Use this when you need domain-specific fake data beyond what Faker and Alice offer natively.

```php
<?php

namespace App\Faker\Provider;

use Faker\Provider\Base as BaseProvider;

final class JobProvider extends BaseProvider
{
   /**
    * Sources: {@link http://siliconvalleyjobtitlegenerator.tumblr.com/}
    *
    * @var array List of job titles.
    */
   const TITLE_PROVIDER = [
       'firstname' => [
           'Audience Recognition',
           'Big Data',
           'Bitcoin',
           '...',
           'Video Experience',
           'Wearables',
           'Webinar',
       ],
       'lastname' => [
           'Advocate',
           'Amplifier',
           'Architect',
           '...',
           'Warlock',
           'Watchman',
           'Wizard',
       ],
       'fullname' => [
           'Conductor of Datafication',
           'Crowd-Funder-in-Residence',
           'Quantified-Self-in-Residence',
           '...',
           'Tech-Svengali-in-Residence',
           'Tech-Wizard-in-Residence',
           'Thought-Leader-in-Residence',
       ],
   ];

   /**
    * Sources: {@link http://sos.uhrs.indiana.edu/Job_Code_Title_Abbreviation_List.htm}
    *
    * @var array List of job abbreviations.
    */
   const ABBREVIATION_PROVIDER = [
       'ABATE',
       'ACAD',
       'ACCT',
       '...',
       'WCTR',
       'WSTRN',
       'WKR',
   ];

   /**
    * @return string Random job title.
    */
   public function jobTitle()
   {
       $names = [
           sprintf(
               '%s %s',
               self::randomElement(self::TITLE_PROVIDER['firstname']),
               self::randomElement(self::TITLE_PROVIDER['lastname'])
           ),
           self::randomElement(self::TITLE_PROVIDER['fullname']),
       ];

       return self::randomElement($names);
   }

   /**
    * @return string Random job abbreviation title
    */
   public function jobAbbreviation()
   {
       return self::randomElement(self::ABBREVIATION_PROVIDER);
   }
}

```

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

### Randomized user data with Faker providers

Source: https://github.com/nelmio/alice/blob/main/doc/customizing-data-generation.md

Uses Faker data providers like `<username()>`, `<firstName()>`, `<lastName()>`, `<date_create()>`, `<email()>`, and `<numberBetween(1, 200)>` to generate random data for a collection of 10 users. Arguments can be passed to providers as in a function call.

```yaml
Nelmio\Entity\User:
    user{1..10}:
        username: '<username()>'
        fullname: '<firstName()> <lastName()>'
        birthDate: '<date_create()>'
        email: '<email()>'
        favoriteNumber: '<numberBetween(1, 200)>'
```

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

### Reference an object with @name

Source: https://github.com/nelmio/alice/blob/main/doc/relations-handling.md

Use the @name notation to reference a fixture from any class. The reference name should be composed of letters, digits, periods, underscores, and slashes; other characters like braces and parentheses have special meanings.

```yaml
Nelmio\Entity\User:
    # ...

Nelmio\Entity\Group:
    group1:
        name: Admins
        owner: '@user1'
```

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

### Register Custom Faker Provider with Autowiring and Autoconfiguration (YAML)

Source: https://github.com/nelmio/alice/blob/main/doc/customizing-data-generation.md

Symfony automatically registers the provider with the tag `nelmio_alice.faker.provider` when the service extends `Faker\Provider\Base` and has `autowire` and `autoconfigure` enabled. This YAML configuration enables those defaults and declares the provider service.

```yaml
# config/services.yaml

services:
    _defaults:
        autowire: true
        autoconfigure: true

    App\Faker\Provider\JobProvider: ~

```

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

### Reference a random object by ID

Source: https://github.com/nelmio/alice/blob/main/doc/relations-handling.md

Use a provider like <numberBetween(1, 200)> to reference a random object by its ID.

```yaml
Nelmio\Entity\Group:
    group1:
        owner: '@user<numberBetween(1, 200)>'
```

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

### Reference with current() in fixture ranges

Source: https://github.com/nelmio/alice/blob/main/doc/relations-handling.md

Use <current()> to reference the current iteration ID when using fixture ranges. This allows creating multiple objects with each referencing a corresponding one.

```yaml
Nelmio\Entity\User:
    # ...

Nelmio\Entity\Group:
    group{1..10}:
        owner: '@user<current()>'
```

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

### Register Custom Faker Provider with Explicit Tag (YAML)

Source: https://github.com/nelmio/alice/blob/main/doc/customizing-data-generation.md

Alternative Symfony registration that explicitly passes the Faker generator as an argument and adds the `nelmio_alice.faker.provider` tag. Use this when autoconfiguration is not enabled or you need to customize the service definition.

```yaml
# config/services.yaml

services:
    App\Faker\Provider\JobProvider:
        arguments:
            - '@Faker\Generator'
        tags: [ { name: nelmio_alice.faker.provider } ]

```

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

### Current value in a collection context

Source: https://github.com/nelmio/alice/blob/main/doc/customizing-data-generation.md

Returns the current value in the context of a collection using `<current()>`, which is equivalent to `$current`. Used for generating values that depend on the current iteration index.

```yaml
stdClass:
    dummy{1..2}:
        currentValue: <current()> # is equivalent to '$current'
```

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

### Template inheritance with extends flag

Source: https://github.com/nelmio/alice/blob/main/doc/fixtures-refactoring.md

Defines a base template 'user_bare' and a full template 'user_full' that extends it using the '(extends user_bare)' flag. Template instances are not persisted.

```yaml
Nelmio\Entity\User:
    user_bare (template):
        username: '<username()>'
    user_full (template, extends user_bare):
        name: '<firstName()>'
        lastname: '<lastName()>'
        city: '<city()>'
```

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

### Dynamic parameters in YAML

Source: https://github.com/nelmio/alice/blob/main/doc/fixtures-refactoring.md

Uses dynamic parameters with '<current()>' to resolve different values per instance.

```yaml
parameters:
    username_alice: Alice
    username_bob: Bob

Nelmio\Entity\User:
    user_{alice, bob}:
        username: '<{username_<current()>}>' # Will be 'Alice' for 'user_alice' and 'Bob' for 'user_bob'
```

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

### Reference an object property with @name->property

Source: https://github.com/nelmio/alice/blob/main/doc/relations-handling.md

Use the @name->property notation to reference an object's property. Public properties are directly accessible, otherwise a getter is called (e.g., @name->property calls $name->getProperty()). Private properties can be accessed by decorating the property accessor with ReflectionPropertyAccessor.

```yaml
Nelmio\Entity\User:
    # ...

Nelmio\Entity\Group:
    group1:
        name: Admins
        owner: '@user1->username'
```

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

### YAML: Extending from a non-template fixture is no longer possible

Source: https://github.com/nelmio/alice/blob/main/UPGRADE.md

In Alice 3.0, you cannot 'extend' from a non-template fixture. The fixture definition `dummy_A` will completely override the `dummy_A` derived from `dummy_{A, B}`, resulting in `dummy_A` having only `var: 'A'` and `dummy_B` having `var1` and `var2`. In 2.x, `dummy_A` would have all three properties.

```yaml
stdClass:
    dummy_{A, B}:
        var1: 'foo'
        var2: 'bar'

    dummy_A:    # This fixture definition will completely override the 'dummy_A' derived from 'dummy_{A, B}'
        var: 'A'
```

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

### Reference an entity ID with @name->id

Source: https://github.com/nelmio/alice/blob/main/doc/relations-handling.md

Use the @name->id notation to reference an entity's ID. This implies you are setting IDs when the object is created (e.g., with UUIDs) or you have no guarantee the ID is not already used in the database.

```yaml
# fixture_user.yml
Nelmio\Entity\User:
    # ...
```

```yaml
# fixture_group.yml
Nelmio\Entity\Group:
    group1:
        name: Admins
        owner: '@user1->id'
```

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

### PHP: addX() no longer supported without removeX(), setter required

Source: https://github.com/nelmio/alice/blob/main/UPGRADE.md

In Alice 3.0, `addX()` methods are only supported if a corresponding `removeX()` method exists. If not, you must define a setter for the collection, as shown. Previously, if an `addX($object)` method existed and the argument in Alice was an array, `addX($object)` was called for each element; this is no longer the case.

```php
class Recipe

    // no longer supported
    public function addServing(Serving $serving)
    {
        // …
    }
    
    // the setter must be defined
    public function setServings(iterable $servings)
    {
        // …
    }
}
```

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

### Composite parameters in YAML

Source: https://github.com/nelmio/alice/blob/main/doc/fixtures-refactoring.md

Combines parameters into a composite value using '<{key1}> <{key2}>!'.

```yaml
parameters:
    key1: NaN
    key2: Bat
    composite: '<{key1}> <{key2}>!'

Nelmio\Entity\User:
    user0:
        username: '<{composite}>' # 'NaN Bat!'
```

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

### Static parameters in YAML

Source: https://github.com/nelmio/alice/blob/main/doc/fixtures-refactoring.md

Defines global parameters that are inserted where used. The parameter can be referenced with '<{param}>' or '<($param)>'.

```yaml
parameters:
    ebay_domain_name: ebay.us

Nelmio\Entity\Shop:
    shop{1..10}:
        domain: '<{ebay_domain_name}>'
        # or
        domain: '<($ebay_domain_name)>'
```

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

### Extending multiple templates with last extends override

Source: https://github.com/nelmio/alice/blob/main/doc/fixtures-refactoring.md

Demonstrates extending from two templates. The last declared 'extends' (user_young) overrides values from previous templates, but explicit fixture values like 'username: user1' remain unchanged.

```yaml
Nelmio\Entity\User:
    user (template):
        username: '<username()>'
        age: '<numberBetween(1, 40)>'

    user_young (template):
        age: '<numberBetween(1, 20)>'

    user1 (extends user, extends user_young):
        username: user1
        name: '<firstName()>'
        lastname: '<lastName()>'
        city: '<city()>'
```

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

### Extending a template with overrides

Source: https://github.com/nelmio/alice/blob/main/doc/fixtures-refactoring.md

Shows a template 'user' and a fixture 'user1' that extends it, overriding the 'age' value. Extension properties do not override values set explicitly in the fixture spec.

```yaml
Nelmio\Entity\User:
    user (template):
        username: '<username()>'
        age: '<numberBetween(1, 20)>'

    user1 (extends user):
        name: '<firstName()>'
        lastname: '<lastName()>'
        city: '<city()>'
        age: '<numberBetween(1, 50)>'
```
Tokens:
Raw