RuntimeManager::executeEvent() - Code Metrics - Inspection of "Removed the underscore for protected methods and p..." - zepi/turbo - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( af7267...09bff1 )

by Matthias

created 2016-10-23 10:42 UTC

RuntimeManager::executeEvent() A

↳ Parent: RuntimeManager

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1

<?php
/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 zepi
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */

/**
 * The RuntimeManager registers and executes all handlers. The
 * handlers are saved in an object backend.
 * 
 * @package Zepi\Turbo\Manager
 * @author Matthias Zobrist <[email protected]>
 * @copyright Copyright (c) 2015 zepi
 */

namespace Zepi\Turbo\Manager;

use \Zepi\Turbo\Framework;
use \Zepi\Turbo\Backend\ObjectBackendAbstract;
use \Zepi\Turbo\Request\RequestAbstract;
use \Zepi\Turbo\FrameworkInterface\EventHandlerInterface;
use Zepi\Turbo\FrameworkInterface\CliEventHandlerInterface;

/**
 * The RuntimeManager registers and executes all handlers. The
 * handlers are saved in an object backend.
 * 
 * @author Matthias Zobrist <[email protected]>
 * @copyright Copyright (c) 2015 zepi
 */
class RuntimeManager
{
    const EVENT = 'event';
    const FILTER = 'filter';
    
    /**
     * @access protected
     * @var Framework
     */
    protected $framework;
    
    /**
     * @access protected
     * @var ObjectBackendAbstract
     */
    protected $handlerObjectBackend;
    
    /**
     * @access protected
     * @var array
     */
    protected $handlers = array();
    
    /**
     * Constructs the object
     * 
     * @access public
     * @param \Zepi\Turbo\Framework $framework
     * @param \Zepi\Turbo\Backend\ObjectBackendAbstract $handlerObjectBackend
     */
    public function __construct(Framework $framework, ObjectBackendAbstract $handlerObjectBackend)
    {
        $this->framework = $framework;
        $this->handlerObjectBackend = $handlerObjectBackend;
    }
    
    /**
     * Initializes the event system. The function loads all saved
     * events from the object backend.
     * 
     * @access public
     */
    public function initializeManager()
    {
        $handlers = $this->handlerObjectBackend->loadObject();
        if (!is_array($handlers)) {
            $handlers = array();
        }
        
        $this->handlers = $handlers;
    }
    
    /**
     * Executes the events for the given event name
     * 
     * @access public
     * @param string $eventName
     */
    public function executeEvent($eventName)
    {
        $this->executeItems(self::EVENT, $eventName);
    }
    
    /**
     * Executes the filter for the given filter name
     *
     * @access public
     * @param string $eventName
     * @param mixed $value
     */
    public function executeFilter($eventName, $value = null)
    {
        return $this->executeItems(self::FILTER, $eventName, $value);
    }
    
    /**
     * Executes the given event handlers. Every event handler will
     * be initialized and executed.
     * 
     * @access protected
     * @param string $type
     * @param string $name
     * @param mixed $value
     * @return mixed
     */
    protected function executeItems($type, $name, $value = null)
    {
        if (!isset($this->handlers[$type][$name])) {
            return $value;
        }
        
        $request = $this->framework->getRequest();

        foreach ($this->filterHandlers($type, $name, $request) as $handlerName) {
            $handler = $this->framework->getInstance($handlerName);
                
            $response = $this->framework->getResponse();
            $response->setData('_executedType', $type);
            $response->setData('_executedName', $name);
                
            // Execute the handler
            $handlerResult = $handler->execute(
                $this->framework, 
                $this->framework->getRequest(), 
                $response,
                $value
            );
                
            // Save the handler result to the variable if this is an filter handler
            if ($type === self::FILTER) {
                $value = $handlerResult;
            }
        }
        
        // Return the value if this is an filter handler
        if ($type === self::FILTER) {
            return $value;
        }
    }
    
    /**
     * Filters the handler and returns an single array with
     * all queued handlers
     *
     * @access protected
     * @param string $type            
     * @param string $name            
     * @param RequestAbstract $request            
     * @return array
     */
    protected function filterHandlers($type, $name, RequestAbstract $request)
    {
        $filteredHandlers = array();
        
        foreach ($this->handlers[$type][$name] as $priority => $handlers) {
            foreach ($handlers as $handlerName) {
                if ($type === self::EVENT && !$this->compareRequestWithInterface($request, $handlerName)) {
                    continue;
                }
                
                $filteredHandlers[] = $handlerName;
            }
        }

        return array_unique($filteredHandlers);
    }
    
    /**
     * Returns true if the event handler and the request are from the same interface,
     * e.g. both are from cli. If the event handler is neutral return true. Return false
     * if the event handler isn't neutral and the request is not from the same interface.
     * 
     * @access protected
     * @param RequestAbstract $request
     * @param string $handlerName
     * @return boolean
     */
    protected function compareRequestWithInterface(RequestAbstract $request, $handlerName)
    {
        $implementedInterfaces = class_implements($handlerName, true);

        // If the event is a cli event but the request isn't a cli request
        // we skip this event
        if (isset($implementedInterfaces['Zepi\\Turbo\\FrameworkInterface\\CliEventHandlerInterface'])
            && get_class($request) != 'Zepi\\Turbo\\Request\\CliRequest') {
            return false;
        }

        // If the event is a web event but the request isn't a web request
        // we skip this event
        if (isset($implementedInterfaces['Zepi\\Turbo\\FrameworkInterface\\WebEventHandlerInterface'])
            && get_class($request) != 'Zepi\\Turbo\\Request\\WebRequest') {
            return false;
        }
        
        return true;
    }
    
    /**
     * Adds an event handler
     * 
     * @access public
     * @param string $eventName
     * @param string $eventHandlerName
     * @param integer $priority
     */
    public function addEventHandler($eventName, $eventHandlerName, $priority = 50)
    {
        $this->addHandler(self::EVENT, $eventName, $eventHandlerName, $priority);
    }
    
    /**
     * Adds an filter handler
     * 
     * @access public
     * @param string $filterName
     * @param string $filterHandlerName
     * @param integer $priority
     */
    public function addFilterHandler($filterName, $filterHandlerName, $priority = 50)
    {
        $this->addHandler(self::FILTER, $filterName, $filterHandlerName, $priority);
    }
    
    /**
     * Adds a new handler
     * 
     * @access protected
     * @param string $type
     * @param string $name
     * @param string $handlerName
     * @param integer $priority
     */
    protected function addHandler($type, $name, $handlerName, $priority)
    {
        // If the priority isn't existing we add the priority as 
        // a new array.
        if (!isset($this->handlers[$type][$name][$priority])) {
            $this->handlers[$type][$name][$priority] = array();
            ksort($this->handlers[$type][$name]);
        }
        
        // If we had the event handler already registred, return at this point
        if (in_array($handlerName, $this->handlers[$type][$name][$priority])) {
            return;
        }
        
        // Add the event handler and save the new events array
        $this->handlers[$type][$name][$priority][] = $handlerName;
        $this->saveHandlers();
    }
    
    /**
     * Removes an event handler
     * 
     * @access public
     * @param string $eventName
     * @param string $eventHandlerName
     * @param integer $priority
     */
    public function removeEventHandler($eventName, $eventHandlerName, $priority = 50)
    {
        $this->removeHandler(self::EVENT, $eventName, $eventHandlerName, $priority);
    }
    
    /**
     * Removes an filter handler
     * 
     * @access public
     * @param string $filterName
     * @param string $filterHandlerName
     * @param integer $priority
     */
    public function removeFilterHandler($filterName, $filterHandlerName, $priority = 50)
    {
        $this->removeHandler(self::FILTER, $filterName, $filterHandlerName, $priority);
    }
    
    /**
     * Removes an handler
     * 
     * @access protected
     * @param string $type
     * @param string $name
     * @param string $handlerName
     * @param string $priority
     */
    protected function removeHandler($type, $name, $handlerName, $priority)
    {
        // If the event isn't set we add an array to the events array
        if (!isset($this->handlers[$type][$name][$priority])) {
            return;
        }
        
        // If the event handler isn't registred we return with true.
        if (!in_array($handlerName, $this->handlers[$type][$name][$priority])) {
            return;
        }
        
        // Remove the event handler from the array
        $index = array_search($handlerName, $this->handlers[$type][$name][$priority]);
        unset($this->handlers[$type][$name][$priority][$index]);
        $this->saveHandlers();
    }
    
    /**
     * Clears the handlers cache and reactivates the modules
     * to rebuild the cache.
     * 
     * @access public
     * @param boolean $reactivateModules
     */
    public function clearCache($reactivateModules = true)
    {
        $this->handlers = array();
        
        if ($reactivateModules) {
            $this->framework->getModuleManager()->reactivateModules();
        }
    }
    
    /**
     * Saves the registred handlers in the object backend.
     * 
     * @access protected
     */
    protected function saveHandlers()
    {
        $this->handlerObjectBackend->saveObject($this->handlers);
    }
}


1			<?php
2			/*
3			* The MIT License (MIT)
4			*
5			* Copyright (c) 2015 zepi
6			*
7			* Permission is hereby granted, free of charge, to any person obtaining a copy
8			* of this software and associated documentation files (the "Software"), to deal
9			* in the Software without restriction, including without limitation the rights
10			* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11			* copies of the Software, and to permit persons to whom the Software is
12			* furnished to do so, subject to the following conditions:
13			*
14			* The above copyright notice and this permission notice shall be included in
15			* all copies or substantial portions of the Software.
16			*
17			* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18			* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19			* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20			* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21			* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22			* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23			* THE SOFTWARE.
24			*
25			*/
26
27			/**
28			* The RuntimeManager registers and executes all handlers. The
29			* handlers are saved in an object backend.
30			*
31			* @package Zepi\Turbo\Manager
32			* @author Matthias Zobrist <[email protected]>
33			* @copyright Copyright (c) 2015 zepi
34			*/
35
36			namespace Zepi\Turbo\Manager;
37
38			use \Zepi\Turbo\Framework;
39			use \Zepi\Turbo\Backend\ObjectBackendAbstract;
40			use \Zepi\Turbo\Request\RequestAbstract;
41			use \Zepi\Turbo\FrameworkInterface\EventHandlerInterface;
42			use Zepi\Turbo\FrameworkInterface\CliEventHandlerInterface;
43
44			/**
45			* The RuntimeManager registers and executes all handlers. The
46			* handlers are saved in an object backend.
47			*
48			* @author Matthias Zobrist <[email protected]>
49			* @copyright Copyright (c) 2015 zepi
50			*/
51			class RuntimeManager
52			{
53			const EVENT = 'event';
54			const FILTER = 'filter';
55
56			/**
57			* @access protected
58			* @var Framework
59			*/
60			protected $framework;
61
62			/**
63			* @access protected
64			* @var ObjectBackendAbstract
65			*/
66			protected $handlerObjectBackend;
67
68			/**
69			* @access protected
70			* @var array
71			*/
72			protected $handlers = array();
73
74			/**
75			* Constructs the object
76			*
77			* @access public
78			* @param \Zepi\Turbo\Framework $framework
79			* @param \Zepi\Turbo\Backend\ObjectBackendAbstract $handlerObjectBackend
80			*/
81			public function __construct(Framework $framework, ObjectBackendAbstract $handlerObjectBackend)
82			{
83			$this->framework = $framework;
84			$this->handlerObjectBackend = $handlerObjectBackend;
85			}
86
87			/**
88			* Initializes the event system. The function loads all saved
89			* events from the object backend.
90			*
91			* @access public
92			*/
93			public function initializeManager()
94			{
95			$handlers = $this->handlerObjectBackend->loadObject();
96			if (!is_array($handlers)) {
97			$handlers = array();
98			}
99
100			$this->handlers = $handlers;
101			}
102
103			/**
104			* Executes the events for the given event name
105			*
106			* @access public
107			* @param string $eventName
108			*/
109			public function executeEvent($eventName)
110			{
111			$this->executeItems(self::EVENT, $eventName);
112			}
113
114			/**
115			* Executes the filter for the given filter name
116			*
117			* @access public
118			* @param string $eventName
119			* @param mixed $value
120			*/
121			public function executeFilter($eventName, $value = null)
122			{
123			return $this->executeItems(self::FILTER, $eventName, $value);
124			}
125
126			/**
127			* Executes the given event handlers. Every event handler will
128			* be initialized and executed.
129			*
130			* @access protected
131			* @param string $type
132			* @param string $name
133			* @param mixed $value
134			* @return mixed
135			*/
136			protected function executeItems($type, $name, $value = null)
137			{
138			if (!isset($this->handlers[$type][$name])) {
139			return $value;
140			}
141
142			$request = $this->framework->getRequest();
143
144			foreach ($this->filterHandlers($type, $name, $request) as $handlerName) {
145			$handler = $this->framework->getInstance($handlerName);
146
147			$response = $this->framework->getResponse();
148			$response->setData('_executedType', $type);
149			$response->setData('_executedName', $name);
150
151			// Execute the handler
152			$handlerResult = $handler->execute(
153			$this->framework,
154			$this->framework->getRequest(),
155			$response,
156			$value
157			);
158
159			// Save the handler result to the variable if this is an filter handler
160			if ($type === self::FILTER) {
161			$value = $handlerResult;
162			}
163			}
164
165			// Return the value if this is an filter handler
166			if ($type === self::FILTER) {
167			return $value;
168			}
169			}
170
171			/**
172			* Filters the handler and returns an single array with
173			* all queued handlers
174			*
175			* @access protected
176			* @param string $type
177			* @param string $name
178			* @param RequestAbstract $request
179			* @return array
180			*/
181			protected function filterHandlers($type, $name, RequestAbstract $request)
182			{
183			$filteredHandlers = array();
184
185			foreach ($this->handlers[$type][$name] as $priority => $handlers) {
186			foreach ($handlers as $handlerName) {
187			if ($type === self::EVENT && !$this->compareRequestWithInterface($request, $handlerName)) {
188			continue;
189			}
190
191			$filteredHandlers[] = $handlerName;
192			}
193			}
194
195			return array_unique($filteredHandlers);
196			}
197
198			/**
199			* Returns true if the event handler and the request are from the same interface,
200			* e.g. both are from cli. If the event handler is neutral return true. Return false
201			* if the event handler isn't neutral and the request is not from the same interface.
202			*
203			* @access protected
204			* @param RequestAbstract $request
205			* @param string $handlerName
206			* @return boolean
207			*/
208			protected function compareRequestWithInterface(RequestAbstract $request, $handlerName)
209			{
210			$implementedInterfaces = class_implements($handlerName, true);
211
212			// If the event is a cli event but the request isn't a cli request
213			// we skip this event
214			if (isset($implementedInterfaces['Zepi\\Turbo\\FrameworkInterface\\CliEventHandlerInterface'])
215			&& get_class($request) != 'Zepi\\Turbo\\Request\\CliRequest') {
216			return false;
217			}
218
219			// If the event is a web event but the request isn't a web request
220			// we skip this event
221			if (isset($implementedInterfaces['Zepi\\Turbo\\FrameworkInterface\\WebEventHandlerInterface'])
222			&& get_class($request) != 'Zepi\\Turbo\\Request\\WebRequest') {
223			return false;
224			}
225
226			return true;
227			}
228
229			/**
230			* Adds an event handler
231			*
232			* @access public
233			* @param string $eventName
234			* @param string $eventHandlerName
235			* @param integer $priority
236			*/
237			public function addEventHandler($eventName, $eventHandlerName, $priority = 50)
238			{
239			$this->addHandler(self::EVENT, $eventName, $eventHandlerName, $priority);
240			}
241
242			/**
243			* Adds an filter handler
244			*
245			* @access public
246			* @param string $filterName
247			* @param string $filterHandlerName
248			* @param integer $priority
249			*/
250			public function addFilterHandler($filterName, $filterHandlerName, $priority = 50)
251			{
252			$this->addHandler(self::FILTER, $filterName, $filterHandlerName, $priority);
253			}
254
255			/**
256			* Adds a new handler
257			*
258			* @access protected
259			* @param string $type
260			* @param string $name
261			* @param string $handlerName
262			* @param integer $priority
263			*/
264			protected function addHandler($type, $name, $handlerName, $priority)
265			{
266			// If the priority isn't existing we add the priority as
267			// a new array.
268			if (!isset($this->handlers[$type][$name][$priority])) {
269			$this->handlers[$type][$name][$priority] = array();
270			ksort($this->handlers[$type][$name]);
271			}
272
273			// If we had the event handler already registred, return at this point
274			if (in_array($handlerName, $this->handlers[$type][$name][$priority])) {
275			return;
276			}
277
278			// Add the event handler and save the new events array
279			$this->handlers[$type][$name][$priority][] = $handlerName;
280			$this->saveHandlers();
281			}
282
283			/**
284			* Removes an event handler
285			*
286			* @access public
287			* @param string $eventName
288			* @param string $eventHandlerName
289			* @param integer $priority
290			*/
291			public function removeEventHandler($eventName, $eventHandlerName, $priority = 50)
292			{
293			$this->removeHandler(self::EVENT, $eventName, $eventHandlerName, $priority);
294			}
295
296			/**
297			* Removes an filter handler
298			*
299			* @access public
300			* @param string $filterName
301			* @param string $filterHandlerName
302			* @param integer $priority
303			*/
304			public function removeFilterHandler($filterName, $filterHandlerName, $priority = 50)
305			{
306			$this->removeHandler(self::FILTER, $filterName, $filterHandlerName, $priority);
307			}
308
309			/**
310			* Removes an handler
311			*
312			* @access protected
313			* @param string $type
314			* @param string $name
315			* @param string $handlerName
316			* @param string $priority
317			*/
318			protected function removeHandler($type, $name, $handlerName, $priority)
319			{
320			// If the event isn't set we add an array to the events array
321			if (!isset($this->handlers[$type][$name][$priority])) {
322			return;
323			}
324
325			// If the event handler isn't registred we return with true.
326			if (!in_array($handlerName, $this->handlers[$type][$name][$priority])) {
327			return;
328			}
329
330			// Remove the event handler from the array
331			$index = array_search($handlerName, $this->handlers[$type][$name][$priority]);
332			unset($this->handlers[$type][$name][$priority][$index]);
333			$this->saveHandlers();
334			}
335
336			/**
337			* Clears the handlers cache and reactivates the modules
338			* to rebuild the cache.
339			*
340			* @access public
341			* @param boolean $reactivateModules
342			*/
343			public function clearCache($reactivateModules = true)
344			{
345			$this->handlers = array();
346
347			if ($reactivateModules) {
348			$this->framework->getModuleManager()->reactivateModules();
349			}
350			}
351
352			/**
353			* Saves the registred handlers in the object backend.
354			*
355			* @access protected
356			*/
357			protected function saveHandlers()
358			{
359			$this->handlerObjectBackend->saveObject($this->handlers);
360			}
361			}
362

zepi / turbo

Push — master ( af7267...09bff1 )

RuntimeManager::executeEvent() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like