19974859358

Committed 05 Dec 2025 08:16PM UTC coverage: 88.272% (-0.4%) from 88.72%

Build # 19974859358

Build Type

push

github

Committed by

f3l1x

Commit Message

CI: add PHP 8.5

Run Details

286 of 324 relevant lines covered (88.27%)

0.88 hits per line

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

96.43

/src/DI/ApiRouterExtension.php

<?php declare(strict_types = 1);

namespace Contributte\ApiRouter\DI;

use Contributte\ApiRouter\ApiRoute;
use Contributte\Utils\Annotations;
use Nette\Application\IPresenter;
use Nette\DI\CompilerExtension;
use Nette\DI\ContainerBuilder;
use Nette\DI\Definitions\Definition;
use Nette\DI\Definitions\Statement;
use Nette\PhpGenerator\ClassType as GClassType;
use ReflectionClass;
use ReflectionMethod;

class ApiRouterExtension extends CompilerExtension
{

        private ?Definition $definition = null;

        public function beforeCompile(): void
        {
                $builder = $this->getContainerBuilder();

                $routes = $this->findRoutes($builder);
                $routesStatements = [];

                foreach ($routes as $route) {
                        $routesStatements[] = new Statement(ApiRoute::class . '::fromArray', [$route->toArray()]);
                }

                $this->definition = $builder->addDefinition($this->prefix('resolver'))
                        ->setType(ApiRoutesResolver::class)
                        ->addSetup('prepandRoutes', [$builder->getDefinition('router'), $routesStatements]);
        }

        public function afterCompile(GClassType $class): void
        {
                parent::afterCompile($class);

                $class->getMethod('initialize')->addBody('$this->getService(?);', [$this->definition->getName()]);
        }

        /**
         * @return array<string, ApiRoute[]>
         */
        private function findRoutes(ContainerBuilder $builder): array
        {
                /**
                 * Find all presenters and their routes
                 */
                $presentersDec = $builder->findByType(IPresenter::class);
                $routes = [];

                foreach ($presentersDec as $presenterDec) {
                        $this->findRoutesInPresenter($presenterDec->getType(), $routes);
                }

                /**
                 * Return routes sorted by priority
                 */
                return $this->sortByPriority($routes);
        }

        /**
         * @param array<ApiRoute> $routes
         */
        private function findRoutesInPresenter(string $presenter, array &$routes): void
        {
                $r = new ReflectionClass($presenter);

                $attributes = $r->getAttributes(ApiRoute::class);

                if ($attributes === []) {
                        return;
                }

                $route = $attributes[0]->newInstance();

                /**
                 * Add route to priority-half-sorted list
                 */
                if ($routes !== [] && !$routes[$route->getPriority()]) {
                        $routes[$route->getPriority()] = [];
                }

                $route->setDescription(Annotations::getAnnotation($r, 'description'));

                if (!$route->getPresenter()) {
                        $route->setPresenter(preg_replace('/Presenter$/', '', $r->getShortName()));
                }

                /**
                 * Find apropriate methods
                 */
                foreach ($r->getMethods() as $method_r) {
                        $this->findPresenterMethodRoute($method_r, $routes, $route);
                }

                /**
                 * Add ApiRouter annotated presenter route only if there are some remaining
                 * methods without ApiRouter annotated presenter method
                 */
                if ($route->getMethods() !== []) {
                        $routes[$route->getPriority()][] = $route;
                }
        }

        /**
         * @param array<ApiRoute> $routes
         */
        private function findPresenterMethodRoute(
                ReflectionMethod $method_reflection,
                array &$routes,
                ApiRoute $route
        ): void
        {
                $attributes = $method_reflection->getAttributes(ApiRoute::class);
                $actionRoute = $attributes !== [] ? $attributes[0]->newInstance() : null;

                /**
                 * Get action without that ^action string
                 */
                $action = lcfirst(preg_replace('/^action/', '', $method_reflection->name));

                /**
                 * Route can be defined also for particular action
                 */
                if (!$actionRoute) {
                        $route->setAction($action);

                        return;
                }

                $actionRoute->setDescription(Annotations::getAnnotation($method_reflection, 'description'));

                /**
                 * Action route will inherit presenter name, priority, etc from parent route
                 */
                $actionRoute->setPresenter($actionRoute->getPresenter() ?: $route->getPresenter());
                $actionRoute->setPriority($actionRoute->getPriority() ?: $route->getPriority());
                $actionRoute->setFormat($actionRoute->getFormat() ?: $route->getFormat());
                $actionRoute->setSection($actionRoute->getSection() ?: $route->getSection());
                $actionRoute->setAction($action, $actionRoute->getMethod() ?: null);

                $routes[$route->getPriority()][] = $actionRoute;
        }

        /**
         * @param array<ApiRoute> $routes
         * @return array<ApiRoute>
         */
        private function sortByPriority(array $routes): array
        {
                $return = [];

                foreach ($routes as $priority_routes) {
                        foreach ($priority_routes as $route) {
                                $return[] = $route;
                        }
                }

                return $return;
        }

}

1	<?php declare(strict_types = 1);
2
3	namespace Contributte\ApiRouter\DI;
4
5	use Contributte\ApiRouter\ApiRoute;
6	use Contributte\Utils\Annotations;
7	use Nette\Application\IPresenter;
8	use Nette\DI\CompilerExtension;
9	use Nette\DI\ContainerBuilder;
10	use Nette\DI\Definitions\Definition;
11	use Nette\DI\Definitions\Statement;
12	use Nette\PhpGenerator\ClassType as GClassType;
13	use ReflectionClass;
14	use ReflectionMethod;
15
16	class ApiRouterExtension extends CompilerExtension
17	{
18
19	private ?Definition $definition = null;
20
21	public function beforeCompile(): void
22	{
23	$builder = $this->getContainerBuilder();	1✔
24
25	$routes = $this->findRoutes($builder);	1✔
26	$routesStatements = [];	1✔
27
28	foreach ($routes as $route) {	1✔
29	$routesStatements[] = new Statement(ApiRoute::class . '::fromArray', [$route->toArray()]);	1✔
30	}
31
32	$this->definition = $builder->addDefinition($this->prefix('resolver'))	1✔
33	->setType(ApiRoutesResolver::class)	1✔
34	->addSetup('prepandRoutes', [$builder->getDefinition('router'), $routesStatements]);	1✔
35	}	1✔
36
37	public function afterCompile(GClassType $class): void	1✔
38	{
39	parent::afterCompile($class);	1✔
40
41	$class->getMethod('initialize')->addBody('$this->getService(?);', [$this->definition->getName()]);	1✔
42	}	1✔
43
44	/**
45	* @return array<string, ApiRoute[]>
46	*/
47	private function findRoutes(ContainerBuilder $builder): array	1✔
48	{
49	/**
50	* Find all presenters and their routes
51	*/
52	$presentersDec = $builder->findByType(IPresenter::class);	1✔
53	$routes = [];	1✔
54
55	foreach ($presentersDec as $presenterDec) {	1✔
56	$this->findRoutesInPresenter($presenterDec->getType(), $routes);	1✔
57	}
58
59	/**
60	* Return routes sorted by priority
61	*/
62	return $this->sortByPriority($routes);	1✔
63	}
64
65	/**
66	* @param array<ApiRoute> $routes
67	*/
68	private function findRoutesInPresenter(string $presenter, array &$routes): void	1✔
69	{
70	$r = new ReflectionClass($presenter);	1✔
71
72	$attributes = $r->getAttributes(ApiRoute::class);	1✔
73
74	if ($attributes === []) {	1✔
75	return;	×
76	}
77
78	$route = $attributes[0]->newInstance();	1✔
79
80	/**
81	* Add route to priority-half-sorted list
82	*/
83	if ($routes !== [] && !$routes[$route->getPriority()]) {	1✔
84	$routes[$route->getPriority()] = [];	×
85	}
86
87	$route->setDescription(Annotations::getAnnotation($r, 'description'));	1✔
88
89	if (!$route->getPresenter()) {	1✔
90	$route->setPresenter(preg_replace('/Presenter$/', '', $r->getShortName()));	1✔
91	}
92
93	/**
94	* Find apropriate methods
95	*/
96	foreach ($r->getMethods() as $method_r) {	1✔
97	$this->findPresenterMethodRoute($method_r, $routes, $route);	1✔
98	}
99
100	/**
101	* Add ApiRouter annotated presenter route only if there are some remaining
102	* methods without ApiRouter annotated presenter method
103	*/
104	if ($route->getMethods() !== []) {	1✔
105	$routes[$route->getPriority()][] = $route;	1✔
106	}
107	}	1✔
108
109	/**
110	* @param array<ApiRoute> $routes
111	*/
112	private function findPresenterMethodRoute(	1✔
113	ReflectionMethod $method_reflection,
114	array &$routes,
115	ApiRoute $route
116	): void
117	{
118	$attributes = $method_reflection->getAttributes(ApiRoute::class);	1✔
119	$actionRoute = $attributes !== [] ? $attributes[0]->newInstance() : null;	1✔
120
121	/**
122	* Get action without that ^action string
123	*/
124	$action = lcfirst(preg_replace('/^action/', '', $method_reflection->name));	1✔
125
126	/**
127	* Route can be defined also for particular action
128	*/
129	if (!$actionRoute) {	1✔
130	$route->setAction($action);	1✔
131
132	return;	1✔
133	}
134
135	$actionRoute->setDescription(Annotations::getAnnotation($method_reflection, 'description'));	1✔
136
137	/**
138	* Action route will inherit presenter name, priority, etc from parent route
139	*/
140	$actionRoute->setPresenter($actionRoute->getPresenter() ?: $route->getPresenter());	1✔
141	$actionRoute->setPriority($actionRoute->getPriority() ?: $route->getPriority());	1✔
142	$actionRoute->setFormat($actionRoute->getFormat() ?: $route->getFormat());	1✔
143	$actionRoute->setSection($actionRoute->getSection() ?: $route->getSection());	1✔
144	$actionRoute->setAction($action, $actionRoute->getMethod() ?: null);	1✔
145
146	$routes[$route->getPriority()][] = $actionRoute;	1✔
147	}	1✔
148
149	/**
150	* @param array<ApiRoute> $routes
151	* @return array<ApiRoute>
152	*/
153	private function sortByPriority(array $routes): array	1✔
154	{
155	$return = [];	1✔
156
157	foreach ($routes as $priority_routes) {	1✔
158	foreach ($priority_routes as $route) {	1✔
159	$return[] = $route;	1✔
160	}
161	}
162
163	return $return;	1✔
164	}
165
166	}

contributte / api-router / 19974859358

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