Modules::newMod() - Code Metrics - Inspection of "2.2" - bfw-systems/bfw - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#67)

by Vermeulen

created 2016-05-16 09:29 UTC

Modules::newMod() A

↳ Parent: Modules

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes	7
Bugs	2	Features	0

Metric	Value
c	7
b	2
f	0
dl	0
loc	5
ccs	3
cts	3
cp	1
rs	9.4285
cc	1
eloc	3
nc	1
nop	2
crap	1

<?php
/**
 * Classes gérant les modules
 * @author Vermeulen Maxime <[email protected]>
 * @version 2.0
 */

namespace BFW;

/**
 * Gestions des modules
 * @package bfw
 */
class Modules implements \BFWInterface\IModules
{
    /**
     * @var $_kernel L'instance du Kernel
     */
    protected $_kernel;
    
    /**
     * @var $modList Liste des modules inclus
     */
    protected $modList = array();
    
    /**
     * @var $modLoad Liste des modules chargé
     */
    protected $modLoad = array();
    
    /**
     * @var $notLoad Liste des modules qui n'ont pas été chargé.
     */
    protected $notLoad = null;
    
    /**
     * @var array $loadOrder Liste de l'ordre de chargement des modules pour chaque temps de chargement
     */
    protected $loadOrder = array();
    
    /**
     * Constructeur
     */
    public function __construct()
    {
        $this->_kernel = getKernel();
    }
    
    /**
     * Permet de déclarer un nouveau module depuis un fichier json
     * 
     * @param string $path : Le chemin vers le fichier json
     * 
     * @throws \Exception Erreur sur la déclaration des options
     */
    public function newFromJson($path)
    {
        $filePath = $path.'/module.json';
        $jsonInfo = file_get_contents($filePath);
        $modInfo  = json_decode($jsonInfo, true);
        
        if(!isset($modInfo['name']))
        {
            throw new \Exception('Le nom du module n\'est pas déclaré (path: '.$path.').');
        }
        
        if(isset($modInfo['params']) && !is_array($modInfo['params']))
        {
            throw new \Exception('Les paramètres du module '.$name.' n\'est pas au bon format.');
        }
        
        $name   = $modInfo['name'];
        $params = $modInfo['params'];
        
        $this->initMod($name, $params);
        $this->addPath($name, $path);
    }
    
    /**
     * Permet de déclarer un nouveau modules
     * 
     * @param string $name   Le nom du modules
     * @param array  $params Options pour le chargement des modules.
     * Liste des clés du tableau : 
     * - time (string, constante) : Le moment auquel sera chargé le module. Plusieurs valeurs possible. Ce sont des constantes
     *     modulesLoadTime_Module : Chargement immédiat. Avant la classe visiteur et les path en constante
     *     modulesLoadTime_Visiteur : Après la classe Visiteur. Les path en constante n'existe pas
     *     modulesLoadTime_EndInit : A la fin de l'initialisation du framework (défaut)
     * - require (string, array) : Si le module doit avoir d'autre module de chargé avant.
     * 
     * @throws \Exception Erreur sur la déclaration des options
     */ 
    public function newMod($name, $params=array())
    {
        $this->initParameters($params, 'runFile', 'inclus.php');
        $this->initMod($name, $params);
    }
    
    /**
     * Permet de déclarer un nouveau modules
     * 
     * @param string $name   Le nom du modules
     * @param array  $params Options pour le chargement des modules.
     * Liste des clés du tableau : 
     * - time (string, constante) : Le moment auquel sera chargé le module. Plusieurs valeurs possible. Ce sont des constantes
     *     modulesLoadTime_Module : Chargement immédiat. Avant la classe visiteur et les path en constante
     *     modulesLoadTime_Visiteur : Après la classe Visiteur. Les path en constante n'existe pas
     *     modulesLoadTime_EndInit : A la fin de l'initialisation du framework (défaut)
     * - require (string, array) : Si le module doit avoir d'autre module de chargé avant.
     * 
     * @throws \Exception Erreur sur la déclaration des options
     */ 
    protected function initMod($name, $params=array())
    {
        if($this->exists($name))
        {
            throw new \Exception('Le module '.$name.' existe déjà.');
        }
        
        if(!is_array($params))
        {
            throw new \Exception('Les options du module '.$name.' doivent être déclarer sous la forme d\'un array.');
        }

        $time     = $this->initParameters($params, 'time', modulesLoadTime_EndInit);
        $require  = $this->initParameters($params, 'require', array());
        $priority = $this->initParameters($params, 'priority', 0);
        $runFile  = $this->initParameters($params, 'runFile', false);
        
        $this->modList[$name] = array(
            'name' => $name,
            'time' => $time,
            'require' => $require,
            'priority' => $priority,
            'runFile' => $runFile
        );
    }
    
    /**
     * Permet d'initialiser un paramètre
     * 
     * @param array  &$params : Les paramètres du module
     * @param string $key     : La clé du paramètre à initialiser
     * @param mixed  $default : La valeur par défaut
     */
    protected function initParameters(&$params, $key, $default)
    {
        if(!is_array($params)) {return;}
        
        if(!isset($params[$key]))
        {
            $params[$key] = $default;
        }
        
        if(is_int($default))
        {
            $params[$key] = (int) $params[$key];
        }
        
        if(is_array($default) && !is_array($params[$key]))
        {
            $params[$key] = array($params[$key]);
        }
        
        return $params[$key];
    }
    
    /**
     * Permet de vérifier si un module existe
     * 
     * @param string $name Le nom du module
     * 
     * @return bool true s'il existe, false sinon
     */
    public function exists($name)
    {
        return array_key_exists($name, $this->modList);
    }
    
    /**
     * Permet de vérifier si un module est chargé
     * 
     * @param string $name Le nom du module
     * 
     * @return bool true s'il est chargé, false sinon
     */
    public function isLoad($name)
    {
        return in_array($name, $this->modLoad);
    }
    
    /**
     * Permet de définir un module comme chargé
     * 
     * @param string $name Le nom du module
     * 
     * @throws \Exception : Si le module n'existe pas
     * 
     * @return void
     */
    public function loaded($name)
    {
        if(!$this->exists($name))
        {
            throw new \Exception('Module '.$name.' not exists.');
        }
        
        $this->modLoad[] = $name;
    }
    
    /**
     * Ajoute le path pour un module donné
     * 
     * @param string $name Le nom du module
     * @param string $path Le chemin réel du module
     * 
     * @throws \Exception Le module n'existe pas
     */
    public function addPath($name, $path)
    {
        if(!$this->exists($name)) {throw new \Exception('Le module '.$name.' n\'existe pas.');}
        $this->modList[$name]['path'] = $path;
    }
    
    /**
     * Liste des modules à charger à un moment précis.
     * 
     * @param string $timeToLoad Le temps auquel doivent être chargé les modules
     * 
     * @throws \Exception Erreur au chargement d'un module
     * 
     * @return array Liste des modules à charger
     */
    public function listToLoad($timeToLoad)
    {
        $arrayToLoad = array();
        $toLoad = array();
        
        foreach($this->modList as &$mod)
        {
            if($mod['time'] == $timeToLoad)
            {
                $toLoad[] = $mod;
            }
        }
        unset($mod); //kill ref
        
        uasort($toLoad, array($this, 'sortPriority'));
        
        foreach($toLoad as &$mod)
        {
            //Une exception est levé par modToLoad s'il y a une problème;
            $this->modToLoad($mod, $arrayToLoad);
        }
        unset($mod); //kill ref
        
        /*
        var_dump($arrayToLoad);
        if($timeToLoad == 'endInit') {exit;}
        //*/
        
        $this->loadOrder[$timeToLoad] = $arrayToLoad;
        
        return $arrayToLoad;
    }
    
    protected function sortPriority($mod1, $mod2)
    {
        $prio1 = $mod1['priority'];
        $prio2 = $mod2['priority'];
        
        if($prio1 === $prio2)
        {
            return 0;
        }
        
        return ($prio1 > $prio2) ? -1 : 1;
    }
    
    /**
     * Permet de vérifier si un module peut être chargé
     * 
     * @param array $mod         Le module à vérifier pour le chargement
     * @param array $arrayToLoad (ref) Liste des modules à charger
     * 
     * @throws \Exception Erreur avec les dépendances
     * 
     * @return bool Si le module peut être chargé ou non.
     */
    protected function modToLoad(&$mod, &$arrayToLoad, $waitToLoad=array())
    {
        if(in_array($mod['name'], $arrayToLoad) || isset($waitToLoad[$mod['name']]))
        {
            return true;
        }
        
        $waitToLoad[$mod['name']] = true;
        
        $require = $mod['require'];
        $load    = true;
        
        foreach($require as $modRequire)
        {
            if(!array_key_exists($modRequire, $this->modList))
            {
                throw new \Exception('La dépendance '.$modRequire.' du module '.$mod['name'].' n\'a pas été trouvé.');
            }
            
            if(!$this->isLoad($modRequire))
            {
                $load = $this->modToLoad($this->modList[$modRequire], $arrayToLoad, $waitToLoad);
            }
        }
        
        if($load)
        {
            $arrayToLoad[] = $mod['name'];
            unset($waitToLoad[$mod['name']]);
        }
        
        return $load;
    }
    
    /**
     * Liste les modules non chargé
     * 
     * @param bool $regen (default: false) Permet de regénérer la liste ou non
     * 
     * @return array Liste des modules non chargé
     */
    public function listNotLoad($regen=false)
    {
        if($regen === true || is_null($this->notLoad))
        {
            $this->notLoad = array_diff($this->modList, $this->modLoad);
        }
        
        return $this->notLoad;
    }
    
    /**
     * Permet de savoir si des modules n'ont pas pu être chargé
     * 
     * @return bool True si des modules n'ont pas pu être chargé, false sinon.
     */
    public function isModulesNotLoad()
    {
        $diff = $this->listNotLoad();
        
        if(count($diff) > 0) {return true;}
        return false;
    }
    
    /**
     * Retourne les infos sur un module
     * 
     * @param string $name Le nom du module dont on veux les infos
     * 
     * @throws \Exception Le module n'existe pas.
     * 
     * @return array Les infos sur le module
     */
    public function getModuleInfos($name)
    {
        if(!$this->exists($name)) {throw new \Exception('Le module '.$name.' n\'existe pas.');}
        return $this->modList[$name];
    }
    
    /**
     * Retourne le tableau loggant l'ordre de chargements des modules
     * 
     * @return array
     */
    public function getLoadOrder()
    {
        return $this->loadOrder;
    }
}


1		<?php
2		/**
3		* Classes gérant les modules
4		* @author Vermeulen Maxime <[email protected]>
5		* @version 2.0
6		*/
7
8		namespace BFW;
9
10		/**
11		* Gestions des modules
12		* @package bfw
13		*/
14		class Modules implements \BFWInterface\IModules
15		{
16		/**
17		* @var $_kernel L'instance du Kernel
18		*/
19		protected $_kernel;
20
21		/**
22		* @var $modList Liste des modules inclus
23		*/
24		protected $modList = array();
25
26		/**
27		* @var $modLoad Liste des modules chargé
28		*/
29		protected $modLoad = array();
30
31		/**
32		* @var $notLoad Liste des modules qui n'ont pas été chargé.
33		*/
34		protected $notLoad = null;
35
36		/**
37		* @var array $loadOrder Liste de l'ordre de chargement des modules pour chaque temps de chargement
38		*/
39		protected $loadOrder = array();
40
41		/**
42		* Constructeur
43		*/
44		public function __construct()
45		{
46	1	$this->_kernel = getKernel();
47	1	}
48
49		/**
50		* Permet de déclarer un nouveau module depuis un fichier json
51		*
52		* @param string $path : Le chemin vers le fichier json
53		*
54		* @throws \Exception Erreur sur la déclaration des options
55		*/
56		public function newFromJson($path)
57		{
58		$filePath = $path.'/module.json';
59		$jsonInfo = file_get_contents($filePath);
60		$modInfo = json_decode($jsonInfo, true);
61
62		if(!isset($modInfo['name']))
63		{
64		throw new \Exception('Le nom du module n\'est pas déclaré (path: '.$path.').');
65		}
66
67		if(isset($modInfo['params']) && !is_array($modInfo['params']))
68		{
69		throw new \Exception('Les paramètres du module '.$name.' n\'est pas au bon format.');
70		}
71
72		$name = $modInfo['name'];
73		$params = $modInfo['params'];
74
75		$this->initMod($name, $params);
76		$this->addPath($name, $path);
77		}
78
79		/**
80		* Permet de déclarer un nouveau modules
81		*
82		* @param string $name Le nom du modules
83		* @param array $params Options pour le chargement des modules.
84		* Liste des clés du tableau :
85		* - time (string, constante) : Le moment auquel sera chargé le module. Plusieurs valeurs possible. Ce sont des constantes
86		* modulesLoadTime_Module : Chargement immédiat. Avant la classe visiteur et les path en constante
87		* modulesLoadTime_Visiteur : Après la classe Visiteur. Les path en constante n'existe pas
88		* modulesLoadTime_EndInit : A la fin de l'initialisation du framework (défaut)
89		* - require (string, array) : Si le module doit avoir d'autre module de chargé avant.
90		*
91		* @throws \Exception Erreur sur la déclaration des options
92		*/
93		public function newMod($name, $params=array())
94		{
95	1	$this->initParameters($params, 'runFile', 'inclus.php');
96	1	$this->initMod($name, $params);
97	1	}
98
99		/**
100		* Permet de déclarer un nouveau modules
101		*
102		* @param string $name Le nom du modules
103		* @param array $params Options pour le chargement des modules.
104		* Liste des clés du tableau :
105		* - time (string, constante) : Le moment auquel sera chargé le module. Plusieurs valeurs possible. Ce sont des constantes
106		* modulesLoadTime_Module : Chargement immédiat. Avant la classe visiteur et les path en constante
107		* modulesLoadTime_Visiteur : Après la classe Visiteur. Les path en constante n'existe pas
108		* modulesLoadTime_EndInit : A la fin de l'initialisation du framework (défaut)
109		* - require (string, array) : Si le module doit avoir d'autre module de chargé avant.
110		*
111		* @throws \Exception Erreur sur la déclaration des options
112		*/
113		protected function initMod($name, $params=array())
114		{
115	1	if($this->exists($name))
116	1	{
117	1	throw new \Exception('Le module '.$name.' existe déjà.');
118		}
119
120	1	if(!is_array($params))
121	1	{
122	1	throw new \Exception('Les options du module '.$name.' doivent être déclarer sous la forme d\'un array.');
123		}
124
125	1	$time = $this->initParameters($params, 'time', modulesLoadTime_EndInit);
126	1	$require = $this->initParameters($params, 'require', array());
127	1	$priority = $this->initParameters($params, 'priority', 0);
128	1	$runFile = $this->initParameters($params, 'runFile', false);
129
130	1	$this->modList[$name] = array(
131	1	'name' => $name,
132	1	'time' => $time,
133	1	'require' => $require,
134	1	'priority' => $priority,
135		'runFile' => $runFile
136	1	);
137	1	}
138
139		/**
140		* Permet d'initialiser un paramètre
141		*
142		* @param array &$params : Les paramètres du module
143		* @param string $key : La clé du paramètre à initialiser
144		* @param mixed $default : La valeur par défaut
145		*/
146		protected function initParameters(&$params, $key, $default)
147		{
148	1	if(!is_array($params)) {return;}
149
150	1	if(!isset($params[$key]))
151	1	{
152	1	$params[$key] = $default;
153	1	}
154
155	1	if(is_int($default))
156	1	{
157	1	$params[$key] = (int) $params[$key];
158	1	}
159
160	1	if(is_array($default) && !is_array($params[$key]))
161	1	{
162	1	$params[$key] = array($params[$key]);
163	1	}
164
165	1	return $params[$key];
166		}
167
168		/**
169		* Permet de vérifier si un module existe
170		*
171		* @param string $name Le nom du module
172		*
173		* @return bool true s'il existe, false sinon
174		*/
175		public function exists($name)
176		{
177	1	return array_key_exists($name, $this->modList);
178		}
179
180		/**
181		* Permet de vérifier si un module est chargé
182		*
183		* @param string $name Le nom du module
184		*
185		* @return bool true s'il est chargé, false sinon
186		*/
187		public function isLoad($name)
188		{
189	1	return in_array($name, $this->modLoad);
190		}
191
192		/**
193		* Permet de définir un module comme chargé
194		*
195		* @param string $name Le nom du module
196		*
197		* @throws \Exception : Si le module n'existe pas
198		*
199		* @return void
200		*/
201		public function loaded($name)
202		{
203	1	if(!$this->exists($name))
204	1	{
205	1	throw new \Exception('Module '.$name.' not exists.');
206		}
207
208	1	$this->modLoad[] = $name;
209	1	}
210
211		/**
212		* Ajoute le path pour un module donné
213		*
214		* @param string $name Le nom du module
215		* @param string $path Le chemin réel du module
216		*
217		* @throws \Exception Le module n'existe pas
218		*/
219		public function addPath($name, $path)
220		{
221	1	if(!$this->exists($name)) {throw new \Exception('Le module '.$name.' n\'existe pas.');}
222	1	$this->modList[$name]['path'] = $path;
223	1	}
224
225		/**
226		* Liste des modules à charger à un moment précis.
227		*
228		* @param string $timeToLoad Le temps auquel doivent être chargé les modules
229		*
230		* @throws \Exception Erreur au chargement d'un module
231		*
232		* @return array Liste des modules à charger
233		*/
234		public function listToLoad($timeToLoad)
235		{
236	1	$arrayToLoad = array();
237	1	$toLoad = array();
238
239	1	foreach($this->modList as &$mod)
240		{
241	1	if($mod['time'] == $timeToLoad)
242	1	{
243	1	$toLoad[] = $mod;
244	1	}
245	1	}
246	1	unset($mod); //kill ref
247
248	1	uasort($toLoad, array($this, 'sortPriority'));
249
250	1	foreach($toLoad as &$mod)
251		{
252		//Une exception est levé par modToLoad s'il y a une problème;
253	1	$this->modToLoad($mod, $arrayToLoad);
254	1	}
255	1	unset($mod); //kill ref
256
257		/*
258		var_dump($arrayToLoad);
259		if($timeToLoad == 'endInit') {exit;}
260		//*/
261
262	1	$this->loadOrder[$timeToLoad] = $arrayToLoad;
263
264	1	return $arrayToLoad;
265		}
266
267		protected function sortPriority($mod1, $mod2)
268		{
269		$prio1 = $mod1['priority'];
270		$prio2 = $mod2['priority'];
271
272		if($prio1 === $prio2)
273		{
274		return 0;
275		}
276
277		return ($prio1 > $prio2) ? -1 : 1;
278		}
279
280		/**
281		* Permet de vérifier si un module peut être chargé
282		*
283		* @param array $mod Le module à vérifier pour le chargement
284		* @param array $arrayToLoad (ref) Liste des modules à charger
285		*
286		* @throws \Exception Erreur avec les dépendances
287		*
288		* @return bool Si le module peut être chargé ou non.
289		*/
290		protected function modToLoad(&$mod, &$arrayToLoad, $waitToLoad=array())
291		{
292	1	if(in_array($mod['name'], $arrayToLoad) \|\| isset($waitToLoad[$mod['name']]))
293	1	{
294	1	return true;
295		}
296
297	1	$waitToLoad[$mod['name']] = true;
298
299	1	$require = $mod['require'];
300	1	$load = true;
301
302	1	foreach($require as $modRequire)
303		{
304	1	if(!array_key_exists($modRequire, $this->modList))
305	1	{
306	1	throw new \Exception('La dépendance '.$modRequire.' du module '.$mod['name'].' n\'a pas été trouvé.');
307		}
308
309		if(!$this->isLoad($modRequire))
310		{
311		$load = $this->modToLoad($this->modList[$modRequire], $arrayToLoad, $waitToLoad);
312		}
313	1	}
314
315		if($load)
316	1	{
317	1	$arrayToLoad[] = $mod['name'];
318	1	unset($waitToLoad[$mod['name']]);
319	1	}
320
321	1	return $load;
322		}
323
324		/**
325		* Liste les modules non chargé
326		*
327		* @param bool $regen (default: false) Permet de regénérer la liste ou non
328		*
329		* @return array Liste des modules non chargé
330		*/
331		public function listNotLoad($regen=false)
332		{
333	1	if($regen === true \|\| is_null($this->notLoad))
334	1	{
335	1	$this->notLoad = array_diff($this->modList, $this->modLoad);
336	1	}
337
338	1	return $this->notLoad;
339		}
340
341		/**
342		* Permet de savoir si des modules n'ont pas pu être chargé
343		*
344		* @return bool True si des modules n'ont pas pu être chargé, false sinon.
345		*/
346		public function isModulesNotLoad()
347		{
348	1	$diff = $this->listNotLoad();
349
350	1	if(count($diff) > 0) {return true;}
351	1	return false;
352		}
353
354		/**
355		* Retourne les infos sur un module
356		*
357		* @param string $name Le nom du module dont on veux les infos
358		*
359		* @throws \Exception Le module n'existe pas.
360		*
361		* @return array Les infos sur le module
362		*/
363		public function getModuleInfos($name)
364		{
365	1	if(!$this->exists($name)) {throw new \Exception('Le module '.$name.' n\'existe pas.');}
366	1	return $this->modList[$name];
367		}
368
369		/**
370		* Retourne le tableau loggant l'ordre de chargements des modules
371		*
372		* @return array
373		*/
374		public function getLoadOrder()
375		{
376		return $this->loadOrder;
377		}
378		}
379

bfw-systems / bfw

GitHub Access Token became invalid

Pull Request — master (#67)

Modules::newMod() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like