wip

Author: WyattCast44

README.md

@@ -53,14 +53,14 @@ namespace App\Actions;
 
 use App\Models\User;
 use Statix\FormAction\FormAction;
-use Statix\FormAction\Validation\Rule;
+use Statix\FormAction\Validation\Rules;
 
 class ActionName extends FormAction
 {
-    #[Rule(['required', 'string', 'min:3', 'max:255'])] 
+    #[Rules(['required', 'string', 'min:3', 'max:255'])] 
     public $name;
 
-    #[Rule(['email', 'unique:users,email'])] 
+    #[Rules(['email', 'unique:users,email'])] 
     public string $email;
 
     public ?string $timezone;

src/Attributes/Computed.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Statix\FormAction\Attributes;
+
+use Attribute;
+use Statix\FormAction\FormAction;
+use Statix\FormAction\Inspector;
+
+#[Attribute(Attribute::TARGET_PROPERTY)]
+class Computed
+{
+    public function __construct(protected ?string $method = null, protected array $parameters = [])
+    {
+        //
+    }
+
+    public function getResult(FormAction $action, string $property): mixed
+    {
+        $inspector = Inspector::make($action);
+
+        if(is_null($this->method)) {
+            $this->method = 'get'.ucfirst($property).'Property';
+        }
+
+        if (! $inspector->hasMethod($this->method)) {
+            throw new \Exception("The method {$this->method} does not exist on the action.");
+        }
+
+        $method = $inspector->getMethod($this->method);
+
+        $method->setAccessible(true);
+
+        if (! $inspector->doesMethodHaveArguments($this->method)) {
+            $result = $method->invoke($action);
+        } else {
+            $result = $method->invoke($action, ...$this->parameters);
+        }
+
+        $method->setAccessible(false);
+
+        return $result;
+    }
+}

src/Concerns/SupportsComputedAttributeFeatures.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace Statix\FormAction\Concerns;
+
+use Statix\FormAction\Attributes\Computed;
+use Statix\FormAction\FormAction;
+use Statix\FormAction\Inspector;
+
+trait SupportsComputedAttributeFeatures
+{
+    protected $supportComputedProperties = true;
+
+    public function dontSupportComputedProperties(): static
+    {
+        $this->supportComputedProperties = false;
+
+        return $this;
+    }
+
+    public function supportComputedProperties(): static
+    {
+        $this->supportComputedProperties = true;
+
+        return $this;
+    }
+
+    public function bootSupportsComputedAttributeFeatures(): void
+    {
+        if (! $this->supportComputedProperties) {
+            return;
+        }
+
+        // hook into the beforeAuthorization method
+        /** @var FormAction $this */
+        $this->afterValidation(function (FormAction $action) {
+
+            // get the inspector
+            $inspector = Inspector::make($action);
+
+            // get the public properties with the Computed attribute
+            $publicProperties = $inspector->getPublicPropertiesWithAttribute(Computed::class);
+
+            // loop through the public properties
+            foreach ($publicProperties as $property) {
+
+                // get the Computed attribute, it does not allow multiple so we can just get the first one
+
+                /** @var ReflectionAttribute $computed */
+                $computed = $inspector->getPropertyAttributes($property, Computed::class)[0];
+
+                $result = $computed->newInstance()->getResult($action, $inspector->getPropertyName($property));
+
+                // TODO: need to check that the result of the computed attribute is of the correct type and passes validation
+                $inspector->setPropertyValue($property, $result);
+
+            }
+
+        });
+    }
+}

src/Concerns/SupportsPublicPropetyMappingFeatures.php

@@ -3,6 +3,7 @@
 namespace Statix\FormAction\Concerns;
 
 use ReflectionProperty;
+use Statix\FormAction\Attributes\Computed;
 use Statix\FormAction\Inspector;
 
 trait SupportsPublicPropetyMappingFeatures
@@ -41,6 +42,11 @@ public function attemptToMapValidatedDataToPublicProperties(): static
 
             $propertyName = $inspector->getPropertyName($property);
 
+            // skip the property if it has a Computed attribute
+            if ($inspector->doesPropertyHaveAttributes($property, Computed::class)) {
+                continue;
+            }
+
             if (! array_key_exists($propertyName, $validated)) {
                 continue;
             }

src/Concerns/SupportsValidationFeatures.php

@@ -9,7 +9,7 @@
 use ReflectionProperty;
 use Statix\FormAction\FormAction;
 use Statix\FormAction\Inspector;
-use Statix\FormAction\Validation\Rule;
+use Statix\FormAction\Validation\Rules;
 
 trait SupportsValidationFeatures
 {
@@ -237,7 +237,7 @@ private function getRulesFromRuleAttributesOnPublicProperties(): array
 
         $inspector = Inspector::make($this);
 
-        $properties = $inspector->getPublicPropertiesWithAttribute(Rule::class);
+        $properties = $inspector->getPublicPropertiesWithAttribute(Rules::class);
 
         foreach ($properties as $property) {
 
@@ -248,7 +248,7 @@ private function getRulesFromRuleAttributesOnPublicProperties(): array
                 $types = $inspector->getPropertyTypeHints($property);
             }
 
-            $attributes = $inspector->getPropertyAttributes($property, Rule::class);
+            $attributes = $inspector->getPropertyAttributes($property, Rules::class);
 
             foreach ($attributes as $attribute) {
                 /** @var ReflectionAttribute $attribute */

src/FormAction.php

@@ -6,6 +6,7 @@
 use Illuminate\Http\Request;
 use Statix\FormAction\Concerns\InteractsWithTheRequest;
 use Statix\FormAction\Concerns\SupportsAuthorizationFeatures;
+use Statix\FormAction\Concerns\SupportsComputedAttributeFeatures;
 use Statix\FormAction\Concerns\SupportsPublicPropetyMappingFeatures;
 use Statix\FormAction\Concerns\SupportsValidationFeatures;
 use Statix\FormAction\Concerns\SuppportAutomaticAuthorizationValidationOnResolve;
@@ -15,6 +16,7 @@ class FormAction
     use InteractsWithTheRequest,
         SupportsAuthorizationFeatures,
         SupportsValidationFeatures,
+        SupportsComputedAttributeFeatures,
         SupportsPublicPropetyMappingFeatures,
         SuppportAutomaticAuthorizationValidationOnResolve;
 
@@ -25,10 +27,10 @@ public function __construct(protected ?Container $app = null, protected ?Request
         }
 
         if (! $request) {
-            $this->request = request();
+            $request = request();
         }
 
-        $this->setRequest($this->request);
+        $this->setRequest($request);
 
         $this->configure();
 

src/Inspector.php

@@ -4,6 +4,7 @@
 
 use ReflectionClass;
 use ReflectionIntersectionType;
+use ReflectionMethod;
 use ReflectionProperty;
 use ReflectionUnionType;
 
@@ -218,4 +219,28 @@ public function propertyHasTypehints(ReflectionProperty $property): bool
 
         return true;
     }
+
+    public function hasMethod(string $method): bool
+    {
+        return $this->reflector->hasMethod($method);
+    }
+
+    public function getMethod(string $method): ReflectionMethod
+    {
+        return $this->reflector->getMethod($method);
+    }
+
+    public function doesMethodHaveArguments(ReflectionMethod|string $method): bool
+    {
+        if (is_string($method) && ! $this->hasMethod($method)) {
+            return false;
+        }
+
+        if (is_string($method)) {
+            $method = $this->getMethod($method);
+        }
+
+        /** @var ReflectionMethod $method */
+        return $method->getNumberOfParameters() > 0;
+    }
 }

src/Validation/BaseRule.php

@@ -5,10 +5,10 @@
 use Attribute;
 
 #[Attribute(Attribute::IS_REPEATABLE | Attribute::TARGET_PROPERTY)]
-class Rule
+class Rules
 {
     public function __construct(
-        public $rule,
+        public $rules,
         protected $message = null,
     ) {
         //
@@ -17,16 +17,16 @@ public function __construct(
     public function getRules(): array
     {
         // if the rule is already an array, we'll assume it's a list of rules and return it as is
-        if (is_array($this->rule)) {
-            return $this->rule;
+        if (is_array($this->rules)) {
+            return $this->rules;
         }
 
         // if the rule is a string, we'll assume it's a single rule and return it as is
-        if (is_string($this->rule)) {
-            return [$this->rule];
+        if (is_string($this->rules)) {
+            return [$this->rules];
         }
 
         // if the rule is an object, we'll assume it's a rule object and return it as is
-        return [$this->rule];
+        return [$this->rules];
     }
 }

src/Validation/Rule.php renamed to src/Validation/Rules.php

@@ -1,8 +1,8 @@
 <?php
 
-// it('will not use debugging functions')
-//     ->expect(['dd', 'dump', 'ray'])
-//     ->each->not->toBeUsed();
+it('will not use debugging functions')
+    ->expect(['dd', 'dump', 'ray'])
+    ->each->not->toBeUsed();
 
 it('will not use final classes')
     ->expect('src\\')