20561245963

Committed 28 Dec 2025 11:47PM UTC coverage: 82.276% (-0.2%) from 82.434%

Build # 20561245963

Build Type

push

github

Committed by

Commit Message

composer: calls Tester with the -C parameter

A pragmatic decision - I do not know how to set extension_dir in a cross-platform way

Run Details

1959 of 2381 relevant lines covered (82.28%)

0.82 hits per line

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

72.41

/src/Application/MicroPresenter.php

<?php

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

declare(strict_types=1);

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,
        ) {
        }


        /**
         * Gets the context.
         */
        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(...array_values($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;
                }
        }


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

nette / application / 20561245963

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