Add ability to add dynamic factory states on classes using HasFactory

Author: stevebauman

readme.md

@@ -86,8 +86,8 @@ The `HasFactory` trait is applied directly to the class you would like to genera
 To use the `HasFactory` trait, you must implement the `toFactoryInstance` and `getFactoryDefinition` methods:
 
 > [!note]
-> The `HasFactory` trait does not provide you the capability of defining state methods or callbacks.
-> If you need this functionality, you should define a separate `Factory` class instead.
+> The `HasFactory` trait supports dynamic state methods. You can define state methods in the format `get{StateName}State` and call them via `Class::factory()->stateName()->make()`.
+> For more complex factory logic or callbacks, you should define a separate `Factory` class instead.
 
 ```php
 namespace App\Data;
@@ -141,6 +141,83 @@ Once implemented, you may call the `Reservation::factory()` method to create a n
 $factory = Reservation::factory();
 ```
 
+#### Dynamic State Methods
+
+The `HasFactory` trait supports dynamic state methods. You can define state methods in your class using the format `get{StateName}State` and call them dynamically on the factory:
+
+```php
+namespace App\Data;
+
+use DateTime;
+use Faker\Generator;
+use DirectoryTree\Dummy\HasFactory;
+
+class Reservation
+{
+    use HasFactory;
+
+    public function __construct(
+        public string $name,
+        public string $email,
+        public DateTime $datetime,
+        public string $status = 'pending',
+        public string $type = 'standard',
+    ) {}
+
+    protected static function toFactoryInstance(array $attributes): self
+    {
+        return new static(
+            $attributes['name'],
+            $attributes['email'],
+            $attributes['datetime'],
+            $attributes['status'] ?? 'pending',
+            $attributes['type'] ?? 'standard',
+        );
+    }
+
+    protected static function getFactoryDefinition(Generator $faker): array
+    {
+        return [
+            'name' => $faker->name(),
+            'email' => $faker->email(),
+            'datetime' => $faker->dateTime(),
+        ];
+    }
+
+    // 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'];
+    }
+}
+```
+
+You can then use these state methods dynamically:
+
+```php
+// Create a confirmed reservation
+$confirmed = Reservation::factory()->confirmed()->make();
+
+// Create a premium reservation
+$premium = Reservation::factory()->premium()->make();
+
+// Chain multiple states
+$premiumCancelled = Reservation::factory()->premium()->cancelled()->make();
+```
+
 ### Class Factory
 
 If you need more control over the dummy data generation process, you may use the `Factory` class.

src/Factory.php

@@ -2,6 +2,7 @@
 
 namespace DirectoryTree\Dummy;
 
+use BadMethodCallException;
 use Closure;
 use Faker\Factory as FakerFactory;
 use Faker\Generator;
@@ -26,6 +27,7 @@ public function __construct(
         protected ?Closure $using = null,
         protected Collection $states = new Collection,
         protected Collection $afterMaking = new Collection,
+        protected ?string $class = null,
     ) {
         $this->faker = $this->newFaker();
     }
@@ -270,6 +272,7 @@ protected function newInstance(array $arguments = []): static
             'using' => $this->using,
             'states' => $this->states,
             'afterMaking' => $this->afterMaking,
+            'usingClass' => $this->class,
         ], $arguments)));
     }
 
@@ -292,4 +295,34 @@ protected function newFaker(): Generator
 
         return FakerFactory::create();
     }
+
+    /**
+     * Handle dynamic state method calls.
+     */
+    public function __call(string $method, array $parameters): static
+    {
+        if (! $this->class) {
+            throw new BadMethodCallException('Cannot call state methods on a factory without a using class.');
+        }
+
+        if (! method_exists($this->class, $stateMethod = $this->getStateMethod($method))) {
+            throw new BadMethodCallException("Method [{$method}] does not exist on [{$this->class}].");
+        }
+
+        if (! is_callable([$this->class, $stateMethod])) {
+            throw new BadMethodCallException("Method [{$method}] is not callable on [{$this->class}].");
+        }
+
+        return $this->state(
+            call_user_func([$this->class, $stateMethod], $parameters)
+        );
+    }
+
+    /**
+     * Get the state method name for the given method name.
+     */
+    protected function getStateMethod(string $method): string
+    {
+        return 'get'.ucfirst($method).'State';
+    }
 }

src/HasFactory.php

@@ -25,7 +25,7 @@ function (Generator $faker, array $attributes) {
      */
     protected static function newFactory(array $attributes): Factory
     {
-        return Factory::new($attributes);
+        return (new Factory(class: static::class))->state($attributes);
     }
 
     /**

tests/Fixtures/HasFactoryWithStatesStub.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace DirectoryTree\Dummy\Tests\Fixtures;
+
+use DirectoryTree\Dummy\Data;
+use DirectoryTree\Dummy\HasFactory;
+use Faker\Generator;
+
+class HasFactoryWithStatesStub
+{
+    use HasFactory;
+
+    protected static function toFactoryInstance(array $attributes): Data
+    {
+        return new Data($attributes);
+    }
+
+    protected static function getFactoryDefinition(Generator $faker): array
+    {
+        return [
+            'name' => $faker->name(),
+            'email' => $faker->email(),
+            'role' => 'user',
+            'status' => 'active',
+        ];
+    }
+
+    /**
+     * Admin state method.
+     */
+    public static function getAdminState(): array
+    {
+        return [
+            'role' => 'admin',
+            'name' => 'Admin User',
+            'email' => '[email protected]',
+        ];
+    }
+
+    /**
+     * Inactive state method.
+     */
+    public static function getInactiveState(): array
+    {
+        return [
+            'status' => 'inactive',
+        ];
+    }
+
+    /**
+     * Premium state method.
+     */
+    public static function getPremiumState(): array
+    {
+        return [
+            'role' => 'premium',
+            'subscription' => 'premium',
+        ];
+    }
+}

tests/HasFactoryTest.php

@@ -3,6 +3,7 @@
 use DirectoryTree\Dummy\Data;
 use DirectoryTree\Dummy\Tests\Fixtures\HasFactoryInstanceStub;
 use DirectoryTree\Dummy\Tests\Fixtures\HasFactoryStub;
+use DirectoryTree\Dummy\Tests\Fixtures\HasFactoryWithStatesStub;
 
 it('can generate fake data instance', function () {
     $instance = HasFactoryStub::factory()->make();
@@ -25,3 +26,36 @@
     expect($instance)->toBeInstanceOf(HasFactoryInstanceStub::class);
     expect($instance->attributes)->toHaveKeys(['name', 'email']);
 });
+
+it('can use dynamic state methods', function () {
+    $instance = HasFactoryWithStatesStub::factory()->admin()->make();
+
+    expect($instance)->toBeInstanceOf(Data::class);
+    expect($instance->role)->toBe('admin');
+    expect($instance->name)->toBe('Admin User');
+    expect($instance->email)->toBe('[email protected]');
+});
+
+it('can chain multiple dynamic state methods', function () {
+    $instance = HasFactoryWithStatesStub::factory()->admin()->inactive()->make();
+
+    expect($instance)->toBeInstanceOf(Data::class);
+    expect($instance->role)->toBe('admin');
+    expect($instance->name)->toBe('Admin User');
+    expect($instance->email)->toBe('[email protected]');
+    expect($instance->status)->toBe('inactive');
+});
+
+it('can use dynamic state methods with premium state', function () {
+    $instance = HasFactoryWithStatesStub::factory()->premium()->make();
+
+    expect($instance)->toBeInstanceOf(Data::class);
+    expect($instance->role)->toBe('premium');
+    expect($instance->subscription)->toBe('premium');
+});
+
+it('throws exception for non-existent state methods', function () {
+    expect(function () {
+        HasFactoryWithStatesStub::factory()->nonExistentState()->make();
+    })->toThrow(\BadMethodCallException::class);
+});