Module::obtainRunnerFile() - Code Metrics - Inspection of "Move and improve skeleton directory" - bfw-systems/bfw - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 3.0 ( de1771...791612 )

by Vermeulen

created 2018-04-06 14:10 UTC

Module::obtainRunnerFile() B

↳ Parent: Module

Complexity

Conditions	4
Paths	6

Size

Total Lines	23
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	23
rs	8.7972
cc	4
eloc	13
nc	6
nop	0

<?php

namespace BFW;

use \Exception;
use \stdClass;

/**
 * Class to manage a module
 */
class Module
{
    /**
     * @const ERR_FILE_NOT_FOUND Exception code if the file is not found.
     */
    const ERR_FILE_NOT_FOUND = 1310001;
    
    /**
     * @const ERR_JSON_PARSE Exception code if the parse of a json file fail.
     */
    const ERR_JSON_PARSE = 1310002;
    
    /**
     * @const ERR_RUNNER_FILE_NOT_FOUND Exception code if the runner file to
     * execute is not found.
     */
    const ERR_RUNNER_FILE_NOT_FOUND = 1310003;

    /**
     * @var string $pathName Module's name
     */
    protected $pathName = '';

    /**
     * @var \BFW\Config $config Config object for this module
     */
    protected $config;

    /**
     * @var \stdClass $loadInfos All informations about how to run the module
     */
    protected $loadInfos;

    /**
     * @var \stdClass $status Load and run status
     */
    protected $status;

    /**
     * Constructor
     * 
     * @param string $pathName Module name
     */
    public function __construct($pathName)
    {
        $this->pathName = $pathName;
        $this->status   = (object) [
            'load' => false,
            'run'  => false
        ];
    }
    
    /**
     * Load informations about the module
     * 
     * @return void
     */
    public function loadModule()
    {
        $this->loadConfig();
        $this->obtainLoadInfos();

        $this->status->load = true;
    }

    /**
     * Get installation informations
     * 
     * @param string $sourceFiles Path to module source (in vendor)
     * 
     * @return \stdClass
     */
    public static function installInfos($sourceFiles)
    {
        $currentClass = get_called_class(); //Allow extends
        return $currentClass::readJsonFile(
            $sourceFiles.'/bfwModulesInfos.json'
        );
    }

    /**
     * Get the module's name
     * 
     * @return string
     */
    public function getPathName()
    {
        return $this->pathName;
    }

    /**
     * Get the Config object which have config for this module
     * 
     * @return \BFW\Config
     */
    public function getConfig()
    {
        return $this->config;
    }

    /**
     * Get the load informations
     * 
     * @return \stdClass
     */
    public function getLoadInfos()
    {
        return $this->loadInfos;
    }

    /**
     * Get the status object for this module
     * 
     * @return \stdClass
     */
    public function getStatus()
    {
        return $this->status;
    }

    /**
     * Return the load status
     * 
     * @return boolean
     */
    public function isLoaded()
    {
        return $this->status->load;
    }

    /**
     * Return the run status
     * 
     * @return boolean
     */
    public function isRun()
    {
        return $this->status->run;
    }

    /**
     * Instantiate the Config object to obtains module's configuration
     * 
     * @return void
     */
    protected function loadConfig()
    {
        if (!file_exists(CONFIG_DIR.$this->pathName)) {
            return;
        }

        $this->config = new \BFW\Config($this->pathName);
        $this->config->loadFiles();
    }

    /**
     * Save loaded informations from json file into the loadInfos property
     * 
     * @return void
     */
    protected function obtainLoadInfos()
    {
        $currentClass = get_called_class(); //Allow extends
        
        $this->loadInfos = $currentClass::readJsonFile(
            MODULES_DIR.$this->pathName
            .'/module.json'
        );
    }

    /**
     * Read and parse a json file
     * 
     * @param string $jsonFilePath : The path to the file to read
     * 
     * @return mixed Json parsed datas
     * 
     * @throws Exception If the file is not found or for a json parser error
     */
    protected static function readJsonFile($jsonFilePath)
    {
        if (!file_exists($jsonFilePath)) {
            throw new Exception(
                'File '.$jsonFilePath.' not found.',
                self::ERR_FILE_NOT_FOUND
            );
        }

        $infos = json_decode(file_get_contents($jsonFilePath));
        if ($infos === null) {
            throw new Exception(
                json_last_error_msg(),
                self::ERR_JSON_PARSE
            );
        }

        return $infos;
    }
    
    /**
     * Add a dependency to the module
     * Used for needMe property in module infos
     * 
     * @param string $dependencyName The dependency name to add
     * 
     * @return $this
     */
    public function addDependency($dependencyName)
    {
        if (!property_exists($this->loadInfos, 'require')) {
            $this->loadInfos->require = [];
        }
        
        if (!is_array($this->loadInfos->require)) {
            $this->loadInfos->require = [$this->loadInfos->require];
        }
        
        $this->loadInfos->require[] = $dependencyName;
        
        return $this;
    }

    /**
     * Get path to the runner file
     * 
     * @return string
     * 
     * @throws Exception If the file not exists
     */
    protected function obtainRunnerFile()
    {
        $moduleInfos = $this->loadInfos;
        $runnerFile  = '';

        if (property_exists($moduleInfos, 'runner')) {
            $runnerFile = (string) $moduleInfos->runner;
        }

        if ($runnerFile === '') {
            return;
        }

        $runnerFile = MODULES_DIR.$this->pathName.'/'.$runnerFile;
        if (!file_exists($runnerFile)) {
            throw new Exception(
                'Runner file for module '.$this->pathName.' not found.',
                $this::ERR_RUNNER_FILE_NOT_FOUND
            );
        }

        return $runnerFile;
    }

    /**
     * Run the module in a closure
     * 
     * @return void
     */
    public function runModule()
    {
        if ($this->status->run === true) {
            return;
        }
        
        $runnerFile   = $this->obtainRunnerFile();
        $initFunction = function() use ($runnerFile) {
            if ($runnerFile === null) {
                return;
            }
            
            require(realpath($runnerFile));
        };

        $this->status->run = true;
        $initFunction();
    }
}


1			<?php
2
3			namespace BFW;
4
5			use \Exception;
6			use \stdClass;
7
8			/**
9			* Class to manage a module
10			*/
11			class Module
12			{
13			/**
14			* @const ERR_FILE_NOT_FOUND Exception code if the file is not found.
15			*/
16			const ERR_FILE_NOT_FOUND = 1310001;
17
18			/**
19			* @const ERR_JSON_PARSE Exception code if the parse of a json file fail.
20			*/
21			const ERR_JSON_PARSE = 1310002;
22
23			/**
24			* @const ERR_RUNNER_FILE_NOT_FOUND Exception code if the runner file to
25			* execute is not found.
26			*/
27			const ERR_RUNNER_FILE_NOT_FOUND = 1310003;
28
29			/**
30			* @var string $pathName Module's name
31			*/
32			protected $pathName = '';
33
34			/**
35			* @var \BFW\Config $config Config object for this module
36			*/
37			protected $config;
38
39			/**
40			* @var \stdClass $loadInfos All informations about how to run the module
41			*/
42			protected $loadInfos;
43
44			/**
45			* @var \stdClass $status Load and run status
46			*/
47			protected $status;
48
49			/**
50			* Constructor
51			*
52			* @param string $pathName Module name
53			*/
54			public function __construct($pathName)
55			{
56			$this->pathName = $pathName;
57			$this->status = (object) [
58			'load' => false,
59			'run' => false
60			];
61			}
62
63			/**
64			* Load informations about the module
65			*
66			* @return void
67			*/
68			public function loadModule()
69			{
70			$this->loadConfig();
71			$this->obtainLoadInfos();
72
73			$this->status->load = true;
74			}
75
76			/**
77			* Get installation informations
78			*
79			* @param string $sourceFiles Path to module source (in vendor)
80			*
81			* @return \stdClass
82			*/
83			public static function installInfos($sourceFiles)
84			{
85			$currentClass = get_called_class(); //Allow extends
86			return $currentClass::readJsonFile(
87			$sourceFiles.'/bfwModulesInfos.json'
88			);
89			}
90
91			/**
92			* Get the module's name
93			*
94			* @return string
95			*/
96			public function getPathName()
97			{
98			return $this->pathName;
99			}
100
101			/**
102			* Get the Config object which have config for this module
103			*
104			* @return \BFW\Config
105			*/
106			public function getConfig()
107			{
108			return $this->config;
109			}
110
111			/**
112			* Get the load informations
113			*
114			* @return \stdClass
115			*/
116			public function getLoadInfos()
117			{
118			return $this->loadInfos;
119			}
120
121			/**
122			* Get the status object for this module
123			*
124			* @return \stdClass
125			*/
126			public function getStatus()
127			{
128			return $this->status;
129			}
130
131			/**
132			* Return the load status
133			*
134			* @return boolean
135			*/
136			public function isLoaded()
137			{
138			return $this->status->load;
139			}
140
141			/**
142			* Return the run status
143			*
144			* @return boolean
145			*/
146			public function isRun()
147			{
148			return $this->status->run;
149			}
150
151			/**
152			* Instantiate the Config object to obtains module's configuration
153			*
154			* @return void
155			*/
156			protected function loadConfig()
157			{
158			if (!file_exists(CONFIG_DIR.$this->pathName)) {
159			return;
160			}
161
162			$this->config = new \BFW\Config($this->pathName);
163			$this->config->loadFiles();
164			}
165
166			/**
167			* Save loaded informations from json file into the loadInfos property
168			*
169			* @return void
170			*/
171			protected function obtainLoadInfos()
172			{
173			$currentClass = get_called_class(); //Allow extends
174
175			$this->loadInfos = $currentClass::readJsonFile(
176			MODULES_DIR.$this->pathName
177			.'/module.json'
178			);
179			}
180
181			/**
182			* Read and parse a json file
183			*
184			* @param string $jsonFilePath : The path to the file to read
185			*
186			* @return mixed Json parsed datas
187			*
188			* @throws Exception If the file is not found or for a json parser error
189			*/
190			protected static function readJsonFile($jsonFilePath)
191			{
192			if (!file_exists($jsonFilePath)) {
193			throw new Exception(
194			'File '.$jsonFilePath.' not found.',
195			self::ERR_FILE_NOT_FOUND
196			);
197			}
198
199			$infos = json_decode(file_get_contents($jsonFilePath));
200			if ($infos === null) {
201			throw new Exception(
202			json_last_error_msg(),
203			self::ERR_JSON_PARSE
204			);
205			}
206
207			return $infos;
208			}
209
210			/**
211			* Add a dependency to the module
212			* Used for needMe property in module infos
213			*
214			* @param string $dependencyName The dependency name to add
215			*
216			* @return $this
217			*/
218			public function addDependency($dependencyName)
219			{
220			if (!property_exists($this->loadInfos, 'require')) {
221			$this->loadInfos->require = [];
222			}
223
224			if (!is_array($this->loadInfos->require)) {
225			$this->loadInfos->require = [$this->loadInfos->require];
226			}
227
228			$this->loadInfos->require[] = $dependencyName;
229
230			return $this;
231			}
232
233			/**
234			* Get path to the runner file
235			*
236			* @return string
237			*
238			* @throws Exception If the file not exists
239			*/
240			protected function obtainRunnerFile()
241			{
242			$moduleInfos = $this->loadInfos;
243			$runnerFile = '';
244
245			if (property_exists($moduleInfos, 'runner')) {
246			$runnerFile = (string) $moduleInfos->runner;
247			}
248
249			if ($runnerFile === '') {
250			return;
251			}
252
253			$runnerFile = MODULES_DIR.$this->pathName.'/'.$runnerFile;
254			if (!file_exists($runnerFile)) {
255			throw new Exception(
256			'Runner file for module '.$this->pathName.' not found.',
257			$this::ERR_RUNNER_FILE_NOT_FOUND
258			);
259			}
260
261			return $runnerFile;
262			}
263
264			/**
265			* Run the module in a closure
266			*
267			* @return void
268			*/
269			public function runModule()
270			{
271			if ($this->status->run === true) {
272			return;
273			}
274
275			$runnerFile = $this->obtainRunnerFile();
276			$initFunction = function() use ($runnerFile) {
277			if ($runnerFile === null) {
278			return;
279			}
280
281			require(realpath($runnerFile));
282			};
283
284			$this->status->run = true;
285			$initFunction();
286			}
287			}
288

bfw-systems / bfw

GitHub Access Token became invalid

Push — 3.0 ( de1771...791612 )

Module::obtainRunnerFile() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like