5222546235

pending completion

Build # 5222546235

Build Type

push

github

Committed by

f3l1x

Commit Message

initial commit

Run Details

69 of 69 new or added lines in 5 files covered. (100.0%)

45 of 69 relevant lines covered (65.22%)

0.65 hits per line

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

90.0

/src/DI/FrameXExtension.php

<?php declare(strict_types = 1);

namespace Contributte\FrameX\DI;

use Contributte\FrameX\Application;
use Contributte\FrameX\Bridge\NetteInteropContainer;
use Contributte\FrameX\Middleware\CorsMiddleware;
use Contributte\FrameX\Middleware\TracyMiddleware;
use Nette\DI\CompilerExtension;
use Nette\DI\Definitions\Statement;
use Nette\DI\Helpers;
use Nette\Schema\Expect;
use Nette\Schema\Schema;
use stdClass;

/**
 * @method stdClass getConfig()
 */
class FrameXExtension extends CompilerExtension
{

        public const MIDDLEWARE_TAG = 'contributte.framex.middleware';

        public const DEFAULT_MIDDLEWARES = [
                'tracy' => [TracyMiddleware::class, ['%debugMode%']],
                'cors' => [CorsMiddleware::class],
        ];

        public function getConfigSchema(): Schema
        {
                $expectService = Expect::anyOf(
                        Expect::string()->required()->assert(fn ($input) => str_starts_with($input, '@') || class_exists($input) || interface_exists($input)),
                        Expect::type(Statement::class),
                )->required();

                return Expect::structure([
                        'middlewares' => Expect::anyOf(
                                Expect::null(),
                                Expect::arrayOf(
                                        $expectService,
                                        Expect::string()->required(),
                                )
                        ),
                        'routing' => Expect::array(
                                Expect::structure([
                                        'method' => Expect::string()->required(),
                                        'path' => Expect::string()->required(),
                                        'controller' => $expectService,
                                ])->required()
                        )->required(),
                ]);
        }

        public function loadConfiguration(): void
        {
                $config = $this->getConfig();
                $builder = $this->getContainerBuilder();

                $builder->addDefinition($this->prefix('container'))
                        ->setFactory(NetteInteropContainer::class)
                        ->setAutowired(false);

                // Use default middlewares or user defined
                if ($config->middlewares === null) {
                        foreach (self::DEFAULT_MIDDLEWARES as $name => $middleware) {
                                $builder->addDefinition($this->prefix(sprintf('middleware.%s', $name)))
                                        ->setFactory($middleware[0])
                                        ->setArguments(array_map(fn ($item) => Helpers::expand($item, $builder->parameters), $middleware[1] ?? []))
                                        ->setAutowired(false)
                                        ->addTag(self::MIDDLEWARE_TAG, $name);
                        }
                } else {
                        foreach ($config->middlewares as $name => $factory) {
                                $builder->addDefinition($this->prefix(sprintf('middleware.%s', $name)))
                                        ->setFactory($factory)
                                        ->setAutowired(false)
                                        ->addTag(self::MIDDLEWARE_TAG, $name);
                        }
                }

                $builder->addDefinition($this->prefix('application'))
                        ->setFactory(Application::class)
                        ->setArguments([
                                $this->prefix('@container'),
                                array_map(fn (string $service) => $builder->getDefinition($service), array_keys($builder->findByTag(self::MIDDLEWARE_TAG))),
                        ]);
        }

}

1	<?php declare(strict_types = 1);
2
3	namespace Contributte\FrameX\DI;
4
5	use Contributte\FrameX\Application;
6	use Contributte\FrameX\Bridge\NetteInteropContainer;
7	use Contributte\FrameX\Middleware\CorsMiddleware;
8	use Contributte\FrameX\Middleware\TracyMiddleware;
9	use Nette\DI\CompilerExtension;
10	use Nette\DI\Definitions\Statement;
11	use Nette\DI\Helpers;
12	use Nette\Schema\Expect;
13	use Nette\Schema\Schema;
14	use stdClass;
15
16	/**
17	* @method stdClass getConfig()
18	*/
19	class FrameXExtension extends CompilerExtension
20	{
21
22	public const MIDDLEWARE_TAG = 'contributte.framex.middleware';
23
24	public const DEFAULT_MIDDLEWARES = [
25	'tracy' => [TracyMiddleware::class, ['%debugMode%']],
26	'cors' => [CorsMiddleware::class],
27	];
28
29	public function getConfigSchema(): Schema
30	{
31	$expectService = Expect::anyOf(	1✔
32	Expect::string()->required()->assert(fn ($input) => str_starts_with($input, '@') \|\| class_exists($input) \|\| interface_exists($input)),	1✔
33	Expect::type(Statement::class),	1✔
34	)->required();	1✔
35
36	return Expect::structure([	1✔
37	'middlewares' => Expect::anyOf(	1✔
38	Expect::null(),	1✔
39	Expect::arrayOf(	1✔
40	$expectService,	1✔
41	Expect::string()->required(),	1✔
42	)
43	),
44	'routing' => Expect::array(	1✔
45	Expect::structure([	1✔
46	'method' => Expect::string()->required(),	1✔
47	'path' => Expect::string()->required(),	1✔
48	'controller' => $expectService,	1✔
49	])->required()	1✔
50	)->required(),	1✔
51	]);
52	}
53
54	public function loadConfiguration(): void
55	{
56	$config = $this->getConfig();	1✔
57	$builder = $this->getContainerBuilder();	1✔
58
59	$builder->addDefinition($this->prefix('container'))	1✔
60	->setFactory(NetteInteropContainer::class)	1✔
61	->setAutowired(false);	1✔
62
63	// Use default middlewares or user defined
64	if ($config->middlewares === null) {	1✔
65	foreach (self::DEFAULT_MIDDLEWARES as $name => $middleware) {	1✔
66	$builder->addDefinition($this->prefix(sprintf('middleware.%s', $name)))	1✔
67	->setFactory($middleware[0])	1✔
68	->setArguments(array_map(fn ($item) => Helpers::expand($item, $builder->parameters), $middleware[1] ?? []))	1✔
69	->setAutowired(false)	1✔
70	->addTag(self::MIDDLEWARE_TAG, $name);	1✔
71	}
72	} else {
73	foreach ($config->middlewares as $name => $factory) {	1✔
74	$builder->addDefinition($this->prefix(sprintf('middleware.%s', $name)))	×
75	->setFactory($factory)	×
76	->setAutowired(false)	×
77	->addTag(self::MIDDLEWARE_TAG, $name);	×
78	}
79	}
80
81	$builder->addDefinition($this->prefix('application'))	1✔
82	->setFactory(Application::class)	1✔
83	->setArguments([	1✔
84	$this->prefix('@container'),	1✔
85	array_map(fn (string $service) => $builder->getDefinition($service), array_keys($builder->findByTag(self::MIDDLEWARE_TAG))),	1✔
86	]);
87	}	1✔
88
89	}

contributte / framex / 5222546235

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