PHP code example of directorytree / dummy

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

directorytree / dummy example snippets

use DirectoryTree\Dummy\HasFactory;

class Reservation
{
    use HasFactory;

    protected static function toFactoryInstance(array $attributes): static
    {
        return new static(
            $attributes['name'],
            $attributes['email'],
        );
    }
}

$reservation = Reservation::factory()->make();

use DirectoryTree\Dummy\DummyData;
use DirectoryTree\Dummy\HasDummyFactory;

class Reservation
{
    use HasDummyFactory;

    protected static function toDummyInstance(DummyData $attributes): static
    {
        return new static(
            $attributes['name'],
            $attributes['email'],
        );
    }
}

$reservation = Reservation::dummy()->make();

protected static function toDummyInstance(DummyData $attributes): static
{
    return new static($attributes->all());
}

$attributes->get('profile.name');
$attributes->filled('email');
$attributes->boolean('active');
$attributes->integer('visits');
$attributes->enum('status', Status::class);
$attributes->enums('roles', Role::class);
$attributes->only(['name', 'email']);
$attributes->except('password');

namespace App\Data;

class Reservation
{
    public function __construct(
        public string $name,
        public string $email,
        public DateTime $date,
    ) {}
}

// Generate one instance:
$reservation = Reservation::dummy()->make();

// Generate multiple instances:
$collection = Reservation::dummy()->count(5)->make();

namespace App\Data;

use DateTime;
use Faker\Generator;
use DirectoryTree\Dummy\DummyData;
use DirectoryTree\Dummy\HasDummyFactory;

/**
 * @use HasDummyFactory<Reservation>
 */
class Reservation
{
    use HasDummyFactory;
    
    /**
     * Constructor.
     */
    public function __construct(
        public string $name,
        public string $email,
        public DateTime $date,
    ) {}
    
    /**
     * Define the factory's default state.
     */
    protected static function getDummyDefinition(Generator $faker): array
    {
        return [
            'name' => $faker->name(),
            'email' => $faker->email(),
            'datetime' => $faker->dateTime(),
        ];
    }
    
    /**
     * Create a new instance of the class using the factory definition.
     */
    protected static function toDummyInstance(DummyData $attributes): static
    {
        return new static(
            $attributes['name'],
            $attributes['email'],
            $attributes['datetime'],
        );
    }
}

$factory = Reservation::dummy();

namespace App\Data;

use DateTime;
use Faker\Generator;
use DirectoryTree\Dummy\DummyData;
use DirectoryTree\Dummy\HasDummyFactory;

/**
 * @use HasDummyFactory<Reservation>
 */
class Reservation
{
    use HasDummyFactory;

    public function __construct(
        public string $name,
        public string $email,
        public DateTime $datetime,
        public string $status = 'pending',
        public string $type = 'standard',
    ) {}

    // Dynamic state methods...

    public static function getConfirmedState(): array
    {
        return ['status' => 'confirmed'];
    }

    public static function getPremiumState(): array
    {
        return [
            'type' => 'premium',
            'status' => 'confirmed',
        ];
    }

    public static function getCancelledState(): array
    {
        return ['status' => 'cancelled'];
    }

    protected static function toDummyInstance(DummyData $attributes): self
    {
        return new static(
            $attributes['name'],
            $attributes['email'],
            $attributes['datetime'],
            $attributes['status'] ?? 'pending',
            $attributes['type'] ?? 'standard',
        );
    }

    protected static function getDummyDefinition(Generator $faker): array
    {
        return [
            'name' => $faker->name(),
            'email' => $faker->email(),
            'datetime' => $faker->dateTime(),
        ];
    }
}

// Create a confirmed reservation
$confirmed = Reservation::dummy()->confirmed()->make();

// Create a premium reservation
$premium = Reservation::dummy()->premium()->make();

// Chain multiple states
$premiumCancelled = Reservation::dummy()->premium()->cancelled()->make();

namespace App\Factories;

use App\Data\Reservation;
use DirectoryTree\Dummy\Factory;

/**
 * @extends Factory<Reservation>
 */
class ReservationFactory extends Factory
{
    /**
     * Define the factory's default state.
     */
    protected function definition(): array
    {
        return [
            'name' => $this->faker->name(),
            'email' => $this->faker->email(),
            'datetime' => $this->faker->dateTime(),
        ];
    }
    
    /**
     * Generate a new instance of the class.
     */
    protected function generate(array $attributes): Reservation
    {
        return new Reservation(
            $attributes['name'],
            $attributes['email'],
            $attributes['datetime'],
        );
    }
}

// Using the trait:
$reservation = Reservation::dummy()->make();

// Using the factory class:
$reservation = ReservationFactory::new()->make();

$reservation = Reservation::dummy()->make([
    'name' => 'John Doe',
]);

$collection = Reservation::dummy()->count(5)->make();

$reservation = Reservation::dummy()->count(5)->makeOne();

$collection = Reservation::dummy()->makeMany([
    ['name' => 'Taylor Otwell'],
    ['name' => 'Nuno Maduro'],
]);

$makeReservation = Reservation::dummy()->lazy([
    'name' => 'John Doe',
]);

$reservation = $makeReservation();

class ReservationFactory extends Factory
{
    // ...

    /**
     * Indicate that the reservation is for tomorrow.
     */
    public function tomorrow(): Factory
    {
        return $this->state(function (array $attributes) {
            return ['datetime' => new DateTime('tomorrow')];
        });
    }
}

$reservation = Reservation::dummy()
    ->tomorrow()
    ->prependState([
        'name' => 'Early State',
    ])
    ->make();

use App\Models\Company;
use App\Models\User;

$reservation = Reservation::dummy()->make([
    'company_id' => Company::factory(),
    'user_id' => User::factory()->create(),
]);

$reservation = Reservation::dummy()->make([
    'company_id' => Company::factory(),
    'user_id' => fn (array $attributes) => User::factory([
        'company_id' => $attributes['company_id'],
    ]),
]);

class ReservationFactory extends Factory
{
    // ...
    
    /**
     * Configure the dummy factory.
     */
    protected function configure(): static
    {
        return $this->afterMaking(function (Reservation $reservation) {
            // ...
        });
    }
}

$reservation = ReservationFactory::new()
    ->withoutAfterMaking()
    ->make();

Reservation::dummy()
    ->count(3)
    ->sequence(
        ['datetime' => new Datetime('tomorrow')],
        ['datetime' => new Datetime('next week')],
        ['datetime' => new Datetime('next month')],
    )
    ->make();

class ReservationFactory extends Factory
{
    // ...
    
    /**
     * Create a new collection of classes.
     */
    public function collect(array $instances = []): ReservationCollection
    {
        return new ReservationCollection($instances);
    }
}

use DirectoryTree\Dummy\Factory;

Factory::macro('named', function (string $name) {
    return $this->state([
        'name' => $name,
    ]);
});

$reservation = Reservation::dummy()->named('John Doe')->make();

/**
 * @use HasDummyFactory<Reservation>
 */
class Reservation
{
    use HasDummyFactory;

    // ...
}

/**
 * @extends Factory<Reservation>
 */
class ReservationFactory extends Factory
{
    // ...
}