Manager::getPlugins() - Code Metrics - Inspection of "Changes in js code generation." - jaxon-php/jaxon-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 9cf8bc...8e87e9 )

by Thierry

created 2019-11-18 18:02 UTC

Manager::getPlugins() A

↳ Parent: Manager

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

/**
 * Manager.php - Jaxon plugin manager
 *
 * Register Jaxon plugins, generate corresponding code, handle request
 * and redirect them to the right plugin.
 *
 * @package jaxon-core
 * @author Jared White
 * @author J. Max Wilson
 * @author Joseph Woolley
 * @author Steffen Konerow
 * @author Thierry Feuzeu <[email protected]>
 * @copyright Copyright (c) 2005-2007 by Jared White & J. Max Wilson
 * @copyright Copyright (c) 2008-2010 by Joseph Woolley, Steffen Konerow, Jared White  & J. Max Wilson
 * @copyright 2016 Thierry Feuzeu <[email protected]>
 * @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
 * @link https://github.com/jaxon-php/jaxon-core
 */

namespace Jaxon\Plugin;

use Jaxon\Jaxon;
use Jaxon\Plugin\Package;
use Jaxon\Request\Support\CallableRepository;
use Jaxon\Request\Plugin\CallableClass;
use Jaxon\Request\Plugin\CallableDir;
use Jaxon\Request\Plugin\CallableFunction;
use Jaxon\Request\Plugin\FileUpload;
use Jaxon\Response\Plugin\JQuery as JQueryPlugin;
use Jaxon\Utils\Config\Config;

use Closure;

class Manager
{
    use \Jaxon\Features\Manager;
    use \Jaxon\Features\Config;
    use \Jaxon\Features\Event;
    use \Jaxon\Features\Translator;

    /**
     * All plugins, indexed by priority
     *
     * @var array
     */
    private $aPlugins = [];

    /**
     * Request plugins, indexed by name
     *
     * @var array
     */
    private $aRequestPlugins = [];

    /**
     * Response plugins, indexed by name
     *
     * @var array
     */
    private $aResponsePlugins = [];

    /**
     * An array of package names
     *
     * @var array
     */
    private $aPackages = [];

    /**
     * Get the request and response plugins
     *
     * @return array
     */
    public function getPlugins()
    {
        return $this->aPlugins;
    }

    /**
     * Get the request plugins
     *
     * @return array
     */
    public function getRequestPlugins()
    {
        return $this->aRequestPlugins;
    }

    /**
     * Get the response plugins
     *
     * @return array
     */
    public function getResponsePlugins()
    {
        return $this->aResponsePlugins;
    }

    /**
     * Get the package plugins
     *
     * @return array
     */
    public function getPackages()
    {
        return $this->aPackages;
    }

    /**
     * Inserts an entry into an array given the specified priority number
     *
     * If a plugin already exists with the given priority, the priority is automatically incremented until a free spot is found.
     * The plugin is then inserted into the empty spot in the array.
     *
     * @param Plugin         $xPlugin               An instance of a plugin
     * @param integer        $nPriority             The desired priority, used to order the plugins
     *
     * @return void
     */
    private function setPluginPriority(Plugin $xPlugin, $nPriority)
    {
        while (isset($this->aPlugins[$nPriority]))
        {
            $nPriority++;
        }
        $this->aPlugins[$nPriority] = $xPlugin;
        // Sort the array by ascending keys
        ksort($this->aPlugins);
    }

    /**
     * Register a plugin
     *
     * Below is a table for priorities and their description:
     * - 0 thru 999: Plugins that are part of or extensions to the jaxon core
     * - 1000 thru 8999: User created plugins, typically, these plugins don't care about order
     * - 9000 thru 9999: Plugins that generally need to be last or near the end of the plugin list
     *
     * @param Plugin         $xPlugin               An instance of a plugin
     * @param integer        $nPriority             The plugin priority, used to order the plugins
     *
     * @return void
     */
    public function registerPlugin(Plugin $xPlugin, $nPriority = 1000)
    {
        $bIsAlert = ($xPlugin instanceof \Jaxon\Contracts\Dialogs\Alert);
        $bIsConfirm = ($xPlugin instanceof \Jaxon\Contracts\Dialogs\Confirm);
        $bIsListener = ($xPlugin instanceof \Jaxon\Contracts\Event\Listener);
        if($xPlugin instanceof Request)
        {
            // The name of a request plugin is used as key in the plugin table
            $this->aRequestPlugins[$xPlugin->getName()] = $xPlugin;
        }
        elseif($xPlugin instanceof Response)
        {
            // The name of a response plugin is used as key in the plugin table
            $this->aResponsePlugins[$xPlugin->getName()] = $xPlugin;
        }
        elseif(!$bIsConfirm && !$bIsAlert && !$bIsListener)
        {
            $sErrorMessage = $this->trans('errors.register.invalid', ['name' => get_class($xPlugin)]);
            throw new \Jaxon\Exception\Error($sErrorMessage);
        }
        // This plugin implements the Alert interface
        if($bIsAlert)
        {
            jaxon()->dialog()->setAlert($xPlugin);
        }
        // This plugin implements the Confirm interface
        if($bIsConfirm)
        {
            jaxon()->dialog()->setConfirm($xPlugin);
        }
        // Register the plugin as an event listener
        if($bIsListener)
        {
            $this->addEventListener($xPlugin);
        }

        $this->setPluginPriority($xPlugin, $nPriority);
    }

    /**
     * Register a package
     *
     * @param string         $sPackageClass         The package class name
     * @param Closure        $xClosure              A closure to create package instance
     *
     * @return void
     */
    public function registerPackage(string $sPackageClass, Closure $xClosure)
    {
        $this->aPackages[] = $sPackageClass;
        jaxon()->di()->set($sPackageClass, $xClosure);
    }

    /**
     * Register a function, event or callable class
     *
     * Call the request plugin with the $sType defined as name.
     *
     * @param string        $sType          The type of request handler being registered
     * @param string        $sCallable      The callable entity being registered
     * @param array|string  $aOptions       The associated options
     *
     * @return mixed
     */
    public function registerCallable($sType, $sCallable, $aOptions = [])
    {
        if(!key_exists($sType, $this->aRequestPlugins))
        {
            throw new \Jaxon\Exception\Error($this->trans('errors.register.plugin', ['name' => $sType]));
        }

        $xPlugin = $this->aRequestPlugins[$sType];
        return $xPlugin->register($sType, $sCallable, $aOptions);
    }

    /**
     * Register callable from a section of the config
     *
     * @param Config        $xAppConfig        The config options
     * @param string        $sSection          The config section name
     * @param string        $sCallableType     The type of callable to register
     *
     * @return void
     */
    private function registerCallablesFromConfig($xAppConfig, $sSection, $sCallableType)
    {
        $aConfig = $xAppConfig->getOption($sSection, []);
        foreach($aConfig as $xKey => $xValue)
        {
            if(is_integer($xKey) && is_string($xValue))
            {
                // Register a function without options
                $this->registerCallable($sCallableType, $xValue);
            }
            elseif(is_string($xKey) && (is_array($xValue) || is_string($xValue)))
            {
                // Register a function with options
                $this->registerCallable($sCallableType, $xKey, $xValue);
            }
            else
            {
                continue;
                // Todo: throw an exception
            }
        }
    }

    /**
     * Read and set Jaxon options from a JSON config file
     *
     * @param Config        $xAppConfig        The config options
     *
     * @return void
     */
    public function registerFromConfig($xAppConfig)
    {
        // Register functions
        $this->registerCallablesFromConfig($xAppConfig, 'functions', Jaxon::CALLABLE_FUNCTION);

        // Register classes
        $this->registerCallablesFromConfig($xAppConfig, 'classes', Jaxon::CALLABLE_CLASS);

        // Register directories
        $this->registerCallablesFromConfig($xAppConfig, 'directories', Jaxon::CALLABLE_DIR);
    }


    /**
     * Find the specified response plugin by name and return a reference to it if one exists
     *
     * @param string        $sName                The name of the plugin
     *
     * @return \Jaxon\Plugin\Response
     */
    public function getResponsePlugin($sName)
    {
        if(array_key_exists($sName, $this->aResponsePlugins))
        {
            return $this->aResponsePlugins[$sName];
        }
        return null;
    }

    /**
     * Find the specified request plugin by name and return a reference to it if one exists
     *
     * @param string        $sName                The name of the plugin
     *
     * @return \Jaxon\Plugin\Request
     */
    public function getRequestPlugin($sName)
    {
        if(array_key_exists($sName, $this->aRequestPlugins))
        {
            return $this->aRequestPlugins[$sName];
        }
        return null;
    }

    /**
     * Register the Jaxon request plugins
     *
     * @return void
     */
    public function registerRequestPlugins()
    {
        $di = jaxon()->di();
        $this->registerPlugin($di->get(CallableClass::class), 101);
        $this->registerPlugin($di->get(CallableDir::class), 102);
        $this->registerPlugin($di->get(CallableFunction::class), 103);
        $this->registerPlugin($di->get(FileUpload::class), 104);
    }

    /**
     * Register the Jaxon response plugins
     *
     * @return void
     */
    public function registerResponsePlugins()
    {
        $di = jaxon()->di();
        // Register an instance of the JQuery plugin
        $this->registerPlugin($di->get(JQueryPlugin::class), 700);
    }
}


1			<?php
2
3			/**
4			* Manager.php - Jaxon plugin manager
5			*
6			* Register Jaxon plugins, generate corresponding code, handle request
7			* and redirect them to the right plugin.
8			*
9			* @package jaxon-core
10			* @author Jared White
11			* @author J. Max Wilson
12			* @author Joseph Woolley
13			* @author Steffen Konerow
14			* @author Thierry Feuzeu <[email protected]>
15			* @copyright Copyright (c) 2005-2007 by Jared White & J. Max Wilson
16			* @copyright Copyright (c) 2008-2010 by Joseph Woolley, Steffen Konerow, Jared White & J. Max Wilson
17			* @copyright 2016 Thierry Feuzeu <[email protected]>
18			* @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
19			* @link https://github.com/jaxon-php/jaxon-core
20			*/
21
22			namespace Jaxon\Plugin;
23
24			use Jaxon\Jaxon;
25			use Jaxon\Plugin\Package;
26			use Jaxon\Request\Support\CallableRepository;
27			use Jaxon\Request\Plugin\CallableClass;
28			use Jaxon\Request\Plugin\CallableDir;
29			use Jaxon\Request\Plugin\CallableFunction;
30			use Jaxon\Request\Plugin\FileUpload;
31			use Jaxon\Response\Plugin\JQuery as JQueryPlugin;
32			use Jaxon\Utils\Config\Config;
33
34			use Closure;
35
36			class Manager
37			{
38			use \Jaxon\Features\Manager;
39			use \Jaxon\Features\Config;
40			use \Jaxon\Features\Event;
41			use \Jaxon\Features\Translator;
42
43			/**
44			* All plugins, indexed by priority
45			*
46			* @var array
47			*/
48			private $aPlugins = [];
49
50			/**
51			* Request plugins, indexed by name
52			*
53			* @var array
54			*/
55			private $aRequestPlugins = [];
56
57			/**
58			* Response plugins, indexed by name
59			*
60			* @var array
61			*/
62			private $aResponsePlugins = [];
63
64			/**
65			* An array of package names
66			*
67			* @var array
68			*/
69			private $aPackages = [];
70
71			/**
72			* Get the request and response plugins
73			*
74			* @return array
75			*/
76			public function getPlugins()
77			{
78			return $this->aPlugins;
79			}
80
81			/**
82			* Get the request plugins
83			*
84			* @return array
85			*/
86			public function getRequestPlugins()
87			{
88			return $this->aRequestPlugins;
89			}
90
91			/**
92			* Get the response plugins
93			*
94			* @return array
95			*/
96			public function getResponsePlugins()
97			{
98			return $this->aResponsePlugins;
99			}
100
101			/**
102			* Get the package plugins
103			*
104			* @return array
105			*/
106			public function getPackages()
107			{
108			return $this->aPackages;
109			}
110
111			/**
112			* Inserts an entry into an array given the specified priority number
113			*
114			* If a plugin already exists with the given priority, the priority is automatically incremented until a free spot is found.
115			* The plugin is then inserted into the empty spot in the array.
116			*
117			* @param Plugin $xPlugin An instance of a plugin
118			* @param integer $nPriority The desired priority, used to order the plugins
119			*
120			* @return void
121			*/
122			private function setPluginPriority(Plugin $xPlugin, $nPriority)
123			{
124			while (isset($this->aPlugins[$nPriority]))
125			{
126			$nPriority++;
127			}
128			$this->aPlugins[$nPriority] = $xPlugin;
129			// Sort the array by ascending keys
130			ksort($this->aPlugins);
131			}
132
133			/**
134			* Register a plugin
135			*
136			* Below is a table for priorities and their description:
137			* - 0 thru 999: Plugins that are part of or extensions to the jaxon core
138			* - 1000 thru 8999: User created plugins, typically, these plugins don't care about order
139			* - 9000 thru 9999: Plugins that generally need to be last or near the end of the plugin list
140			*
141			* @param Plugin $xPlugin An instance of a plugin
142			* @param integer $nPriority The plugin priority, used to order the plugins
143			*
144			* @return void
145			*/
146			public function registerPlugin(Plugin $xPlugin, $nPriority = 1000)
147			{
148			$bIsAlert = ($xPlugin instanceof \Jaxon\Contracts\Dialogs\Alert);
149			$bIsConfirm = ($xPlugin instanceof \Jaxon\Contracts\Dialogs\Confirm);
150			$bIsListener = ($xPlugin instanceof \Jaxon\Contracts\Event\Listener);
151			if($xPlugin instanceof Request)
152			{
153			// The name of a request plugin is used as key in the plugin table
154			$this->aRequestPlugins[$xPlugin->getName()] = $xPlugin;
155			}
156			elseif($xPlugin instanceof Response)
157			{
158			// The name of a response plugin is used as key in the plugin table
159			$this->aResponsePlugins[$xPlugin->getName()] = $xPlugin;
160			}
161			elseif(!$bIsConfirm && !$bIsAlert && !$bIsListener)
162			{
163			$sErrorMessage = $this->trans('errors.register.invalid', ['name' => get_class($xPlugin)]);
164			throw new \Jaxon\Exception\Error($sErrorMessage);
165			}
166			// This plugin implements the Alert interface
167			if($bIsAlert)
168			{
169			jaxon()->dialog()->setAlert($xPlugin);
170			}
171			// This plugin implements the Confirm interface
172			if($bIsConfirm)
173			{
174			jaxon()->dialog()->setConfirm($xPlugin);
175			}
176			// Register the plugin as an event listener
177			if($bIsListener)
178			{
179			$this->addEventListener($xPlugin);
180			}
181
182			$this->setPluginPriority($xPlugin, $nPriority);
183			}
184
185			/**
186			* Register a package
187			*
188			* @param string $sPackageClass The package class name
189			* @param Closure $xClosure A closure to create package instance
190			*
191			* @return void
192			*/
193			public function registerPackage(string $sPackageClass, Closure $xClosure)
194			{
195			$this->aPackages[] = $sPackageClass;
196			jaxon()->di()->set($sPackageClass, $xClosure);
197			}
198
199			/**
200			* Register a function, event or callable class
201			*
202			* Call the request plugin with the $sType defined as name.
203			*
204			* @param string $sType The type of request handler being registered
205			* @param string $sCallable The callable entity being registered
206			* @param array\|string $aOptions The associated options
207			*
208			* @return mixed
209			*/
210			public function registerCallable($sType, $sCallable, $aOptions = [])
211			{
212			if(!key_exists($sType, $this->aRequestPlugins))
213			{
214			throw new \Jaxon\Exception\Error($this->trans('errors.register.plugin', ['name' => $sType]));
215			}
216
217			$xPlugin = $this->aRequestPlugins[$sType];
218			return $xPlugin->register($sType, $sCallable, $aOptions);
219			}
220
221			/**
222			* Register callable from a section of the config
223			*
224			* @param Config $xAppConfig The config options
225			* @param string $sSection The config section name
226			* @param string $sCallableType The type of callable to register
227			*
228			* @return void
229			*/
230			private function registerCallablesFromConfig($xAppConfig, $sSection, $sCallableType)
231			{
232			$aConfig = $xAppConfig->getOption($sSection, []);
233			foreach($aConfig as $xKey => $xValue)
234			{
235			if(is_integer($xKey) && is_string($xValue))
236			{
237			// Register a function without options
238			$this->registerCallable($sCallableType, $xValue);
239			}
240			elseif(is_string($xKey) && (is_array($xValue) \|\| is_string($xValue)))
241			{
242			// Register a function with options
243			$this->registerCallable($sCallableType, $xKey, $xValue);
244			}
245			else
246			{
247			continue;
248			// Todo: throw an exception
249			}
250			}
251			}
252
253			/**
254			* Read and set Jaxon options from a JSON config file
255			*
256			* @param Config $xAppConfig The config options
257			*
258			* @return void
259			*/
260			public function registerFromConfig($xAppConfig)
261			{
262			// Register functions
263			$this->registerCallablesFromConfig($xAppConfig, 'functions', Jaxon::CALLABLE_FUNCTION);
264
265			// Register classes
266			$this->registerCallablesFromConfig($xAppConfig, 'classes', Jaxon::CALLABLE_CLASS);
267
268			// Register directories
269			$this->registerCallablesFromConfig($xAppConfig, 'directories', Jaxon::CALLABLE_DIR);
270			}
271
272
273			/**
274			* Find the specified response plugin by name and return a reference to it if one exists
275			*
276			* @param string $sName The name of the plugin
277			*
278			* @return \Jaxon\Plugin\Response
279			*/
280			public function getResponsePlugin($sName)
281			{
282			if(array_key_exists($sName, $this->aResponsePlugins))
283			{
284			return $this->aResponsePlugins[$sName];
285			}
286			return null;
287			}
288
289			/**
290			* Find the specified request plugin by name and return a reference to it if one exists
291			*
292			* @param string $sName The name of the plugin
293			*
294			* @return \Jaxon\Plugin\Request
295			*/
296			public function getRequestPlugin($sName)
297			{
298			if(array_key_exists($sName, $this->aRequestPlugins))
299			{
300			return $this->aRequestPlugins[$sName];
301			}
302			return null;
303			}
304
305			/**
306			* Register the Jaxon request plugins
307			*
308			* @return void
309			*/
310			public function registerRequestPlugins()
311			{
312			$di = jaxon()->di();
313			$this->registerPlugin($di->get(CallableClass::class), 101);
314			$this->registerPlugin($di->get(CallableDir::class), 102);
315			$this->registerPlugin($di->get(CallableFunction::class), 103);
316			$this->registerPlugin($di->get(FileUpload::class), 104);
317			}
318
319			/**
320			* Register the Jaxon response plugins
321			*
322			* @return void
323			*/
324			public function registerResponsePlugins()
325			{
326			$di = jaxon()->di();
327			// Register an instance of the JQuery plugin
328			$this->registerPlugin($di->get(JQueryPlugin::class), 700);
329			}
330			}
331

jaxon-php / jaxon-core

Push — master ( 9cf8bc...8e87e9 )

Manager::getPlugins() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like