Merge pull request #141 from michaelhrivnak/add-with-trashed-attribute

Added WithTrashed attribute
spatie · Apr 24, 2024 · f201355 · f201355
2 parents 8831b1e + f37b602
commit f201355
Show file tree

Hide file tree

Showing 7 changed files with 169 additions and 4 deletions.
diff --git a/README.md b/README.md
@@ -556,6 +556,46 @@ Route::get('my-default-route/{param?}/{param2?}/{param3?}', [MyController::class
 Route::get('my-override-route/{param?}', [MyController::class, 'myOverrideMethod'])->setDefaults(['param', 'method-default']);
 ```
 
+### With Trashed
+
+You can use the `WithTrashed` annotation on a class or method to enable WithTrashed bindings to the model.
+You can explicitly override the behaviour using `WithTrashed(false)` if it is applied at the class level
+
+```php
+use Spatie\RouteAttributes\Attributes\Get;
+use Spatie\RouteAttributes\Attributes\Post;
+use Spatie\RouteAttributes\Attributes\WithTrashed;
+
+#[WithTrashed]
+class MyController extends Controller
+{
+    #[Get('my-get-route/{param}')]
+    #[WithTrashed]
+    public function myGetMethod($param)
+    {
+    }
+
+    #[Post('my-post-route/{param}')]
+    #[WithTrashed(false)]    
+    public function myPostMethod($param)
+    {
+    }
+
+    #[Get('my-default-route/{param}')]
+    public function myDefaultMethod($param)
+    {
+    }    
+}
+```
+These annotations will automatically register these routes:
+
+```php
+Route::get('my-get-route/{param}', [MyController::class, 'myGetMethod'])->WithTrashed();
+Route::post('my-post-route/{param}', [MyController::class, 'myPostMethod'])->withTrashed(false);
+Route::get('my-default-route/{param}', [MyController::class, 'myDefaultMethod'])->withTrashed();
+```
+
+
 ## Testing
 
 ``` bash

diff --git a/src/Attributes/WithTrashed.php b/src/Attributes/WithTrashed.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace Spatie\RouteAttributes\Attributes;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_CLASS )]
+class WithTrashed implements RouteAttribute
+{
+    public bool $withTrashed;
+
+    public function __construct(bool $withTrashed = true)
+    {
+        $this->withTrashed = $withTrashed;
+    }
+}
diff --git a/src/ClassRouteAttributes.php b/src/ClassRouteAttributes.php
@@ -13,6 +13,7 @@
 use Spatie\RouteAttributes\Attributes\RouteAttribute;
 use Spatie\RouteAttributes\Attributes\ScopeBindings;
 use Spatie\RouteAttributes\Attributes\Where;
+use Spatie\RouteAttributes\Attributes\WithTrashed;
 
 class ClassRouteAttributes
 {
@@ -236,6 +237,19 @@ public function defaults(): array
         return $defaults;
     }
 
+    /**
+     * @psalm-suppress NoInterfaceProperties
+     */
+    public function withTrashed() : bool
+    {
+        /** @var ?WithTrashed $attribute */
+        if (! $attribute = $this->getAttribute(WithTrashed::class)) {
+            return false;
+        }
+
+        return $attribute->withTrashed;
+    }
+
     protected function getAttribute(string $attributeClass): ?RouteAttribute
     {
         $attributes = $this->class->getAttributes($attributeClass, \ReflectionAttribute::IS_INSTANCEOF);

diff --git a/src/RouteRegistrar.php b/src/RouteRegistrar.php
@@ -13,6 +13,7 @@
 use Spatie\RouteAttributes\Attributes\RouteAttribute;
 use Spatie\RouteAttributes\Attributes\ScopeBindings;
 use Spatie\RouteAttributes\Attributes\WhereAttribute;
+use Spatie\RouteAttributes\Attributes\WithTrashed;
 use SplFileInfo;
 use Symfony\Component\Finder\Finder;
 use Throwable;
@@ -139,7 +140,7 @@ protected function registerResource(ReflectionClass $class, ClassRouteAttributes
     protected function registerRoutes(ReflectionClass $class, ClassRouteAttributes $classRouteAttributes): void
     {
         foreach ($class->getMethods() as $method) {
-            list($attributes, $wheresAttributes, $defaultAttributes, $fallbackAttributes, $scopeBindingsAttribute) = $this->getAttributesForTheMethod($method);
+            list($attributes, $wheresAttributes, $defaultAttributes, $fallbackAttributes, $scopeBindingsAttribute, $withTrashedAttribute) = $this->getAttributesForTheMethod($method);
 
 
             foreach ($attributes as $attribute) {
@@ -171,6 +172,8 @@ protected function registerRoutes(ReflectionClass $class, ClassRouteAttributes $
 
                 $this->addMiddlewareToRoute($classRouteAttributes, $attributeClass, $route);
 
+                $this->setWithTrashedIfAvailable($classRouteAttributes, $withTrashedAttribute, $route);
+
 
                 if (count($fallbackAttributes) > 0) {
                     $route->fallback();
@@ -209,8 +212,9 @@ public function getAttributesForTheMethod(\ReflectionMethod $method): array
         $defaultAttributes = $method->getAttributes(Defaults::class, ReflectionAttribute::IS_INSTANCEOF);
         $fallbackAttributes = $method->getAttributes(Fallback::class, ReflectionAttribute::IS_INSTANCEOF);
         $scopeBindingsAttribute = $method->getAttributes(ScopeBindings::class, ReflectionAttribute::IS_INSTANCEOF)[0] ?? null;
+        $withTrashedAttribute = $method->getAttributes(WithTrashed::class, ReflectionAttribute::IS_INSTANCEOF)[0] ?? null;
 
-        return [$attributes, $wheresAttributes, $defaultAttributes, $fallbackAttributes, $scopeBindingsAttribute];
+        return [$attributes, $wheresAttributes, $defaultAttributes, $fallbackAttributes, $scopeBindingsAttribute, $withTrashedAttribute];
     }
 
     /**
@@ -277,6 +281,29 @@ public function setDefaultsIfAvailable(ClassRouteAttributes $classRouteAttribute
         }
     }
 
+    /**
+     * @param ClassRouteAttributes $classRouteAttributes
+     * @param ReflectionAttribute|null $withTrashedAttribute
+     * @param \Illuminate\Routing\Route $route
+     * @return void
+     */
+    public function setWithTrashedIfAvailable(ClassRouteAttributes $classRouteAttributes, ?ReflectionAttribute $withTrashedAttribute, \Illuminate\Routing\Route $route): void
+    {
+        $withTrashed = $classRouteAttributes->withTrashed();
+
+
+        if($withTrashedAttribute !== null)
+        {
+            /** @var WithTrashed $instance */
+            $instance = $withTrashedAttribute->newInstance();
+            $route->withTrashed($instance->withTrashed);
+        }
+        else
+        {
+            $route->withTrashed($withTrashed);
+        }
+    }
+
     /**
      * @param ReflectionClass $class
      * @param ClassRouteAttributes $classRouteAttributes

diff --git a/tests/AttributeTests/WithTrashedAttributeTest.php b/tests/AttributeTests/WithTrashedAttributeTest.php
@@ -0,0 +1,42 @@
+<?php
+
+namespace AttributeTests;
+
+use Spatie\RouteAttributes\Tests\TestCase;
+use Spatie\RouteAttributes\Tests\TestClasses\Controllers\WithTrashedTestController;
+
+class WithTrashedAttributeTest extends TestCase
+{
+    /** @test */
+    public function it_can_apply_with_trashed_on_a_controller(): void
+    {
+        $this->routeRegistrar->registerClass(WithTrashedTestController::class);
+
+        $this
+            ->assertRegisteredRoutesCount(3)
+            ->assertRouteRegistered(
+                WithTrashedTestController::class,
+                controllerMethod: 'withTrashedRoute',
+                httpMethods: 'get',
+                uri: 'with-trashed-test-method/{param}',
+                withTrashed: true,
+
+            )
+            ->assertRouteRegistered(
+                WithTrashedTestController::class,
+                controllerMethod: 'withoutTrashedRoute',
+                httpMethods: 'get',
+                uri: 'with-trashed-test-method-2/{param}',
+                withTrashed: false,
+            )
+            // registered through
+            ->assertRouteRegistered(
+                WithTrashedTestController::class,
+                controllerMethod: 'noWithTrashedAttributeRoute',
+                httpMethods: 'get',
+                uri: 'with-trashed-test-method-3/{param}',
+                withTrashed: true,
+            )
+        ;
+    }
+}
diff --git a/tests/TestCase.php b/tests/TestCase.php
@@ -51,14 +51,15 @@ public function assertRouteRegistered(
         ?bool $isFallback = false,
         ?bool $enforcesScopedBindings = false,
         ?bool $preventsScopedBindings = false,
-        ?array $defaults = []
+        ?array $defaults = [],
+        ?bool $withTrashed = false,
     ): self {
         if (! is_array($middleware)) {
             $middleware = Arr::wrap($middleware);
         }
 
         $routeRegistered = collect($this->getRouteCollection()->getRoutes())
-            ->contains(function (Route $route) use ($name, $middleware, $controllerMethod, $controller, $uri, $httpMethods, $domain, $wheres, $isFallback, $enforcesScopedBindings, $preventsScopedBindings, $defaults) {
+            ->contains(function (Route $route) use ($name, $middleware, $controllerMethod, $controller, $uri, $httpMethods, $domain, $wheres, $isFallback, $enforcesScopedBindings, $preventsScopedBindings, $defaults, $withTrashed) {
                 foreach (Arr::wrap($httpMethods) as $httpMethod) {
                     if (! in_array(strtoupper($httpMethod), $route->methods)) {
                         return false;
@@ -111,6 +112,10 @@ public function assertRouteRegistered(
                     return false;
                 }
 
+                if($route->allowsTrashedBindings() !== $withTrashed){
+                    return false;
+                }
+
                 return true;
             });
 

diff --git a/tests/TestClasses/Controllers/WithTrashedTestController.php b/tests/TestClasses/Controllers/WithTrashedTestController.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Spatie\RouteAttributes\Tests\TestClasses\Controllers;
+
+use Spatie\RouteAttributes\Attributes\Get;
+use Spatie\RouteAttributes\Attributes\WithTrashed;
+
+#[WithTrashed]
+class WithTrashedTestController
+{
+    #[Get('with-trashed-test-method/{param}')]
+    #[WithTrashed]
+    public function withTrashedRoute() {}
+
+    #[Get('with-trashed-test-method-2/{param}')]
+    #[WithTrashed(false)]
+    public function withoutTrashedRoute() {}
+
+    #[Get('with-trashed-test-method-3/{param}')]
+    public function noWithTrashedAttributeRoute() {}
+}