feat: custom presets

src/ArchPresets/AbstractPreset.php

@@ -15,7 +15,7 @@ abstract class AbstractPreset // @pest-arch-ignore-line
     /**
      * The expectations.
      *
-     * @var array<int, ArchExpectation>
+     * @var array<int, Expectation<mixed>|ArchExpectation>
      */
     protected array $expectations = [];
 
@@ -24,7 +24,7 @@ abstract class AbstractPreset // @pest-arch-ignore-line
      *
      * @param  array<int, string>  $userNamespaces
      */
-    final public function __construct(
+    public function __construct(
         private readonly array $userNamespaces,
     ) {
         //
@@ -45,7 +45,7 @@ abstract class AbstractPreset // @pest-arch-ignore-line
     final public function ignoring(array|string $targetsOrDependencies): void
     {
         $this->expectations = array_map(
-            fn (ArchExpectation $expectation): \Pest\Arch\Contracts\ArchExpectation => $expectation->ignoring($targetsOrDependencies),
+            fn (ArchExpectation|Expectation $expectation): Expectation|ArchExpectation => $expectation instanceof ArchExpectation ? $expectation->ignoring($targetsOrDependencies) : $expectation,
             $this->expectations,
         );
     }

src/ArchPresets/Custom.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\ArchPresets;
+
+use Closure;
+use Pest\Arch\Contracts\ArchExpectation;
+use Pest\Expectation;
+
+/**
+ * @internal
+ */
+final class Custom extends AbstractPreset
+{
+    /**
+     * Creates a new preset instance.
+     *
+     * @param  array<int, string>  $userNamespaces
+     * @param  Closure(array<int, string>): array<Expectation<mixed>|ArchExpectation>  $execute
+     */
+    public function __construct(
+        private readonly array $userNamespaces,
+        private readonly string $name,
+        private readonly Closure $execute,
+    ) {
+        parent::__construct($userNamespaces);
+    }
+
+    /**
+     * Returns the name of the preset.
+     */
+    public function name(): string
+    {
+        return $this->name;
+    }
+
+    /**
+     * Executes the arch preset.
+     */
+    public function execute(): void
+    {
+        $this->expectations = ($this->execute)($this->userNamespaces);
+    }
+}

src/Concerns/Testable.php

@@ -6,6 +6,7 @@ namespace Pest\Concerns;
 
 use Closure;
 use Pest\Exceptions\DatasetArgumentsMismatch;
+use Pest\Preset;
 use Pest\Support\ChainableClosure;
 use Pest\Support\ExceptionTrace;
 use Pest\Support\Reflection;
@@ -410,6 +411,14 @@ trait Testable
         return ExceptionTrace::ensure(fn (): mixed => call_user_func_array(Closure::bind($closure, $this, $this::class), $arguments));
     }
 
+    /**
+     * Uses the given preset on the test.
+     */
+    public function preset(): Preset
+    {
+        return new Preset;
+    }
+
     #[PostCondition]
     protected function __MarkTestIncompleteIfSnapshotHaveChanged(): void
     {

src/Configuration.php

@@ -86,6 +86,14 @@ final readonly class Configuration
         return new Configuration\Theme;
     }
 
+    /**
+     * Gets the presets configuration.
+     */
+    public function presets(): Configuration\Presets
+    {
+        return new Configuration\Presets;
+    }
+
     /**
      * Gets the project configuration.
      */

src/Configuration/Presets.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Configuration;
+
+use Closure;
+use Pest\Preset;
+
+final class Presets
+{
+    /**
+     * Creates a custom preset instance, and adds it to the list of presets.
+     */
+    public function custom(string $name, Closure $execute): void
+    {
+        Preset::custom($name, $execute);
+    }
+}

src/PendingCalls/TestCall.php

@@ -12,7 +12,6 @@ use Pest\Factories\TestCaseMethodFactory;
 use Pest\Mutate\Decorators\TestCallDecorator as MutationTestCallDecorator;
 use Pest\PendingCalls\Concerns\Describable;
 use Pest\Plugins\Only;
-use Pest\Preset;
 use Pest\Support\Backtrace;
 use Pest\Support\Exporter;
 use Pest\Support\HigherOrderCallables;
@@ -663,12 +662,4 @@ final class TestCall
             $testCase->attributes = array_merge($testCase->attributes, $this->testCaseFactoryAttributes);
         }
     }
-
-    /**
-     * Uses the given preset on the test.
-     */
-    public function preset(): Preset
-    {
-        return new Preset($this);
-    }
 }

src/Preset.php

@@ -4,13 +4,16 @@ declare(strict_types=1);
 
 namespace Pest;
 
+use Closure;
 use Pest\Arch\Support\Composer;
 use Pest\ArchPresets\AbstractPreset;
+use Pest\ArchPresets\Custom;
 use Pest\ArchPresets\Laravel;
 use Pest\ArchPresets\Php;
 use Pest\ArchPresets\Relaxed;
 use Pest\ArchPresets\Security;
 use Pest\ArchPresets\Strict;
+use Pest\Exceptions\InvalidArgumentException;
 use Pest\PendingCalls\TestCall;
 use stdClass;
 
@@ -26,10 +29,17 @@ final class Preset
      */
     private static ?array $baseNamespaces = null;
 
+    /**
+     * The custom presets.
+     *
+     * @var array<string, Closure>
+     */
+    private static array $customPresets = [];
+
     /**
      * Creates a new preset instance.
      */
-    public function __construct(private readonly TestCall $testCall)
+    public function __construct()
     {
         //
     }
@@ -74,6 +84,41 @@ final class Preset
         return $this->executePreset(new Relaxed($this->baseNamespaces()));
     }
 
+    /**
+     * Uses the Pest custom preset and returns the test call instance.
+     *
+     * @internal
+     */
+    public static function custom(string $name, Closure $execute): void
+    {
+        if (preg_match('/^[a-zA-Z]+$/', $name) === false) {
+            throw new InvalidArgumentException('The preset name must only contain words from a-z or A-Z.');
+        }
+
+        self::$customPresets[$name] = $execute;
+    }
+
+    /**
+     * Dynamically handle calls to the class.
+     *
+     * @param  array<int, mixed>  $arguments
+     *
+     * @throws InvalidArgumentException
+     */
+    public function __call(string $name, array $arguments): AbstractPreset
+    {
+        if (! array_key_exists($name, self::$customPresets)) {
+            $availablePresets = [
+                ...['php', 'laravel', 'strict', 'security', 'relaxed'],
+                ...array_keys(self::$customPresets),
+            ];
+
+            throw new InvalidArgumentException(sprintf('The preset [%s] does not exist. The available presets are [%s].', $name, implode(', ', $availablePresets)));
+        }
+
+        return $this->executePreset(new Custom($this->baseNamespaces(), $name, self::$customPresets[$name]));
+    }
+
     /**
      * Executes the given preset.
      *
@@ -84,19 +129,13 @@ final class Preset
      */
     private function executePreset(AbstractPreset $preset): AbstractPreset
     {
-        if ((fn (): ?string => $this->description)->call($this->testCall) === null) {
-            $description = strtolower((new \ReflectionClass($preset))->getShortName());
-
-            (fn (): string => $this->description = sprintf('arch "%s" preset', $description))->call($this->testCall);
-        }
-
         $this->baseNamespaces();
 
         $preset->execute();
 
-        $this->testCall->testCaseMethod->closure = (function () use ($preset): void {
-            $preset->flush();
-        })->bindTo(new stdClass);
+        // $this->testCall->testCaseMethod->closure = (function () use ($preset): void {
+        //    $preset->flush();
+        // })->bindTo(new stdClass);
 
         return $preset;
     }