27919019709

Committed 21 Jun 2026 10:08PM UTC coverage: 84.111% (+0.05%) from 84.059%

Build # 27919019709

Build Type

push

github

Committed by

Commit Message

phpstan fix

Coverage Stats

2038 of 2423 relevant lines covered (84.11%)

0.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.41

/src/Application/MicroPresenter.php

<?php declare(strict_types=1);

/**
 * This file is part of the Nette Framework (https://nette.org)
 * Copyright (c) 2004 David Grudl (https://davidgrudl.com)
 */

namespace NetteModule;

use Latte;
use Nette;
use Nette\Application;
use Nette\Application\Responses;
use Nette\Http;
use Nette\Routing\Router;
use function is_array, is_object, is_string;


/**
 * Micro presenter.
 */
final class MicroPresenter implements Application\IPresenter
{
        private ?Application\Request $request;


        public function __construct(
                private readonly ?Nette\DI\Container $context = null,
                private readonly ?Nette\Http\IRequest $httpRequest = null,
                private readonly ?Router $router = null,
        ) {
        }


        public function getContext(): ?Nette\DI\Container
        {
                return $this->context;
        }


        public function run(Application\Request $request): Application\Response
        {
                $this->request = $request;

                if (
                        $this->httpRequest
                        && $this->router
                        && !$this->httpRequest->isAjax()
                        && ($request->isMethod('get') || $request->isMethod('head'))
                ) {
                        $refUrl = $this->httpRequest->getUrl();
                        $url = $this->router->constructUrl($request->toArray(), $refUrl);
                        if ($url !== null && !$refUrl->isEqual($url)) {
                                return new Responses\RedirectResponse($url, Http\IResponse::S301_MovedPermanently);
                        }
                }

                $params = $request->getParameters();
                $callback = $params['callback'] ?? null;
                if (!is_object($callback) || !is_callable($callback)) {
                        throw new Application\BadRequestException('Parameter callback is not a valid closure.');
                }

                $reflection = Nette\Utils\Callback::toReflection($callback);

                if ($this->context) {
                        foreach ($reflection->getParameters() as $param) {
                                $type = $param->getType();
                                if ($type instanceof \ReflectionNamedType && !$type->isBuiltin()) {
                                        $params[$param->getName()] = $this->context->getByType($type->getName(), throw: false);
                                }
                        }
                }

                $params['presenter'] = $this;
                try {
                        $params = Application\UI\ParameterConverter::toArguments($reflection, $params);
                } catch (Nette\InvalidArgumentException $e) {
                        $this->error($e->getMessage());
                }

                $response = $callback(...$params);

                if (is_string($response)) {
                        $response = [$response, []];
                }

                if (is_array($response)) {
                        [$templateSource, $templateParams] = $response;
                        $response = $this->createTemplate()->setParameters($templateParams);
                        if (!$templateSource instanceof \SplFileInfo) {
                                $response->getLatte()->setLoader(new Latte\Loaders\StringLoader);
                        }

                        $response->setFile((string) $templateSource);
                }

                if ($response instanceof Application\UI\Template) {
                        return new Responses\TextResponse($response);
                } else {
                        return $response ?: new Responses\VoidResponse;
                }
        }


        /**
         * Creates a template instance with default variables pre-populated.
         * @param  ?class-string<Application\UI\Template>  $class
         * @param  ?callable(): Latte\Engine  $latteFactory
         */
        public function createTemplate(?string $class = null, ?callable $latteFactory = null): Application\UI\Template
        {
                $latte = $latteFactory
                        ? $latteFactory()
                        : $this->context->getByType(Nette\Bridges\ApplicationLatte\LatteFactory::class)->create();
                $template = $class
                        ? new $class
                        : new Nette\Bridges\ApplicationLatte\DefaultTemplate($latte);

                $template->setParameters($this->request->getParameters());
                $template->presenter = $this;
                $template->context = $this->context;
                if ($this->httpRequest) {
                        $url = $this->httpRequest->getUrl();
                        $template->baseUrl = rtrim($url->getBaseUrl(), '/');
                        $template->basePath = rtrim($url->getBasePath(), '/');
                }

                return $template;
        }


        /**
         * Redirects to another URL.
         */
        public function redirectUrl(string $url, int $httpCode = Http\IResponse::S302_Found): Responses\RedirectResponse
        {
                return new Responses\RedirectResponse($url, $httpCode);
        }


        /**
         * Throws HTTP error.
         * @throws Nette\Application\BadRequestException
         */
        public function error(string $message = '', int $httpCode = Http\IResponse::S404_NotFound): never
        {
                throw new Application\BadRequestException($message, $httpCode);
        }


        public function getRequest(): ?Nette\Application\Request
        {
                return $this->request;
        }
}

1	<?php declare(strict_types=1);
2
3	/**
4	* This file is part of the Nette Framework (https://nette.org)
5	* Copyright (c) 2004 David Grudl (https://davidgrudl.com)
6	*/
7
8	namespace NetteModule;
9
10	use Latte;
11	use Nette;
12	use Nette\Application;
13	use Nette\Application\Responses;
14	use Nette\Http;
15	use Nette\Routing\Router;
16	use function is_array, is_object, is_string;
17
18
19	/**
20	* Micro presenter.
21	*/
22	final class MicroPresenter implements Application\IPresenter
23	{
24	private ?Application\Request $request;
25
26
27	public function __construct(	1✔
28	private readonly ?Nette\DI\Container $context = null,
29	private readonly ?Nette\Http\IRequest $httpRequest = null,
30	private readonly ?Router $router = null,
31	) {
32	}	1✔
33
34
35	public function getContext(): ?Nette\DI\Container
36	{
37	return $this->context;	×
38	}
39
40
41	public function run(Application\Request $request): Application\Response	1✔
42	{
43	$this->request = $request;	1✔
44
45	if (
46	$this->httpRequest	1✔
47	&& $this->router	1✔
48	&& !$this->httpRequest->isAjax()	1✔
49	&& ($request->isMethod('get') \|\| $request->isMethod('head'))	1✔
50	) {
51	$refUrl = $this->httpRequest->getUrl();	×
52	$url = $this->router->constructUrl($request->toArray(), $refUrl);	×
53	if ($url !== null && !$refUrl->isEqual($url)) {	×
54	return new Responses\RedirectResponse($url, Http\IResponse::S301_MovedPermanently);	×
55	}
56	}
57
58	$params = $request->getParameters();	1✔
59	$callback = $params['callback'] ?? null;	1✔
60	if (!is_object($callback) \|\| !is_callable($callback)) {	1✔
61	throw new Application\BadRequestException('Parameter callback is not a valid closure.');	×
62	}
63
64	$reflection = Nette\Utils\Callback::toReflection($callback);	1✔
65
66	if ($this->context) {	1✔
67	foreach ($reflection->getParameters() as $param) {	1✔
68	$type = $param->getType();	1✔
69	if ($type instanceof \ReflectionNamedType && !$type->isBuiltin()) {	1✔
70	$params[$param->getName()] = $this->context->getByType($type->getName(), throw: false);	1✔
71	}
72	}
73	}
74
75	$params['presenter'] = $this;	1✔
76	try {
77	$params = Application\UI\ParameterConverter::toArguments($reflection, $params);	1✔
78	} catch (Nette\InvalidArgumentException $e) {	×
79	$this->error($e->getMessage());	×
80	}
81
82	$response = $callback(...$params);	1✔
83
84	if (is_string($response)) {	1✔
85	$response = [$response, []];	1✔
86	}
87
88	if (is_array($response)) {	1✔
89	[$templateSource, $templateParams] = $response;	1✔
90	$response = $this->createTemplate()->setParameters($templateParams);	1✔
91	if (!$templateSource instanceof \SplFileInfo) {	1✔
92	$response->getLatte()->setLoader(new Latte\Loaders\StringLoader);	1✔
93	}
94
95	$response->setFile((string) $templateSource);	1✔
96	}
97
98	if ($response instanceof Application\UI\Template) {	1✔
99	return new Responses\TextResponse($response);	1✔
100	} else {
101	return $response ?: new Responses\VoidResponse;	1✔
102	}
103	}
104
105
106	/**
107	* Creates a template instance with default variables pre-populated.
108	* @param ?class-string<Application\UI\Template> $class
109	* @param ?callable(): Latte\Engine $latteFactory
110	*/
111	public function createTemplate(?string $class = null, ?callable $latteFactory = null): Application\UI\Template	1✔
112	{
113	$latte = $latteFactory	1✔
114	? $latteFactory()	1✔
115	: $this->context->getByType(Nette\Bridges\ApplicationLatte\LatteFactory::class)->create();	1✔
116	$template = $class	1✔
117	? new $class	×
118	: new Nette\Bridges\ApplicationLatte\DefaultTemplate($latte);	1✔
119
120	$template->setParameters($this->request->getParameters());	1✔
121	$template->presenter = $this;	1✔
122	$template->context = $this->context;	1✔
123	if ($this->httpRequest) {	1✔
124	$url = $this->httpRequest->getUrl();	×
125	$template->baseUrl = rtrim($url->getBaseUrl(), '/');	×
126	$template->basePath = rtrim($url->getBasePath(), '/');	×
127	}
128
129	return $template;	1✔
130	}
131
132
133	/**
134	* Redirects to another URL.
135	*/
136	public function redirectUrl(string $url, int $httpCode = Http\IResponse::S302_Found): Responses\RedirectResponse
137	{
138	return new Responses\RedirectResponse($url, $httpCode);	×
139	}
140
141
142	/**
143	* Throws HTTP error.
144	* @throws Nette\Application\BadRequestException
145	*/
146	public function error(string $message = '', int $httpCode = Http\IResponse::S404_NotFound): never
147	{
148	throw new Application\BadRequestException($message, $httpCode);	×
149	}	×
150
151
152	public function getRequest(): ?Nette\Application\Request
153	{
154	return $this->request;	×
155	}
156	}

nette / application / 27919019709

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous