Add ability to use without the Laravel framework

Author: stevebauman

composer.json

@@ -27,7 +27,7 @@
         "pestphp/pest": "^1.0|^2.0|^3.0",
         "laravel/pint": "^1.0",
         "fakerphp/faker": "^1.0",
-        "illuminate/support": "^9.0|^10.0|^11.0",
+        "illuminate/collections": "^9.0|^10.0|^11.0",
         "orchestra/testbench": "^7.0|^8.0|^9.0"
     },
     "config": {

composer.lock

@@ -128,9 +128,9 @@ class Reservation
     protected static function toFactoryInstance(array $attributes): static
     {
         return new static(
-            $fluent->name,
-            $fluent->email,
-            $fluent->datetime,
+            $attributes['name'],
+            $attributes['email'],
+            $attributes['datetime'],
         );
     }
 }

readme.md

@@ -0,0 +1,159 @@
+<?php
+
+namespace DirectoryTree\Dummy;
+
+use ArrayAccess;
+use Illuminate\Support\Arr;
+use JsonSerializable;
+
+class Data implements ArrayAccess, JsonSerializable
+{
+    /**
+     * The data attributes.
+     */
+    protected array $attributes = [];
+
+    /**
+     * Constructor.
+     */
+    public function __construct(iterable $attributes = [])
+    {
+        foreach ($attributes as $key => $value) {
+            $this->attributes[$key] = $value;
+        }
+    }
+
+    /**
+     * Get an attribute from the data instance using "dot" notation.
+     */
+    public function get(string $key, mixed $default = null): mixed
+    {
+        return data_get($this->attributes, $key, $default);
+    }
+
+    /**
+     * Get an attribute from the data instance.
+     */
+    public function value(string $key, mixed $default = null): mixed
+    {
+        if (array_key_exists($key, $this->attributes)) {
+            return $this->attributes[$key];
+        }
+
+        return value($default);
+    }
+
+    /**
+     * Get the value of the given key as a new data instance.
+     */
+    public function scope(string $key, mixed $default = null): static
+    {
+        return new static(
+            (array) $this->get($key, $default)
+        );
+    }
+
+    /**
+     * Get the attributes from the data instance.
+     *
+     * @param  array|mixed|null  $keys
+     */
+    public function all(mixed $keys = null): array
+    {
+        $data = $this->attributes;
+
+        if (! $keys) {
+            return $data;
+        }
+
+        $results = [];
+
+        foreach (is_array($keys) ? $keys : func_get_args() as $key) {
+            Arr::set($results, $key, Arr::get($data, $key));
+        }
+
+        return $results;
+    }
+
+    /**
+     * Convert the object into something JSON serializable.
+     */
+    public function jsonSerialize(): array
+    {
+        return $this->attributes;
+    }
+
+    /**
+     * Determine if the given offset exists.
+     */
+    public function offsetExists(mixed $offset): bool
+    {
+        return isset($this->attributes[$offset]);
+    }
+
+    /**
+     * Get the value for a given offset.
+     */
+    public function offsetGet(mixed $offset): mixed
+    {
+        return $this->value($offset);
+    }
+
+    /**
+     * Set the value at the given offset.
+     */
+    public function offsetSet(mixed $offset, mixed $value): void
+    {
+        $this->attributes[$offset] = $value;
+    }
+
+    /**
+     * Unset the value at the given offset.
+     */
+    public function offsetUnset(mixed $offset): void
+    {
+        unset($this->attributes[$offset]);
+    }
+
+    /**
+     * Handle dynamic calls to the data instance to set attributes.
+     */
+    public function __call(string $method, array $parameters): static
+    {
+        $this->attributes[$method] = count($parameters) > 0 ? reset($parameters) : true;
+
+        return $this;
+    }
+
+    /**
+     * Dynamically retrieve the value of an attribute.
+     */
+    public function __get(string $key): mixed
+    {
+        return $this->value($key);
+    }
+
+    /**
+     * Dynamically set the value of an attribute.
+     */
+    public function __set(string $key, mixed $value): void
+    {
+        $this->offsetSet($key, $value);
+    }
+
+    /**
+     * Dynamically check if an attribute is set.
+     */
+    public function __isset(string $key): bool
+    {
+        return $this->offsetExists($key);
+    }
+
+    /**
+     * Dynamically unset an attribute.
+     */
+    public function __unset(string $key): void
+    {
+        $this->offsetUnset($key);
+    }
+}

src/Data.php

@@ -3,10 +3,10 @@
 namespace DirectoryTree\Dummy;
 
 use Closure;
+use Faker\Factory as FakerFactory;
 use Faker\Generator;
 use Illuminate\Container\Container;
 use Illuminate\Support\Collection;
-use Illuminate\Support\Fluent;
 use Illuminate\Support\Traits\Conditionable;
 
 class Factory
@@ -59,7 +59,7 @@ protected function definition(): array
      */
     protected function generate(array $attributes): mixed
     {
-        return new Fluent($attributes);
+        return new Data($attributes);
     }
 
     /**
@@ -286,6 +286,10 @@ public function faker(): Generator
      */
     protected function newFaker(): Generator
     {
-        return Container::getInstance()->make(Generator::class);
+        if (class_exists(Container::class)) {
+            return Container::getInstance()->make(Generator::class);
+        }
+
+        return FakerFactory::create();
     }
 }

src/Factory.php

@@ -1,24 +1,24 @@
 <?php
 
+use DirectoryTree\Dummy\Data;
 use DirectoryTree\Dummy\Tests\Fixtures\FactoryClassStub;
 use DirectoryTree\Dummy\Tests\Fixtures\FactoryStub;
 use DirectoryTree\Dummy\Tests\Fixtures\FactoryWithConfigurationStub;
 use DirectoryTree\Dummy\Tests\Fixtures\FactoryWithCustomClassStub;
 use DirectoryTree\Dummy\Tests\Fixtures\FactoryWithStateStub;
 use Illuminate\Support\Collection;
-use Illuminate\Support\Fluent;
 
 it('can generate single instance', function () {
     $instance = FactoryStub::new()->make();
 
-    expect($instance)->toBeInstanceOf(Fluent::class);
+    expect($instance)->toBeInstanceOf(Data::class);
 });
 
 it('can generate multiple instances in a collection', function () {
     $collection = FactoryStub::new()->count(5)->make();
 
     $collection->each(
-        fn ($instance) => expect($instance)->toBeInstanceOf(Fluent::class)
+        fn ($instance) => expect($instance)->toBeInstanceOf(Data::class)
     );
 
     expect($collection)->toHaveCount(5);

tests/FactoryTest.php

@@ -2,8 +2,8 @@
 
 namespace DirectoryTree\Dummy\Tests\Fixtures;
 
+use DirectoryTree\Dummy\Data;
 use DirectoryTree\Dummy\Factory;
-use Illuminate\Support\Fluent;
 
 class FactoryWithConfigurationStub extends Factory
 {
@@ -17,8 +17,8 @@ protected function definition(): array
 
     protected function configure(): static
     {
-        return $this->afterMaking(function (Fluent $fluent) {
-            $fluent->name = 'Custom';
+        return $this->afterMaking(function (Data $data) {
+            $data->name = 'Custom';
         });
     }
 }