TacticianServiceProvider::register() - Code Metrics - Atriedes/tactician-service-provider - Measure and Improve Code Quality continuously with Scrutinizer

TacticianServiceProvider::register() C
last analyzed 2016-02-22 15:37 UTC

↳ Parent: TacticianServiceProvider

Complexity

Conditions	8
Paths	16

Size

Total Lines	66
Code Lines	34

Duplication

Lines	0
Ratio	0 %

Importance

Changes	5
Bugs	1	Features	0

Metric	Value
c	5
b	1
f	0
dl	0
loc	66
rs	6.7081
cc	8
eloc	34
nc	16
nop	1

How to fix Long Method

<?php

namespace Silex\Provider;

use League\Tactician\CommandBus;
use League\Tactician\Handler\CommandHandlerMiddleware;
use League\Tactician\Handler\CommandNameExtractor\CommandNameExtractor;
use League\Tactician\Handler\Locator\HandlerLocator;
use League\Tactician\Handler\MethodNameInflector\HandleClassNameInflector;
use League\Tactician\Handler\MethodNameInflector\HandleClassNameWithoutSuffixInflector;
use League\Tactician\Handler\MethodNameInflector\HandleInflector;
use League\Tactician\Handler\MethodNameInflector\InvokeInflector;
use League\Tactician\Handler\MethodNameInflector\MethodNameInflector;
use League\Tactician\Middleware;
use Pimple\Container;
use Pimple\ServiceProviderInterface;
use Silex\Component\Tactician\CommandNameExtractor\Silex as SilexCommandExtractor;
use Silex\Component\Tactician\Locator\Silex as SilexLocator;

/**
 * Class TacticianServiceProvider
 * @package Silex\Provider
 */
class TacticianServiceProvider implements ServiceProviderInterface
{
    /**
     * @var Container
     */
    private $app;

    /**
     * @var array
     */
    private $config;
    /**
     * @param array $config
     */
    public function __construct(array $config)
    {
        $this->config = $config;
    }
    /**
     * @param Container $app
     */
    public function register(Container $app)
    {
        $this->app = $app;

        foreach ($this->config as $key => $value) {
            $this->app[$key] = $value;
        }

        // register default locator if haven't defined yet
        if (! $app->offsetExists('tactician.locator')) {
            $app['tactician.locator'] = function () use ($app) {
                return new SilexLocator($app);
            };
        }

        // register default command extractor if haven't defined yet
        if (! $app->offsetExists('tactician.command_extractor')) {
            $app['tactician.command_extractor'] = function () {
                return new SilexCommandExtractor();
            };
        }

        // if inflector is string then resolve it
        if (is_string($app['tactician.inflector'])) {
            $app['tactician.inflector'] = $this->resolveStringBaseMethodInflector($app['tactician.inflector']);
        }

        $app['tactician.command_bus'] = function () use ($app) {
            // type checking, make sure all command bus component are valid
            if (! $app['tactician.command_extractor'] instanceof CommandNameExtractor) {
                throw new \InvalidArgumentException(sprintf(
                    'Tactician command extractor must implement %s',
                    CommandNameExtractor::class
                ));
            }

            if (! $app['tactician.locator'] instanceof HandlerLocator) {
                throw new \InvalidArgumentException(sprintf(
                    'Tactician locator must implement %s',
                    HandlerLocator::class
                ));
            }

            if (! $app['tactician.inflector'] instanceof MethodNameInflector) {
                throw new \InvalidArgumentException(sprintf(
                    'Tactician inflector must implement %s',
                    MethodNameInflector::class
                ));
            }

            $handler_middleware = new CommandHandlerMiddleware(
                $app['tactician.command_extractor'],
                $app['tactician.locator'],
                $app['tactician.inflector']
            );

            // combine middleware together
            $middleware = $app['tactician.middleware'];
            array_walk($middleware, function (&$value) {
                $value = $this->resolveMiddleware($value);
            });
            array_push($middleware, $handler_middleware);

            return new CommandBus($middleware);
        };
    }

    /**
     * @param string $string
     * @return MethodNameInflector
     */
    private function resolveStringBaseMethodInflector($string)
    {
        switch ($string) {
            case 'class_name':
                $inflector = function () {
                    return new HandleClassNameInflector();
                };
                break;
            case 'class_name_without_suffix':
                $inflector = function () {
                    return new HandleClassNameWithoutSuffixInflector();
                };
                break;
            case 'handle':
                $inflector = function () {
                    return new HandleInflector();
                };
                break;
            case 'invoke':
                $inflector = function () {
                    return new InvokeInflector();
                };
                break;
            default:
                $inflector = function () {
                    return new HandleClassNameInflector();
                };
                break;
        }

        return $inflector;
    }

    /**
     * @param string|Middleware $middleware
     * @return Middleware
     */
    public function resolveMiddleware($middleware)
    {
        if ($middleware instanceof Middleware) {
            return $middleware;
        }

        if ($this->app->offsetExists($middleware)) {
            $middleware = $this->app[$middleware];
            if ($middleware instanceof Middleware) {
                return $middleware;
            }
        }

        throw new \InvalidArgumentException(sprintf('Tactician middleware must implement %s', Middleware::class));
    }
}


1			<?php
2
3			namespace Silex\Provider;
4
5			use League\Tactician\CommandBus;
6			use League\Tactician\Handler\CommandHandlerMiddleware;
7			use League\Tactician\Handler\CommandNameExtractor\CommandNameExtractor;
8			use League\Tactician\Handler\Locator\HandlerLocator;
9			use League\Tactician\Handler\MethodNameInflector\HandleClassNameInflector;
10			use League\Tactician\Handler\MethodNameInflector\HandleClassNameWithoutSuffixInflector;
11			use League\Tactician\Handler\MethodNameInflector\HandleInflector;
12			use League\Tactician\Handler\MethodNameInflector\InvokeInflector;
13			use League\Tactician\Handler\MethodNameInflector\MethodNameInflector;
14			use League\Tactician\Middleware;
15			use Pimple\Container;
16			use Pimple\ServiceProviderInterface;
17			use Silex\Component\Tactician\CommandNameExtractor\Silex as SilexCommandExtractor;
18			use Silex\Component\Tactician\Locator\Silex as SilexLocator;
19
20			/**
21			* Class TacticianServiceProvider
22			* @package Silex\Provider
23			*/
24			class TacticianServiceProvider implements ServiceProviderInterface
25			{
26			/**
27			* @var Container
28			*/
29			private $app;
30
31			/**
32			* @var array
33			*/
34			private $config;
35			/**
36			* @param array $config
37			*/
38			public function __construct(array $config)
39			{
40			$this->config = $config;
41			}
42			/**
43			* @param Container $app
44			*/
45			public function register(Container $app)
46			{
47			$this->app = $app;
48
49			foreach ($this->config as $key => $value) {
50			$this->app[$key] = $value;
51			}
52
53			// register default locator if haven't defined yet
54			if (! $app->offsetExists('tactician.locator')) {
55			$app['tactician.locator'] = function () use ($app) {
56			return new SilexLocator($app);
57			};
58			}
59
60			// register default command extractor if haven't defined yet
61			if (! $app->offsetExists('tactician.command_extractor')) {
62			$app['tactician.command_extractor'] = function () {
63			return new SilexCommandExtractor();
64			};
65			}
66
67			// if inflector is string then resolve it
68			if (is_string($app['tactician.inflector'])) {
69			$app['tactician.inflector'] = $this->resolveStringBaseMethodInflector($app['tactician.inflector']);
70			}
71
72			$app['tactician.command_bus'] = function () use ($app) {
73			// type checking, make sure all command bus component are valid
74			if (! $app['tactician.command_extractor'] instanceof CommandNameExtractor) {
75			throw new \InvalidArgumentException(sprintf(
76			'Tactician command extractor must implement %s',
77			CommandNameExtractor::class
78			));
79			}
80
81			if (! $app['tactician.locator'] instanceof HandlerLocator) {
82			throw new \InvalidArgumentException(sprintf(
83			'Tactician locator must implement %s',
84			HandlerLocator::class
85			));
86			}
87
88			if (! $app['tactician.inflector'] instanceof MethodNameInflector) {
89			throw new \InvalidArgumentException(sprintf(
90			'Tactician inflector must implement %s',
91			MethodNameInflector::class
92			));
93			}
94
95			$handler_middleware = new CommandHandlerMiddleware(
96			$app['tactician.command_extractor'],
97			$app['tactician.locator'],
98			$app['tactician.inflector']
99			);
100
101			// combine middleware together
102			$middleware = $app['tactician.middleware'];
103			array_walk($middleware, function (&$value) {
104			$value = $this->resolveMiddleware($value);
105			});
106			array_push($middleware, $handler_middleware);
107
108			return new CommandBus($middleware);
109			};
110			}
111
112			/**
113			* @param string $string
114			* @return MethodNameInflector
115			*/
116			private function resolveStringBaseMethodInflector($string)
117			{
118			switch ($string) {
119			case 'class_name':
120			$inflector = function () {
121			return new HandleClassNameInflector();
122			};
123			break;
124			case 'class_name_without_suffix':
125			$inflector = function () {
126			return new HandleClassNameWithoutSuffixInflector();
127			};
128			break;
129			case 'handle':
130			$inflector = function () {
131			return new HandleInflector();
132			};
133			break;
134			case 'invoke':
135			$inflector = function () {
136			return new InvokeInflector();
137			};
138			break;
139			default:
140			$inflector = function () {
141			return new HandleClassNameInflector();
142			};
143			break;
144			}
145
146			return $inflector;
147			}
148
149			/**
150			* @param string\|Middleware $middleware
151			* @return Middleware
152			*/
153			public function resolveMiddleware($middleware)
154			{
155			if ($middleware instanceof Middleware) {
156			return $middleware;
157			}
158
159			if ($this->app->offsetExists($middleware)) {
160			$middleware = $this->app[$middleware];
161			if ($middleware instanceof Middleware) {
162			return $middleware;
163			}
164			}
165
166			throw new \InvalidArgumentException(sprintf('Tactician middleware must implement %s', Middleware::class));
167			}
168			}
169

Atriedes / tactician-service-provider

TacticianServiceProvider::register() C last analyzed 2016-02-22 15:37 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

TacticianServiceProvider::register() C
last analyzed 2016-02-22 15:37 UTC