Increase template controller DI support

src/Application.php

@@ -162,7 +162,7 @@ public function register($provider)
         }
 
         if (is_string($provider)) {
-            $provider = new $provider($this);
+            $provider = $this->make($provider);
         }
 
         if (method_exists($provider, 'register')) {

src/Bootstrappers/RegisterRequestHandler.php

@@ -13,5 +13,9 @@ public function bootstrap(Application $app)
         if ($config->get('app.debug')) {
             $app->detectWhenRequestHasNotBeenHandled();
         }
+
+        $app->bind(\WP_Query::class, function () {
+            return $GLOBALS['wp_query'];
+        });
     }
 }

src/Exceptions/MismatchedContextException.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Rareloop\Lumberjack\Exceptions;
+
+class MismatchedContextException extends UnresolvableContextException
+{
+    public static function forIncorrectClass(string $expectedClass, mixed $actualValue): self
+    {
+        $actualType = is_object($actualValue) ? $actualValue::class : gettype($actualValue);
+
+        return new static(
+            "Resolved a WordPress object, but it was of type [{$actualType}] " .
+            "instead of the expected [{$expectedClass}]."
+        );
+    }
+}

src/Exceptions/MissingContextException.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Rareloop\Lumberjack\Exceptions;
+
+class MissingContextException extends UnresolvableContextException
+{
+    public static function forType(string $expectedClass, mixed $actualObject): self
+    {
+        $actualType = get_debug_type($actualObject);
+
+        return new static(
+            "Could not resolve context for typehint [{$expectedClass}]. " .
+            "The current WordPress queried object is [{$actualType}]."
+        );
+    }
+}

src/Exceptions/UnresolvableContextException.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace Rareloop\Lumberjack\Exceptions;
+
+use Exception;
+
+class UnresolvableContextException extends Exception
+{
+}

src/Helpers.php

@@ -41,7 +41,12 @@ public static function config($key, $default = null)
 
     public static function view($template, $context = [], $statusCode = 200, $headers = [])
     {
-        return new TimberResponse($template, $context, $statusCode, $headers);
+        return static::app()->make(TimberResponse::class, [
+            'twigTemplate' => $template,
+            'context' => $context,
+            'status' => $statusCode,
+            'headers' => $headers,
+        ]);
     }
 
     public static function route($name, $params = [])

src/Http/Resolvers/AbstractContextResolver.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace Rareloop\Lumberjack\Http\Resolvers;
+
+use Illuminate\Support\Arr;
+use Invoker\ParameterResolver\ParameterResolver;
+use Rareloop\Lumberjack\Exceptions\MismatchedContextException;
+use Rareloop\Lumberjack\Exceptions\MissingContextException;
+use ReflectionFunctionAbstract;
+
+abstract class AbstractContextResolver implements ParameterResolver
+{
+    public function getParameters(
+        ReflectionFunctionAbstract $reflection,
+        array $providedParameters,
+        array $resolvedParameters
+    ): array {
+        foreach ($reflection->getParameters() as $parameter) {
+            if (Arr::has($resolvedParameters, $parameter->getPosition())) {
+                continue;
+            }
+
+            $type = $parameter->getType();
+
+            if (!$type || $type->isBuiltin()) {
+                continue;
+            }
+
+            $className = $type->getName();
+
+            if (!$this->canResolveClass($className)) {
+                continue;
+            }
+
+            try {
+                $context = $this->getContext();
+
+                if (is_null($context)) {
+                    throw MissingContextException::forType($className, $context);
+                }
+
+                if (!$this->isValidContext($context, $className)) {
+                    throw MismatchedContextException::forIncorrectClass($className, $context);
+                }
+
+                $resolvedObject = $this->resolveObject($className, $context);
+
+                if (!is_null($resolvedObject) && !$resolvedObject instanceof $className) {
+                    throw MismatchedContextException::forIncorrectClass($className, $resolvedObject);
+                }
+
+                $resolvedParameters[$parameter->getPosition()] = $resolvedObject;
+            } catch (MissingContextException | MismatchedContextException $e) {
+                // If the context is entirely missing or mismatched, we allow null if the typehint supports it
+                if (!$parameter->allowsNull()) {
+                    throw $e;
+                }
+
+                $resolvedParameters[$parameter->getPosition()] = null;
+            }
+        }
+
+        return $resolvedParameters;
+    }
+
+    /**
+     * Get the raw context object to resolve from (e.g. WP_Post, WP_Term, WP_Query).
+     * Defaults to the current WordPress queried object.
+     *
+     * @return mixed
+     */
+    protected function getContext(): mixed
+    {
+        return get_queried_object();
+    }
+
+    /**
+     * Determine if this resolver can handle the given class type-hint.
+     *
+     * @param string $className
+     * @return bool
+     */
+    abstract protected function canResolveClass(string $className): bool;
+
+    /**
+     * Determine if the current context is valid for this resolver.
+     *
+     * @param mixed $context
+     * @param string $className
+     * @return bool
+     */
+    abstract protected function isValidContext(mixed $context, string $className): bool;
+
+    /**
+     * Build the concrete object instance from the raw context.
+     *
+     * @param string $className
+     * @param mixed $context
+     * @return mixed
+     */
+    abstract protected function resolveObject(string $className, mixed $context): mixed;
+}

src/Http/Resolvers/PostQueryResolver.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace Rareloop\Lumberjack\Http\Resolvers;
+
+use Rareloop\Lumberjack\Application;
+use Timber\PostQuery as TimberPostQuery;
+use Timber\PostCollectionInterface;
+use Timber\Timber;
+use WP_Query;
+
+class PostQueryResolver extends AbstractContextResolver
+{
+    public function __construct(protected Application $app)
+    {
+    }
+
+    protected function canResolveClass(string $className): bool
+    {
+        return is_a($className, TimberPostQuery::class, true)
+            || is_a($className, PostCollectionInterface::class, true);
+    }
+
+    protected function isValidContext(mixed $context, string $className): bool
+    {
+        return is_a($context, WP_Query::class);
+    }
+
+    protected function getContext(): mixed
+    {
+        return $this->app->get(WP_Query::class);
+    }
+
+    protected function resolveObject(string $className, mixed $context): mixed
+    {
+        // If they asked for the interface or the base Timber PostQuery, use the factory
+        if ($className === PostCollectionInterface::class || $className === TimberPostQuery::class) {
+            return Timber::get_posts($context);
+        }
+
+        // If it's a subclass (like Rareloop\Lumberjack\PostQuery), we must instantiate it manually
+        // to ensure we get the correct instance type.
+        return new $className($context);
+    }
+}

src/Http/Resolvers/PostResolver.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Rareloop\Lumberjack\Http\Resolvers;
+
+use Rareloop\Lumberjack\Post;
+use Timber\Post as TimberPost;
+use Timber\Timber;
+use Timber\CoreEntityInterface;
+use WP_Post;
+
+class PostResolver extends AbstractContextResolver
+{
+    protected function canResolveClass(string $className): bool
+    {
+        return is_a($className, Post::class, true)
+            || is_a($className, TimberPost::class, true);
+    }
+
+    protected function isValidContext(mixed $context, string $className): bool
+    {
+        return is_a($context, WP_Post::class) || is_a($context, CoreEntityInterface::class);
+    }
+
+    protected function resolveObject(string $className, mixed $context): mixed
+    {
+        return Timber::get_post($context);
+    }
+}

src/Http/Resolvers/TermResolver.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Rareloop\Lumberjack\Http\Resolvers;
+
+use Rareloop\Lumberjack\Term;
+use Timber\Term as TimberTerm;
+use Timber\Timber;
+use Timber\CoreEntityInterface;
+use WP_Term;
+
+class TermResolver extends AbstractContextResolver
+{
+    protected function canResolveClass(string $className): bool
+    {
+        return is_a($className, Term::class, true) || is_a($className, TimberTerm::class, true);
+    }
+
+    protected function isValidContext(mixed $context, string $className): bool
+    {
+        return is_a($context, WP_Term::class) || is_a($context, CoreEntityInterface::class);
+    }
+
+    protected function resolveObject(string $className, mixed $context): mixed
+    {
+        return Timber::get_term($context);
+    }
+}

src/Http/Resolvers/UserResolver.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Rareloop\Lumberjack\Http\Resolvers;
+
+use Rareloop\Lumberjack\User;
+use Timber\User as TimberUser;
+use Timber\Timber;
+use Timber\CoreEntityInterface;
+use WP_User;
+
+class UserResolver extends AbstractContextResolver
+{
+    protected function canResolveClass(string $className): bool
+    {
+        return is_a($className, User::class, true) || is_a($className, TimberUser::class, true);
+    }
+
+    protected function isValidContext(mixed $context, string $className): bool
+    {
+        return is_a($context, WP_User::class) || is_a($context, CoreEntityInterface::class);
+    }
+
+    protected function resolveObject(string $className, mixed $context): mixed
+    {
+        return Timber::get_user($context);
+    }
+}

src/Http/Responses/TimberResponse.php

@@ -21,14 +21,16 @@ public function __construct($twigTemplate, $context, $status = 200, array $heade
         parent::__construct($template, $status, $headers);
     }
 
-    private function flattenContextToArrays(array $context): array
+    private function flattenContextToArrays(array|Arrayable|CollectionArrayable $context): array
     {
+        $context = is_array($context) ? $context : $context->toArray();
+
         // Recursively walk the array, when we find something that implements the Arrayable interface
         // flatten it to an array. Because we're passing by reference by updating what the value of
         // $item is will mutate the original data structure passed in.
-        array_walk_recursive($context, function (&$item, $key) {
+        array_walk_recursive($context, function (&$item) {
             if ($item instanceof Arrayable || $item instanceof CollectionArrayable) {
-                $item = $this->flattenContextToArrays($item->toArray());
+                $item = $this->flattenContextToArrays($item);
             }
         });