ServiceProvider::publishThrowableCaughtHandler() - Code Metrics - Inspection of "Config update" - valkyrjaio/valkyrja - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#38)

by Melech

created 2025-07-02 03:51 UTC

ServiceProvider::publishThrowableCaughtHandler() A

↳ Parent: ServiceProvider

Complexity

Conditions	1
Paths	1

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	6
dl	0
loc	12
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1

<?php

declare(strict_types=1);

/*
 * This file is part of the Valkyrja Framework package.
 *
 * (c) Melech Mizrachi <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Valkyrja\Cli\Middleware\Provider;

use Valkyrja\Application\Env;
filter:
    dependency_paths: ["lib/*"]
use Valkyrja\Cli\Middleware\Contract\CommandDispatchedMiddleware;
use Valkyrja\Cli\Middleware\Contract\CommandMatchedMiddleware;
use Valkyrja\Cli\Middleware\Contract\CommandNotMatchedMiddleware;
use Valkyrja\Cli\Middleware\Contract\ExitedMiddleware;
use Valkyrja\Cli\Middleware\Contract\InputReceivedMiddleware;
use Valkyrja\Cli\Middleware\Contract\ThrowableCaughtMiddleware;
use Valkyrja\Cli\Middleware\Handler;
use Valkyrja\Cli\Middleware\Handler\Contract\CommandDispatchedHandler;
use Valkyrja\Cli\Middleware\Handler\Contract\CommandMatchedHandler;
use Valkyrja\Cli\Middleware\Handler\Contract\CommandNotMatchedHandler;
use Valkyrja\Cli\Middleware\Handler\Contract\ExitedHandler;
use Valkyrja\Cli\Middleware\Handler\Contract\InputReceivedHandler;
use Valkyrja\Cli\Middleware\Handler\Contract\ThrowableCaughtHandler;
use Valkyrja\Container\Contract\Container;
use Valkyrja\Container\Support\Provider;

/**
 * Class ServiceProvider.
 *
 * @author Melech Mizrachi
 */
final class ServiceProvider extends Provider
{
    /**
     * @inheritDoc
     */
    public static function publishers(): array
    {
        return [
            InputReceivedHandler::class     => [self::class, 'publishInputReceivedHandler'],
            ThrowableCaughtHandler::class   => [self::class, 'publishThrowableCaughtHandler'],
            CommandMatchedHandler::class    => [self::class, 'publishCommandMatchedHandler'],
            CommandNotMatchedHandler::class => [self::class, 'publishCommandNotMatchedHandler'],
            CommandDispatchedHandler::class => [self::class, 'publishCommandDispatchedHandler'],
            ExitedHandler::class            => [self::class, 'publishExitedHandler'],
        ];
    }

    /**
     * @inheritDoc
     */
    public static function provides(): array
    {
        return [
            InputReceivedHandler::class,
            CommandDispatchedHandler::class,
            ThrowableCaughtHandler::class,
            CommandMatchedHandler::class,
            CommandNotMatchedHandler::class,
            ExitedHandler::class,
        ];
    }

    /**
     * Publish the RequestReceivedHandler service.
     *
     * @param Container $container The container
     *
     * @return void
     */
    public static function publishInputReceivedHandler(Container $container): void
    {
        $env = $container->getSingleton(Env::class);
        /** @var class-string<InputReceivedMiddleware>[] $middleware */
        $middleware = $env::CLI_MIDDLEWARE_INPUT_RECEIVED;

        $container->setSingleton(
            InputReceivedHandler::class,
            $handler = new Handler\InputReceivedHandler($container)
        );

        $handler->add(...$middleware);
    }

    /**
     * Publish the RouteDispatchedHandler service.
     *
     * @param Container $container The container
     *
     * @return void
     */
    public static function publishCommandDispatchedHandler(Container $container): void
    {
        $env = $container->getSingleton(Env::class);
        /** @var class-string<CommandDispatchedMiddleware>[] $middleware */
        $middleware = $env::CLI_MIDDLEWARE_COMMAND_DISPATCHED;

        $container->setSingleton(
            CommandDispatchedHandler::class,
            $handler = new Handler\CommandDispatchedHandler($container)
        );

        $handler->add(...$middleware);
    }

    /**
     * Publish the ThrowableCaughtHandler service.
     *
     * @param Container $container The container
     *
     * @return void
     */
    public static function publishThrowableCaughtHandler(Container $container): void
    {
        $env = $container->getSingleton(Env::class);
        /** @var class-string<ThrowableCaughtMiddleware>[] $middleware */
        $middleware = $env::CLI_MIDDLEWARE_THROWABLE_CAUGHT;

        $container->setSingleton(
            ThrowableCaughtHandler::class,
            $handler = new Handler\ThrowableCaughtHandler($container)
        );

        $handler->add(...$middleware);
    }

    /**
     * Publish the RouteMatchedHandler service.
     *
     * @param Container $container The container
     *
     * @return void
     */
    public static function publishCommandMatchedHandler(Container $container): void
    {
        $env = $container->getSingleton(Env::class);
        /** @var class-string<CommandMatchedMiddleware>[] $middleware */
        $middleware = $env::CLI_MIDDLEWARE_COMMAND_MATCHED;

        $container->setSingleton(
            CommandMatchedHandler::class,
            $handler = new Handler\CommandMatchedHandler($container)
        );

        $handler->add(...$middleware);
    }

    /**
     * Publish the RouteNotMatchedHandler service.
     *
     * @param Container $container The container
     *
     * @return void
     */
    public static function publishCommandNotMatchedHandler(Container $container): void
    {
        $env = $container->getSingleton(Env::class);
        /** @var class-string<CommandNotMatchedMiddleware>[] $middleware */
        $middleware = $env::CLI_MIDDLEWARE_COMMAND_NOT_MATCHED;

        $container->setSingleton(
            CommandNotMatchedHandler::class,
            $handler = new Handler\CommandNotMatchedHandler($container)
        );

        $handler->add(...$middleware);
    }

    /**
     * Publish the TerminatedHandler service.
     *
     * @param Container $container The container
     *
     * @return void
     */
    public static function publishExitedHandler(Container $container): void
    {
        $env = $container->getSingleton(Env::class);
        /** @var class-string<ExitedMiddleware>[] $middleware */
        $middleware = $env::CLI_MIDDLEWARE_EXITED;

        $container->setSingleton(
            ExitedHandler::class,
            $handler = new Handler\ExitedHandler($container)
        );

        $handler->add(...$middleware);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Valkyrja Framework package.
7			*
8			* (c) Melech Mizrachi <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Valkyrja\Cli\Middleware\Provider;
15
16			use Valkyrja\Application\Env;
			0 ignored issues – show Bug introduced 2025-07-02 03:57 UTC by Report Bug Copy Issue Report The type `Valkyrja\Application\Env` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
17			use Valkyrja\Cli\Middleware\Contract\CommandDispatchedMiddleware;
18			use Valkyrja\Cli\Middleware\Contract\CommandMatchedMiddleware;
19			use Valkyrja\Cli\Middleware\Contract\CommandNotMatchedMiddleware;
20			use Valkyrja\Cli\Middleware\Contract\ExitedMiddleware;
21			use Valkyrja\Cli\Middleware\Contract\InputReceivedMiddleware;
22			use Valkyrja\Cli\Middleware\Contract\ThrowableCaughtMiddleware;
23			use Valkyrja\Cli\Middleware\Handler;
24			use Valkyrja\Cli\Middleware\Handler\Contract\CommandDispatchedHandler;
25			use Valkyrja\Cli\Middleware\Handler\Contract\CommandMatchedHandler;
26			use Valkyrja\Cli\Middleware\Handler\Contract\CommandNotMatchedHandler;
27			use Valkyrja\Cli\Middleware\Handler\Contract\ExitedHandler;
28			use Valkyrja\Cli\Middleware\Handler\Contract\InputReceivedHandler;
29			use Valkyrja\Cli\Middleware\Handler\Contract\ThrowableCaughtHandler;
30			use Valkyrja\Container\Contract\Container;
31			use Valkyrja\Container\Support\Provider;
32
33			/**
34			* Class ServiceProvider.
35			*
36			* @author Melech Mizrachi
37			*/
38			final class ServiceProvider extends Provider
39			{
40			/**
41			* @inheritDoc
42			*/
43			public static function publishers(): array
44			{
45			return [
46			InputReceivedHandler::class => [self::class, 'publishInputReceivedHandler'],
47			ThrowableCaughtHandler::class => [self::class, 'publishThrowableCaughtHandler'],
48			CommandMatchedHandler::class => [self::class, 'publishCommandMatchedHandler'],
49			CommandNotMatchedHandler::class => [self::class, 'publishCommandNotMatchedHandler'],
50			CommandDispatchedHandler::class => [self::class, 'publishCommandDispatchedHandler'],
51			ExitedHandler::class => [self::class, 'publishExitedHandler'],
52			];
53			}
54
55			/**
56			* @inheritDoc
57			*/
58			public static function provides(): array
59			{
60			return [
61			InputReceivedHandler::class,
62			CommandDispatchedHandler::class,
63			ThrowableCaughtHandler::class,
64			CommandMatchedHandler::class,
65			CommandNotMatchedHandler::class,
66			ExitedHandler::class,
67			];
68			}
69
70			/**
71			* Publish the RequestReceivedHandler service.
72			*
73			* @param Container $container The container
74			*
75			* @return void
76			*/
77			public static function publishInputReceivedHandler(Container $container): void
78			{
79			$env = $container->getSingleton(Env::class);
80			/** @var class-string<InputReceivedMiddleware>[] $middleware */
81			$middleware = $env::CLI_MIDDLEWARE_INPUT_RECEIVED;
82
83			$container->setSingleton(
84			InputReceivedHandler::class,
85			$handler = new Handler\InputReceivedHandler($container)
86			);
87
88			$handler->add(...$middleware);
89			}
90
91			/**
92			* Publish the RouteDispatchedHandler service.
93			*
94			* @param Container $container The container
95			*
96			* @return void
97			*/
98			public static function publishCommandDispatchedHandler(Container $container): void
99			{
100			$env = $container->getSingleton(Env::class);
101			/** @var class-string<CommandDispatchedMiddleware>[] $middleware */
102			$middleware = $env::CLI_MIDDLEWARE_COMMAND_DISPATCHED;
103
104			$container->setSingleton(
105			CommandDispatchedHandler::class,
106			$handler = new Handler\CommandDispatchedHandler($container)
107			);
108
109			$handler->add(...$middleware);
110			}
111
112			/**
113			* Publish the ThrowableCaughtHandler service.
114			*
115			* @param Container $container The container
116			*
117			* @return void
118			*/
119			public static function publishThrowableCaughtHandler(Container $container): void
120			{
121			$env = $container->getSingleton(Env::class);
122			/** @var class-string<ThrowableCaughtMiddleware>[] $middleware */
123			$middleware = $env::CLI_MIDDLEWARE_THROWABLE_CAUGHT;
124
125			$container->setSingleton(
126			ThrowableCaughtHandler::class,
127			$handler = new Handler\ThrowableCaughtHandler($container)
128			);
129
130			$handler->add(...$middleware);
131			}
132
133			/**
134			* Publish the RouteMatchedHandler service.
135			*
136			* @param Container $container The container
137			*
138			* @return void
139			*/
140			public static function publishCommandMatchedHandler(Container $container): void
141			{
142			$env = $container->getSingleton(Env::class);
143			/** @var class-string<CommandMatchedMiddleware>[] $middleware */
144			$middleware = $env::CLI_MIDDLEWARE_COMMAND_MATCHED;
145
146			$container->setSingleton(
147			CommandMatchedHandler::class,
148			$handler = new Handler\CommandMatchedHandler($container)
149			);
150
151			$handler->add(...$middleware);
152			}
153
154			/**
155			* Publish the RouteNotMatchedHandler service.
156			*
157			* @param Container $container The container
158			*
159			* @return void
160			*/
161			public static function publishCommandNotMatchedHandler(Container $container): void
162			{
163			$env = $container->getSingleton(Env::class);
164			/** @var class-string<CommandNotMatchedMiddleware>[] $middleware */
165			$middleware = $env::CLI_MIDDLEWARE_COMMAND_NOT_MATCHED;
166
167			$container->setSingleton(
168			CommandNotMatchedHandler::class,
169			$handler = new Handler\CommandNotMatchedHandler($container)
170			);
171
172			$handler->add(...$middleware);
173			}
174
175			/**
176			* Publish the TerminatedHandler service.
177			*
178			* @param Container $container The container
179			*
180			* @return void
181			*/
182			public static function publishExitedHandler(Container $container): void
183			{
184			$env = $container->getSingleton(Env::class);
185			/** @var class-string<ExitedMiddleware>[] $middleware */
186			$middleware = $env::CLI_MIDDLEWARE_EXITED;
187
188			$container->setSingleton(
189			ExitedHandler::class,
190			$handler = new Handler\ExitedHandler($container)
191			);
192
193			$handler->add(...$middleware);
194			}
195			}
196

valkyrjaio / valkyrja

Pull Request — master (#38)

ServiceProvider::publishThrowableCaughtHandler() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like