Vars::makePaths() - Code Metrics - Inspection of "Add CacheProvider" - m1/Vars - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 5b2683...2f55d1 )

by Miles

created 2015-12-08 12:13 UTC

Vars::makePaths() A

↳ Parent: Vars

Complexity

Conditions	3
Paths	2

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
c	2
b	0
f	1
dl	0
loc	9
rs	9.6667
cc	3
eloc	5
nc	2
nop	1

<?php

/**
 * This file is part of the m1\vars library
 *
 * (c) m1 <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @package     m1/vars
 * @version     0.1.0
 * @author      Miles Croxford <[email protected]>
 * @copyright   Copyright (c) Miles Croxford <[email protected]>
 * @license     http://github.com/m1/vars/blob/master/LICENSE
 * @link        http://github.com/m1/vars/blob/master/README.MD Documentation
 */

namespace M1\Vars;

use M1\Vars\Cache\CacheProvider;
use M1\Vars\Resource\AbstractResource;
use M1\Vars\Resource\ResourceProvider;
use M1\Vars\Resource\VariableResource;

/**
 * Vars core class
 *
 * @since 0.1.0
 */
class Vars extends AbstractResource
{
    /**
     * The base path for the Vars config and cache folders
     *
     * @var string $base_path
     */
    private $base_path;

    /**
     * The cache object if the cache is wanted, else false
     *
     * @var \M1\Vars\Cache\CacheProvider $cache
     */
    public $cache;

    /**
     * The available extensions
     *
     * @var array $extensions
     */
    private $extensions = array();

    /**
     * The default options for Vars
     *
     * @var array $default_options
     */
    private $default_options = array(
        'base_path' => null,
        'cache' => true,
        'cache_path' => null,
        'cache_expire' => 300, // 5 minutes
        'loaders' => array('ini', 'json', 'php', 'toml', 'yaml', 'xml',)
    );

    /**
     * The available loaders
     *
     * @var array $loaders
     */
    private $loaders = array();

    /**
     * Have the base and cache paths been set
     *
     * @var bool $paths_loaded
     */
    private $paths_loaded = false;

    /**
     * The imported resources
     *
     * @var array $resources
     */
    private $resources = array();

    /**
     * The words to be replaced in the config files
     *
     * @var array $variables
     */
    private $variables = array();

    /**
     * Creates a new instance of Vars
     *
     * @param string|array $resource The main configuration resource
     * @param array        $options  The options being used for Vars
     */
    public function __construct($resource, $options = null)
    {
        if (!$options) {
            $options = $this->default_options;
        } else {
            $options = array_merge($this->default_options, $options);
        }

        $this->makeCache($options, $resource);
        $this->makePaths($options);

        if (!$this->cache->checkCache()) {
            $this->makeLoaders($options);
            $this->makeVariables($options);

            $resource = new ResourceProvider($this, $resource);
        }

        if ($this->cache->isHit()) {
            $this->loadFromCache();
        } else {
            $resource->mergeParentContent();
function someFunction(A $objectMaybe = null)
{
    if ($objectMaybe instanceof A) {
        $objectMaybe->doSomething();
    }
}
            $this->content = $resource->getContent();

            $this->cache->setTime(time());
            $this->cache->makeCache($this);

        }
    }

    /**
     * Makes the CacheProvider with the options
     *
     * @param array        $options  The options being used for Vars
     * @param array|string $resource The main configuration resource
     */
    private function makeCache($options, $resource)
    {
        $cache = new CacheProvider($resource, array_merge($this->default_options, $options));
        $this->cache = $cache;
    }

    /**
     * Sets the base path if the options have been set and the cache path if the cache path has not been set but the
     * base path has
     *
     * @param array $options The options being used for Vars
     */
    private function makePaths($options)
    {
        $this->setBasePath($options['base_path']);

        if (is_null($options['cache_path']) && !is_null($options['base_path'])) {
            $this->cache->setPath($options['base_path']);
            $this->paths_loaded = true;
        }
    }

    /**
     * Get loaders and make extensions for the loaders
     *
     * @param array|null $options The options being used for Vars
     *
     * @throws \InvalidArgumentException If a loader from options isn't found
     * @throws \InvalidArgumentException If no loaders were loaded
     */
    private function makeLoaders($options)
    {
        $loaders = array();
        $default_loaders = $this->default_options['loaders'];

        if (isset($options['loaders']) && !is_null($options['loaders']) && !empty($options['loaders'])) {
            if (is_array($options['loaders'])) {
                $loaders = $options['loaders'];
            } elseif (is_string($options['loaders'])) {
                $loaders[] = $options['loaders'];
            }
        } else {
            $loaders = $default_loaders;
        }

        $parsed_loaders = array();

        foreach ($loaders as $loader) {
            if ($loader === 'default') {
                $parsed_loaders = array_merge($parsed_loaders, $default_loaders);
            } else {
                $parsed_loaders[] = $loader;
            }
        }

        $parsed_loaders = array_unique($parsed_loaders);
        $namespaced_loaders = array();

        foreach ($parsed_loaders as $loader) {
            if (in_array($loader, $default_loaders)) {
                $loader = sprintf('%s\Loader\%sLoader', __NAMESPACE__, ucfirst(strtolower($loader)));
            }

            if (!class_exists($loader)) {
                throw new \InvalidArgumentException(sprintf("'%s' loader class does not exist", $loader));
            }

            $namespaced_loaders[] = $loader;
        }

        if (!$namespaced_loaders) {

            throw new \InvalidArgumentException('No loaders were loaded');
        }

        $this->loaders = $namespaced_loaders;
        $this->extensions = $this->makeExtensions($namespaced_loaders);
    }

    /**
     * Sets the replacement variables if the option has been set
     *
     * @param array|null $options The options being used for Vars
     */
    private function makeVariables($options)
    {
        if (isset($options['variables'])) {
            $variables = new VariableResource($this, $options['variables']);

            $v = array();

            foreach ($variables->getVariables() as $variable_key => $variable_value) {
                $v["%".$variable_key.'%'] = $variable_value;
            }

            $this->variables = $v;
        }
    }

    /**
     * Loads the cached file into the current class
     */
    private function loadFromCache()
    {
        $this->cache->load();

        $passed_keys = array(
            'base_path',
            'content',
            'extensions',
            'loaders',
            'resources',
            'variables',
        );

        $loaded_vars = get_object_vars($this->cache->getLoadedVars());

        foreach ($loaded_vars as $key => $value) {
            if (in_array($key, $passed_keys)) {
                $this->$key = $value;
            }
        }

        $this->cache->setTime($loaded_vars['cache']->getTime());
    }

    /**
     * Get and make extensions for loaders made from makeLoaders()
     *
     * @see \M1\Vars\Vars::makeLoaders() \M1\Vars\Vars::makeLoaders()
     *
     * @param  array $loaders File loaders
     *
     * @throws \RuntimeException If no loader extensions were found
     *
     * @return array File loader supported extensions
     */
    private function makeExtensions(array $loaders)
    {
        $extensions = array();

        foreach ($loaders as $loader) {
            $extensions = array_merge($extensions, $loader::$supported);
        }

        if (!$extensions) {

            throw new \RuntimeException('No loader extensions were found');
        }

        return $extensions;
    }

    /**
     * Checks if the base and cache paths have been set, if not set then will use the $resource as the base path
     *
     * @param string $resource The resource to use to set the paths if they haven't been set
     */
    public function pathsLoadedCheck($resource)
    {
        if (!$this->paths_loaded) {
            $base_path = $this->getBasePath();

            if (!$base_path) {
                $file = pathinfo(realpath($resource));
                $base_path = $file['dirname'];
                $this->setBasePath($base_path);
            }

            if ($this->cache->getProvide() && !$this->cache->getPath()) {
                $this->cache->setPath($base_path);
            }

            $this->paths_loaded = true;
        }
    }

    /**
     * Get the Vars file loaders
     *
     * @return array The Vars file loaders
     */
    public function getLoaders()
    {
        return $this->loaders;
    }

    /**
     * Get the Vars file loaders extensions
     *
     * @return array The Vars file loader extensions
     */
    public function getExtensions()
    {
        return $this->extensions;
    }

    /**
     * Get the Vars base path
     *
     * @return string The Vars base path
     */
    public function getBasePath()
    {
        return $this->base_path;
    }

    /**
     * Set the Vars base path
     *
     * @param string $base_path The base path to set
     *
     * @throws \InvalidArgumentException If the base path does not exist or is not writable
     *
     * @return \M1\Vars\Vars
     */
    public function setBasePath($base_path)

    {
        if (is_null($base_path)) {
            return;
        }

        if (!is_dir($base_path)) {
            throw new \InvalidArgumentException(sprintf(
                "'%s' base path does not exist or is not writable",
                $base_path
            ));
        }

        $this->base_path = realpath($base_path);
        return $this;
    }



    /**
     * Adds a resource to $this->resources
     *
     * @param string $resource Resource to add to the stack
     *
     * @return int The position of the added resource
     */
    public function addResource($resource)
    {
        $r = realpath($resource);
        $pos = count($this->resources);
        $this->resources[$pos] = $r;
        return $pos;
    }

    /**
     * Updates the string resource with the FileResource
     *
     * @param \M1\Vars\Resource\FileResource $resource The FileResource to add
     * @param int                            $pos      The position of the string resource
     *
     * @return \M1\Vars\Vars
     */
    public function updateResource($resource, $pos)
    {
        $this->resources[$pos] = $resource;
        return $this;
    }

    /**
     * Tests to see if the resource has been imported already -- this is to avoid getting into a infinite loop
     *
     * @param \M1\Vars\Resource\FileResource|string $resource Resource to check
     *
     * @return bool Has resource already been imported
     */
    public function resourceImported($resource)
    {
        $resource = realpath($resource);
        foreach ($this->getResources() as $r) {
            if ((is_a($r, 'M1\Vars\Resource\FileResource') && $resource === $r->getFile()) ||
                (is_string($r) && $resource === $r)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Searches the resource stack for a certain resource
     *
     * @param string $resource The resource to search for
     *
     * @return bool Returns the resource if found
     */
    public function getResource($resource)
    {
        foreach ($this->getResources() as $r) {
            if ($resource === $r->getFilename()) {
                return $r;
            }
        }

        return false;
    }

    /**
     * Returns the imported resources
     *
     * @return array The Vars imported resources
     */
    public function getResources()
    {
        return $this->resources;
    }

    /**
     * Returns the Vars replacement variables
     *
     * @return array The Vars replacement variables
     */
    public function getVariables()
    {
        return $this->variables;
    }

    /**
     * Returns the CacheProvider if set, if not return false
     *
     * @return \M1\Vars\Cache\CacheProvider|false The CacheProvider or false
     */
    public function getCache()
    {
        return $this->cache;
    }
}


1		<?php
2
3		/**
4		* This file is part of the m1\vars library
5		*
6		* (c) m1 <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*
11		* @package m1/vars
12		* @version 0.1.0
13		* @author Miles Croxford <[email protected]>
14		* @copyright Copyright (c) Miles Croxford <[email protected]>
15		* @license http://github.com/m1/vars/blob/master/LICENSE
16		* @link http://github.com/m1/vars/blob/master/README.MD Documentation
17		*/
18
19		namespace M1\Vars;
20
21		use M1\Vars\Cache\CacheProvider;
22		use M1\Vars\Resource\AbstractResource;
23		use M1\Vars\Resource\ResourceProvider;
24		use M1\Vars\Resource\VariableResource;
25
26		/**
27		* Vars core class
28		*
29		* @since 0.1.0
30		*/
31		class Vars extends AbstractResource
32		{
33		/**
34		* The base path for the Vars config and cache folders
35		*
36		* @var string $base_path
37		*/
38		private $base_path;
39
40		/**
41		* The cache object if the cache is wanted, else false
42		*
43		* @var \M1\Vars\Cache\CacheProvider $cache
44		*/
45		public $cache;
46
47		/**
48		* The available extensions
49		*
50		* @var array $extensions
51		*/
52		private $extensions = array();
53
54		/**
55		* The default options for Vars
56		*
57		* @var array $default_options
58		*/
59		private $default_options = array(
60		'base_path' => null,
61		'cache' => true,
62		'cache_path' => null,
63		'cache_expire' => 300, // 5 minutes
64		'loaders' => array('ini', 'json', 'php', 'toml', 'yaml', 'xml',)
65		);
66
67		/**
68		* The available loaders
69		*
70		* @var array $loaders
71		*/
72		private $loaders = array();
73
74		/**
75		* Have the base and cache paths been set
76		*
77		* @var bool $paths_loaded
78		*/
79		private $paths_loaded = false;
80
81		/**
82		* The imported resources
83		*
84		* @var array $resources
85		*/
86		private $resources = array();
87
88		/**
89		* The words to be replaced in the config files
90		*
91		* @var array $variables
92		*/
93		private $variables = array();
94
95		/**
96		* Creates a new instance of Vars
97		*
98		* @param string\|array $resource The main configuration resource
99		* @param array $options The options being used for Vars
100		*/
101		public function __construct($resource, $options = null)
102		{
103		if (!$options) {
104		$options = $this->default_options;
105		} else {
106		$options = array_merge($this->default_options, $options);
107		}
108
109		$this->makeCache($options, $resource);
110		$this->makePaths($options);
111
112		if (!$this->cache->checkCache()) {
113		$this->makeLoaders($options);
114		$this->makeVariables($options);
115
116		$resource = new ResourceProvider($this, $resource);
117		}
118
119		if ($this->cache->isHit()) {
120		$this->loadFromCache();
121		} else {
122		$resource->mergeParentContent();
		0 ignored issues – show Bug introduced 2015-12-07 14:50 UTC by Report Bug Copy Issue Report It seems like `$resource` is not always an object, but can also be of type `string\|array`. Maybe add an additional type check? If a variable is not always an object, we recommend to add an additional type check to ensure your method call is safe: function someFunction(A $objectMaybe = null) { if ($objectMaybe instanceof A) { $objectMaybe->doSomething(); } } Loading history...
123		$this->content = $resource->getContent();
124
125		$this->cache->setTime(time());
126		$this->cache->makeCache($this);
127
128		}
129		}
130
131		/**
132		* Makes the CacheProvider with the options
133		*
134		* @param array $options The options being used for Vars
135		* @param array\|string $resource The main configuration resource
136		*/
137		private function makeCache($options, $resource)
138		{
139		$cache = new CacheProvider($resource, array_merge($this->default_options, $options));
140		$this->cache = $cache;
141		}
142
143		/**
144		* Sets the base path if the options have been set and the cache path if the cache path has not been set but the
145		* base path has
146		*
147		* @param array $options The options being used for Vars
148		*/
149		private function makePaths($options)
150		{
151		$this->setBasePath($options['base_path']);
152
153		if (is_null($options['cache_path']) && !is_null($options['base_path'])) {
154		$this->cache->setPath($options['base_path']);
155		$this->paths_loaded = true;
156		}
157		}
158
159		/**
160		* Get loaders and make extensions for the loaders
161		*
162		* @param array\|null $options The options being used for Vars
163		*
164		* @throws \InvalidArgumentException If a loader from options isn't found
165		* @throws \InvalidArgumentException If no loaders were loaded
166		*/
167		private function makeLoaders($options)
168		{
169		$loaders = array();
170		$default_loaders = $this->default_options['loaders'];
171
172		if (isset($options['loaders']) && !is_null($options['loaders']) && !empty($options['loaders'])) {
173		if (is_array($options['loaders'])) {
174		$loaders = $options['loaders'];
175		} elseif (is_string($options['loaders'])) {
176		$loaders[] = $options['loaders'];
177		}
178		} else {
179		$loaders = $default_loaders;
180		}
181
182		$parsed_loaders = array();
183
184		foreach ($loaders as $loader) {
185		if ($loader === 'default') {
186		$parsed_loaders = array_merge($parsed_loaders, $default_loaders);
187		} else {
188		$parsed_loaders[] = $loader;
189		}
190		}
191
192		$parsed_loaders = array_unique($parsed_loaders);
193		$namespaced_loaders = array();
194
195		foreach ($parsed_loaders as $loader) {
196		if (in_array($loader, $default_loaders)) {
197		$loader = sprintf('%s\Loader\%sLoader', __NAMESPACE__, ucfirst(strtolower($loader)));
198		}
199
200		if (!class_exists($loader)) {
201		throw new \InvalidArgumentException(sprintf("'%s' loader class does not exist", $loader));
202		}
203
204		$namespaced_loaders[] = $loader;
205		}
206
207		if (!$namespaced_loaders) {
		0 ignored issues – show Bug Best Practice introduced 2015-12-07 14:50 UTC by Report Bug Copy Issue Report The expression `$namespaced_loaders` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
208		throw new \InvalidArgumentException('No loaders were loaded');
209		}
210
211		$this->loaders = $namespaced_loaders;
212		$this->extensions = $this->makeExtensions($namespaced_loaders);
213		}
214
215		/**
216		* Sets the replacement variables if the option has been set
217		*
218		* @param array\|null $options The options being used for Vars
219		*/
220		private function makeVariables($options)
221		{
222		if (isset($options['variables'])) {
223		$variables = new VariableResource($this, $options['variables']);
224
225		$v = array();
226
227		foreach ($variables->getVariables() as $variable_key => $variable_value) {
228		$v["%".$variable_key.'%'] = $variable_value;
229		}
230
231		$this->variables = $v;
232		}
233		}
234
235		/**
236		* Loads the cached file into the current class
237		*/
238		private function loadFromCache()
239		{
240		$this->cache->load();
241
242		$passed_keys = array(
243		'base_path',
244		'content',
245		'extensions',
246		'loaders',
247		'resources',
248		'variables',
249		);
250
251		$loaded_vars = get_object_vars($this->cache->getLoadedVars());
252
253		foreach ($loaded_vars as $key => $value) {
254		if (in_array($key, $passed_keys)) {
255		$this->$key = $value;
256		}
257		}
258
259		$this->cache->setTime($loaded_vars['cache']->getTime());
260		}
261
262		/**
263		* Get and make extensions for loaders made from makeLoaders()
264		*
265		* @see \M1\Vars\Vars::makeLoaders() \M1\Vars\Vars::makeLoaders()
266		*
267		* @param array $loaders File loaders
268		*
269		* @throws \RuntimeException If no loader extensions were found
270		*
271		* @return array File loader supported extensions
272		*/
273		private function makeExtensions(array $loaders)
274		{
275		$extensions = array();
276
277		foreach ($loaders as $loader) {
278		$extensions = array_merge($extensions, $loader::$supported);
279		}
280
281		if (!$extensions) {
		0 ignored issues – show Bug Best Practice introduced 2015-12-07 14:50 UTC by Report Bug Copy Issue Report The expression `$extensions` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
282		throw new \RuntimeException('No loader extensions were found');
283		}
284
285		return $extensions;
286		}
287
288		/**
289		* Checks if the base and cache paths have been set, if not set then will use the $resource as the base path
290		*
291		* @param string $resource The resource to use to set the paths if they haven't been set
292		*/
293		public function pathsLoadedCheck($resource)
294		{
295		if (!$this->paths_loaded) {
296		$base_path = $this->getBasePath();
297
298		if (!$base_path) {
299		$file = pathinfo(realpath($resource));
300		$base_path = $file['dirname'];
301		$this->setBasePath($base_path);
302		}
303
304		if ($this->cache->getProvide() && !$this->cache->getPath()) {
305		$this->cache->setPath($base_path);
306		}
307
308		$this->paths_loaded = true;
309		}
310		}
311
312		/**
313		* Get the Vars file loaders
314		*
315		* @return array The Vars file loaders
316		*/
317		public function getLoaders()
318		{
319		return $this->loaders;
320		}
321
322		/**
323		* Get the Vars file loaders extensions
324		*
325		* @return array The Vars file loader extensions
326		*/
327		public function getExtensions()
328		{
329		return $this->extensions;
330		}
331
332		/**
333		* Get the Vars base path
334		*
335		* @return string The Vars base path
336		*/
337		public function getBasePath()
338		{
339		return $this->base_path;
340		}
341
342		/**
343		* Set the Vars base path
344		*
345		* @param string $base_path The base path to set
346		*
347		* @throws \InvalidArgumentException If the base path does not exist or is not writable
348		*
349		* @return \M1\Vars\Vars
350		*/
351	View Code Duplication	public function setBasePath($base_path)
		0 ignored issues – show Duplication introduced 2015-12-08 12:35 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
352		{
353		if (is_null($base_path)) {
354		return;
355		}
356
357		if (!is_dir($base_path)) {
358		throw new \InvalidArgumentException(sprintf(
359		"'%s' base path does not exist or is not writable",
360		$base_path
361		));
362		}
363
364		$this->base_path = realpath($base_path);
365		return $this;
366		}
367
368
369
370		/**
371		* Adds a resource to $this->resources
372		*
373		* @param string $resource Resource to add to the stack
374		*
375		* @return int The position of the added resource
376		*/
377		public function addResource($resource)
378		{
379		$r = realpath($resource);
380		$pos = count($this->resources);
381		$this->resources[$pos] = $r;
382		return $pos;
383		}
384
385		/**
386		* Updates the string resource with the FileResource
387		*
388		* @param \M1\Vars\Resource\FileResource $resource The FileResource to add
389		* @param int $pos The position of the string resource
390		*
391		* @return \M1\Vars\Vars
392		*/
393		public function updateResource($resource, $pos)
394		{
395		$this->resources[$pos] = $resource;
396		return $this;
397		}
398
399		/**
400		* Tests to see if the resource has been imported already -- this is to avoid getting into a infinite loop
401		*
402		* @param \M1\Vars\Resource\FileResource\|string $resource Resource to check
403		*
404		* @return bool Has resource already been imported
405		*/
406		public function resourceImported($resource)
407		{
408		$resource = realpath($resource);
409		foreach ($this->getResources() as $r) {
410		if ((is_a($r, 'M1\Vars\Resource\FileResource') && $resource === $r->getFile()) \|\|
411		(is_string($r) && $resource === $r)) {
412		return true;
413		}
414		}
415		return false;
416		}
417
418		/**
419		* Searches the resource stack for a certain resource
420		*
421		* @param string $resource The resource to search for
422		*
423		* @return bool Returns the resource if found
424		*/
425		public function getResource($resource)
426		{
427		foreach ($this->getResources() as $r) {
428		if ($resource === $r->getFilename()) {
429		return $r;
430		}
431		}
432
433		return false;
434		}
435
436		/**
437		* Returns the imported resources
438		*
439		* @return array The Vars imported resources
440		*/
441		public function getResources()
442		{
443		return $this->resources;
444		}
445
446		/**
447		* Returns the Vars replacement variables
448		*
449		* @return array The Vars replacement variables
450		*/
451		public function getVariables()
452		{
453		return $this->variables;
454		}
455
456		/**
457		* Returns the CacheProvider if set, if not return false
458		*
459		* @return \M1\Vars\Cache\CacheProvider\|false The CacheProvider or false
460		*/
461		public function getCache()
462		{
463		return $this->cache;
464		}
465		}
466

m1 / Vars

GitHub Access Token became invalid

Push — master ( 5b2683...2f55d1 )

Vars::makePaths() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like