Dispatcher - Code Metrics - Inspection of "events, main dispatcher class stub" - comodojo/dispatcher.framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 4.0 ( 954171...ed2d0a )

by Marco

created 2016-01-11 23:31 UTC

Dispatcher F

↳ Parent: Project

Complexity

Total Complexity

108

Size/Duplication

Total Lines	1038
Duplicated Lines	7.61 %

Coupling/Cohesion

Components	1
Dependencies	12

Importance

Changes	11
Bugs	3	Features	2

Metric	Value
wmc	108
c	11
b	3
f	2
lcom	1
cbo	12
dl	79
loc	1038
rs	3.4509

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Dispatcher often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Dispatcher, and based on these observations, apply Extract Interface, too.

<?php namespace Comodojo\Dispatcher;

use \Monolog\Logger;
use \Comodojo\Dispatcher\Components\Configuration;
use \Comodojo\Dispatcher\Request\Model as Request;
use \Comodojo\Dispatcher\Router\Collector as RouteCollector;
use \Comodojo\Dispatcher\Response\Model as Response;
use \Comodojo\Dispatcher\Components\Timestamp as TimestampTrait;
use \Comodojo\Dispatcher\Output\Processor;
use \Comodojo\Dispatcher\Events\DispatcherEvent;
use \Comodojo\Dispatcher\Events\ServiceEvent;
use \Comodojo\Cache\CacheManager;
use \League\Event\Emitter;

/**
 *
 * @package     Comodojo dispatcher
 * @author      Marco Giovinazzi <[email protected]>
 * @license     GPL-3.0+
 *
 * LICENSE:
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

class Dispatcher {

    use TimestampTrait;

    private $configuration = null;

    private $request = null;

    private $router = null;

    private $response = null;

    private $logger = null;

    private $cache = null;

    private $events = null;

    public function __construct() {

        ob_start();

        $this->setTimestamp();

        $this->configuration = new Configuration();

        $this->events = new Emitter();

        $this->cache = new CacheManager( CacheManager::PICK_FIRST );

        $this->request = new Request($this->configuration, $this->logger);

        $this->router = new RouteCollector($this->configuration, $this->logger, $this->cache);

        $this->response = new Response($this->configuration, $this->logger);

    }

    public function configuration() {

        return $this->configuration;

    }

    public function events() {

        return $this->events;

    }

    public function cache() {

        return $this->cache;

    }

    public function request() {

        return $this->request;

    }

    public function router() {

        return $this->router;

    }

    public function response() {

        return $this->response;

    }

    public function dispatch() {

        $this->events->emit( new DispatcherEvent($this) );

        $this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.request') );

        $this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.request.'.$this->request->method()->get()) );

        $this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.request.#') );

        $this->router->route($this->request);

        $this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.route') );

        $this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.route.'.$this->router->route()->type) );

        $this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.route.'.$this->router->route()->service) );

        $this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.route.#') );

        // translate route to service

        $this->router->compose($this->response);

        $this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.response') );

        $this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.response.'.$this->response->status()->get()) );

        $this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.response.#') );

        $return = Processor::parse($this->configuration, $this->logger, $this->response);

        ob_end_clean();

        return $return;

    }

    private function emitServiceSpecializedEvents($name) {

        return new ServiceEvent(
            $name,
            $this->logger,
            $this->request,
            $this->router,
            $this->response
        ) );


    }

}


1			<?php namespace Comodojo\Dispatcher;
2
3			use \Monolog\Logger;
4			use \Comodojo\Dispatcher\Components\Configuration;
5			use \Comodojo\Dispatcher\Request\Model as Request;
6			use \Comodojo\Dispatcher\Router\Collector as RouteCollector;
7			use \Comodojo\Dispatcher\Response\Model as Response;
8			use \Comodojo\Dispatcher\Components\Timestamp as TimestampTrait;
9			use \Comodojo\Dispatcher\Output\Processor;
10			use \Comodojo\Dispatcher\Events\DispatcherEvent;
11			use \Comodojo\Dispatcher\Events\ServiceEvent;
12			use \Comodojo\Cache\CacheManager;
13			use \League\Event\Emitter;
14
15			/**
16			*
17			* @package Comodojo dispatcher
18			* @author Marco Giovinazzi <[email protected]>
19			* @license GPL-3.0+
20			*
21			* LICENSE:
22			*
23			* This program is free software: you can redistribute it and/or modify
24			* it under the terms of the GNU Affero General Public License as
25			* published by the Free Software Foundation, either version 3 of the
26			* License, or (at your option) any later version.
27			*
28			* This program is distributed in the hope that it will be useful,
29			* but WITHOUT ANY WARRANTY; without even the implied warranty of
30			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
31			* GNU Affero General Public License for more details.
32			*
33			* You should have received a copy of the GNU Affero General Public License
34			* along with this program. If not, see <http://www.gnu.org/licenses/>.
35			*/
36
37			class Dispatcher {
38
39			use TimestampTrait;
40
41			private $configuration = null;
42
43			private $request = null;
44
45			private $router = null;
46
47			private $response = null;
48
49			private $logger = null;
50
51			private $cache = null;
52
53			private $events = null;
54
55			public function __construct() {
56
57			ob_start();
58
59			$this->setTimestamp();
60
61			$this->configuration = new Configuration();
62
63			$this->events = new Emitter();
64
65			$this->cache = new CacheManager( CacheManager::PICK_FIRST );
66
67			$this->request = new Request($this->configuration, $this->logger);
68
69			$this->router = new RouteCollector($this->configuration, $this->logger, $this->cache);
70
71			$this->response = new Response($this->configuration, $this->logger);
72
73			}
74
75			public function configuration() {
76
77			return $this->configuration;
78
79			}
80
81			public function events() {
82
83			return $this->events;
84
85			}
86
87			public function cache() {
88
89			return $this->cache;
90
91			}
92
93			public function request() {
94
95			return $this->request;
96
97			}
98
99			public function router() {
100
101			return $this->router;
102
103			}
104
105			public function response() {
106
107			return $this->response;
108
109			}
110
111			public function dispatch() {
112
113			$this->events->emit( new DispatcherEvent($this) );
114
115			$this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.request') );
116
117			$this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.request.'.$this->request->method()->get()) );
118
119			$this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.request.#') );
120
121			$this->router->route($this->request);
122
123			$this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.route') );
124
125			$this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.route.'.$this->router->route()->type) );
126
127			$this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.route.'.$this->router->route()->service) );
128
129			$this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.route.#') );
130
131			// translate route to service
132
133			$this->router->compose($this->response);
134
135			$this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.response') );
136
137			$this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.response.'.$this->response->status()->get()) );
138
139			$this->events->emit( $this->emitServiceSpecializedEvents('dispatcher.response.#') );
140
141			$return = Processor::parse($this->configuration, $this->logger, $this->response);
142
143			ob_end_clean();
144
145			return $return;
146
147			}
148
149			private function emitServiceSpecializedEvents($name) {
150
151			return new ServiceEvent(
152			$name,
153			$this->logger,
154			$this->request,
155			$this->router,
156			$this->response
157			) );
			0 ignored issues – show Bug introduced 2016-01-11 23:45 UTC by Report Bug Copy Issue Report This code did not parse for me. Apparently, there is an error somewhere around this line: Syntax error, unexpected ')', expecting ';' Loading history...
158
159			}
160
161			}
162

comodojo / dispatcher.framework