TransactionableBus::addHandler() - Code Metrics - Inspection of "Added TransactionableBus" - victormln/laravel-tactician - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d69d84...947776 )

by Víctor

created 2019-06-16 23:29 UTC

TransactionableBus::addHandler() A

↳ Parent: TransactionableBus

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	0
cts	4
cp	0
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	2
crap	2

<?php

namespace Victormln\LaravelTactician;

use ReflectionClass;
use InvalidArgumentException;
use League\Tactician\CommandBus;
use League\Tactician\Plugins\LockingMiddleware;
use League\Tactician\Handler\CommandHandlerMiddleware;
use Victormln\LaravelTactician\Exceptions\CommandHandlerNotExists;
use Victormln\LaravelTactician\Locator\LocatorInterface;
use League\Tactician\Handler\MethodNameInflector\MethodNameInflector;
use League\Tactician\Handler\CommandNameExtractor\CommandNameExtractor;
use Victormln\LaravelTactician\Middleware\DatabaseTransactions;

/**
 * The default Command bus Using Tactician, this is an implementation to dispatch commands to their handlers trough a middleware stack, every class is resolved from the laravel's service container.
 *
 * @package Victormln\LaravelTactician
 */
class TransactionableBus implements CommandBusInterface
{

    /** @var CommandBus */
    protected $bus;

    /** @var CommandNameExtractor */
    protected $commandNameExtractor;

    /** @var MethodNameInflector */
    protected $methodNameInflector;

    /** @var LocatorInterface */
    protected $handlerLocator;

    public function __construct(
        MethodNameInflector $MethodNameInflector,
        CommandNameExtractor $CommandNameExtractor,
        LocatorInterface $HandlerLocator
    ) {
        $this->methodNameInflector = $MethodNameInflector;
        $this->commandNameExtractor = $CommandNameExtractor;
        $this->handlerLocator = $HandlerLocator;
    }

    /**
     * Dispatch a command
     *
     * @param  object $command    Command to be dispatched
     * @param  array  $input      Array of input to map to the command
     * @param  array  $middleware Array of middleware class name to add to the stack, they are resolved from the laravel container
     * @throws CommandHandlerNotExists
     * @return mixed
     */
    public function dispatch($command, array $input = [], array $middleware = [])
    {
        $this->bindCommandWitHisCommandHandler($command);

        return $this->handleTheCommand($command, $input, $middleware);
    }

    private function bindCommandWitHisCommandHandler($command)
    {
        $commandFullName = $this->getNameOfClass($command);
        $commandHandlerFullName = $commandFullName . 'Handler';
        if(!class_exists($commandHandlerFullName)) {

            throw CommandHandlerNotExists::with($commandHandlerFullName);
        }

        $this->addHandler($commandFullName, $commandHandlerFullName);
    }

    /**
     * @param $command
     * @return string
     */
    private function getNameOfClass($command): string
    {
        if(\is_string($command)) {

            return $command;
        }

        $reflectionCommand = new \ReflectionObject($command);

        return $reflectionCommand->getNamespaceName() . '\\' . $reflectionCommand->getShortName();
    }

    /**
     * Add the Command Handler
     *
     * @param  string $command Class name of the command
     * @param  string $handler Class name of the handler to be resolved from the Laravel Container
     * @return mixed
     */
    public function addHandler($command, $handler)
    {
        $this->handlerLocator->addHandler($handler, $command);
    }

    /**
     * Handle the command
     *
     * @param  $command
     * @param  $input
     * @param  $middleware
     * @return mixed
     */
    protected function handleTheCommand($command, $input, array $middleware)
    {
        $this->bus = new CommandBus(
            array_merge(
                [new DatabaseTransactions()],
                [new LockingMiddleware()],
                $this->resolveMiddleware($middleware),
                [new CommandHandlerMiddleware($this->commandNameExtractor, $this->handlerLocator, $this->methodNameInflector)]
            )
        );
        return $this->bus->handle($this->mapInputToCommand($command, $input));
    }

    /**
     * Resolve the middleware stack from the laravel container
     *
     * @param  $middleware
     * @return array
     */
    protected function resolveMiddleware(array $middleware)
    {
        $m = [];
        foreach ($middleware as $class) {
            $m[] = app($class);
        }

        return $m;
    }

    /**
     * Map the input to the command
     *
     * @param  $command
     * @param  $input
     * @return object
     */
    protected function mapInputToCommand($command, $input)
    {
        if (is_object($command)) {
            return $command;
        }
        $dependencies = [];
        $class = new ReflectionClass($command);
        foreach ($class->getConstructor()->getParameters() as $parameter) {
            if ( $parameter->getPosition() == 0 && $parameter->isArray() ) {

                if ($input !== []) {
                    $dependencies[] = $input;
                } else {
                    $dependencies[] = $this->getDefaultValueOrFail($parameter);
                }
            } else {
                $name = $parameter->getName();
                if (array_key_exists($name, $input)) {
                    $dependencies[] = $input[$name];
                } else {
                    $dependencies[] = $this->getDefaultValueOrFail($parameter);
                }
            }
        }

        return $class->newInstanceArgs($dependencies);
    }

    /**
     * Returns Default Value for parameter if it exists Or Fail
     *
     * @ReflectionParameter $parameter
     * @return mixed
     */
    private function getDefaultValueOrFail($parameter)
    {
        if (! $parameter->isDefaultValueAvailable()) {
            throw new InvalidArgumentException("Unable to map input to command: {$parameter->getName()}");
        }

        return $parameter->getDefaultValue();
    }

}


1			<?php
2
3			namespace Victormln\LaravelTactician;
4
5			use ReflectionClass;
6			use InvalidArgumentException;
7			use League\Tactician\CommandBus;
8			use League\Tactician\Plugins\LockingMiddleware;
9			use League\Tactician\Handler\CommandHandlerMiddleware;
10			use Victormln\LaravelTactician\Exceptions\CommandHandlerNotExists;
11			use Victormln\LaravelTactician\Locator\LocatorInterface;
12			use League\Tactician\Handler\MethodNameInflector\MethodNameInflector;
13			use League\Tactician\Handler\CommandNameExtractor\CommandNameExtractor;
14			use Victormln\LaravelTactician\Middleware\DatabaseTransactions;
15
16			/**
17			* The default Command bus Using Tactician, this is an implementation to dispatch commands to their handlers trough a middleware stack, every class is resolved from the laravel's service container.
18			*
19			* @package Victormln\LaravelTactician
20			*/
21			class TransactionableBus implements CommandBusInterface
22			{
23
24			/** @var CommandBus */
25			protected $bus;
26
27			/** @var CommandNameExtractor */
28			protected $commandNameExtractor;
29
30			/** @var MethodNameInflector */
31			protected $methodNameInflector;
32
33			/** @var LocatorInterface */
34			protected $handlerLocator;
35
36			public function __construct(
37			MethodNameInflector $MethodNameInflector,
38			CommandNameExtractor $CommandNameExtractor,
39			LocatorInterface $HandlerLocator
40			) {
41			$this->methodNameInflector = $MethodNameInflector;
42			$this->commandNameExtractor = $CommandNameExtractor;
43			$this->handlerLocator = $HandlerLocator;
44			}
45
46			/**
47			* Dispatch a command
48			*
49			* @param object $command Command to be dispatched
50			* @param array $input Array of input to map to the command
51			* @param array $middleware Array of middleware class name to add to the stack, they are resolved from the laravel container
52			* @throws CommandHandlerNotExists
53			* @return mixed
54			*/
55			public function dispatch($command, array $input = [], array $middleware = [])
56			{
57			$this->bindCommandWitHisCommandHandler($command);
58
59			return $this->handleTheCommand($command, $input, $middleware);
60			}
61
62			private function bindCommandWitHisCommandHandler($command)
63			{
64			$commandFullName = $this->getNameOfClass($command);
65			$commandHandlerFullName = $commandFullName . 'Handler';
66			if(!class_exists($commandHandlerFullName)) {
			0 ignored issues – show Coding Style introduced 2019-06-16 23:31 UTC by Report Bug Copy Issue Report Expected 1 space after IF keyword; 0 found Loading history...
67			throw CommandHandlerNotExists::with($commandHandlerFullName);
68			}
69
70			$this->addHandler($commandFullName, $commandHandlerFullName);
71			}
72
73			/**
74			* @param $command
75			* @return string
76			*/
77			private function getNameOfClass($command): string
78			{
79			if(\is_string($command)) {
			0 ignored issues – show Coding Style introduced 2019-06-16 23:31 UTC by Report Bug Copy Issue Report Expected 1 space after IF keyword; 0 found Loading history...
80			return $command;
81			}
82
83			$reflectionCommand = new \ReflectionObject($command);
84
85			return $reflectionCommand->getNamespaceName() . '\\' . $reflectionCommand->getShortName();
86			}
87
88			/**
89			* Add the Command Handler
90			*
91			* @param string $command Class name of the command
92			* @param string $handler Class name of the handler to be resolved from the Laravel Container
93			* @return mixed
94			*/
95			public function addHandler($command, $handler)
96			{
97			$this->handlerLocator->addHandler($handler, $command);
98			}
99
100			/**
101			* Handle the command
102			*
103			* @param $command
104			* @param $input
105			* @param $middleware
106			* @return mixed
107			*/
108			protected function handleTheCommand($command, $input, array $middleware)
109			{
110			$this->bus = new CommandBus(
111			array_merge(
112			[new DatabaseTransactions()],
113			[new LockingMiddleware()],
114			$this->resolveMiddleware($middleware),
115			[new CommandHandlerMiddleware($this->commandNameExtractor, $this->handlerLocator, $this->methodNameInflector)]
116			)
117			);
118			return $this->bus->handle($this->mapInputToCommand($command, $input));
119			}
120
121			/**
122			* Resolve the middleware stack from the laravel container
123			*
124			* @param $middleware
125			* @return array
126			*/
127			protected function resolveMiddleware(array $middleware)
128			{
129			$m = [];
130			foreach ($middleware as $class) {
131			$m[] = app($class);
132			}
133
134			return $m;
135			}
136
137			/**
138			* Map the input to the command
139			*
140			* @param $command
141			* @param $input
142			* @return object
143			*/
144			protected function mapInputToCommand($command, $input)
145			{
146			if (is_object($command)) {
147			return $command;
148			}
149			$dependencies = [];
150			$class = new ReflectionClass($command);
151			foreach ($class->getConstructor()->getParameters() as $parameter) {
152			if ( $parameter->getPosition() == 0 && $parameter->isArray() ) {
			0 ignored issues – show Coding Style introduced 2019-06-16 23:31 UTC by Report Bug Copy Issue Report Expected 0 spaces before closing bracket; 1 found Loading history...
153			if ($input !== []) {
154			$dependencies[] = $input;
155			} else {
156			$dependencies[] = $this->getDefaultValueOrFail($parameter);
157			}
158			} else {
159			$name = $parameter->getName();
160			if (array_key_exists($name, $input)) {
161			$dependencies[] = $input[$name];
162			} else {
163			$dependencies[] = $this->getDefaultValueOrFail($parameter);
164			}
165			}
166			}
167
168			return $class->newInstanceArgs($dependencies);
169			}
170
171			/**
172			* Returns Default Value for parameter if it exists Or Fail
173			*
174			* @ReflectionParameter $parameter
175			* @return mixed
176			*/
177			private function getDefaultValueOrFail($parameter)
178			{
179			if (! $parameter->isDefaultValueAvailable()) {
180			throw new InvalidArgumentException("Unable to map input to command: {$parameter->getName()}");
181			}
182
183			return $parameter->getDefaultValue();
184			}
185
186			}
187

victormln / laravel-tactician

Push — master ( d69d84...947776 )

TransactionableBus::addHandler() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like