Konfig::pathFromArray() - Code Metrics - Inspection of "Minor fixes and code enhancements" - xeriab/konfig - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( adf7fc...68b7f3 )

by Xeriab

created 2016-03-08 00:27 UTC

Konfig::pathFromArray() B

↳ Parent: Konfig

Complexity

Conditions	5
Paths	11

Size

Total Lines	30
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	30

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	30
ccs	0
cts	14
cp	0
rs	8.439
cc	5
eloc	14
nc	11
nop	1
crap	30

<?php
/**
 * Konfig
 *
 * Yet another simple configuration loader library.
 *
 * @author  Xeriab Nabil (aka KodeBurner) <[email protected]>
 * @license https://raw.github.com/xeriab/konfig/master/LICENSE MIT
 * @link    https://xeriab.github.io/projects/konfig
 */

namespace Exen\Konfig;

use Exen\Konfig\Exception\EmptyDirectoryException;
use Exen\Konfig\Exception\FileNotFoundException;
use Exen\Konfig\Exception\UnsupportedFileFormatException;

final class Konfig extends AbstractKonfig
{
    /**
     * @var FileParser[] $fileParsers Array of file parsers objects
     * @since 0.1
     */
    protected $fileParsers;

    /**
     * Stores loaded configuration files
     *
     * @var array $loadedFiles Array of loaded configuration files
     * @since 0.1
     */
    protected static $loadedFiles = [];

    /**
     * Loads a supported configuration file format.
     *
     * @param  string|array|mixed $path String file | configuration array | Konfig instance
     * @throws EmptyDirectoryException If `$path` is an empty directory
     */
    public function __construct($path, array $parsers = [])
    {
        $this->setFileParsers($parsers);

        $paths = $this->getValidPath($path);

        $this->data = [];

        foreach ($paths as $path) {
            // Get file information
            $info = pathinfo($path);
            // $info  = pathinfo($path, PATHINFO_EXTENSION);
            $parts = explode('.', $info['basename']);
            $ext   = array_pop($parts);

            if ($ext === 'dist') {
                $ext = array_pop($parts);
            }

            $parser = $this->getParser($ext);

            // Try and load file
            $this->data = array_replace_recursive($this->data, (array) $parser->parse($path));

            self::$loadedFiles[$path] = true;
        }

        parent::__construct($this->data);
    }

    /**
     * Static method for loading a Konfig instance.
     *
     * @param  string|array|mixed $path string file | configuration array | Konfig instance
     * @return Konfig
     */
    public static function load($path = null)
    {
        return new static($path);
    }

    /**
     * Static method for getting loaded Konfig files.
     *
     * @return array
     */
    public static function loaded()
    {
        return self::$loadedFiles;
    }

    /**
     * Static method for getting all Konfig keys.
     *
     * @return array
     */
    public static function keys()
    {
        // @TODO: Fix this soon
    }

    /**
     * @return FileParser[]
     * @since 0.1
     */
    public function getFileParsers()
    {
        return $this->fileParsers;
    }

    /**
     * @return void
     * @since 0.1
     */
    protected function addFileParser(FileParser $fileParser)
    {
        $this->fileParsers[] = $fileParser;
    }

    /**
     * @return void
     * @since 0.1
     */
    protected function setFileParsers(array $fileParsers = [])
    {
        if (empty($fileParsers)) {
            $fileParsers = [
                new FileParser\Xml(),
                new FileParser\Ini(),
                new FileParser\Json(),
                new FileParser\Yaml(),
                new FileParser\Neon(),
                new FileParser\Toml(),
                new FileParser\Php(),
            ];
        }

        $this->fileParsers = [];

        foreach ($fileParsers as $fileParser) {
            $this->addFileParser($fileParser);
        }
    }

    /**
     * Gets a parser for a given file extension
     *
     * @param  string $ext
     * @return Konfig\FileParser
     * @throws UnsupportedFileFormatException If `$path` is an unsupported file format
     */
    private function getParser($ext)
    {
        $parser = null;

        if (empty($ext)) {
            // @TODO: Throw an exception.
        }

        $fileParsers = $this->getFileParsers();

        foreach ($fileParsers as $fileParser) {
            if (in_array($ext, $fileParser->getSupportedFileExtensions(), true)) {
                $parser = $fileParser;
                break;
            }
        }

        // If none exist, then throw an exception
        if (is_null($parser)) {
            throw new UnsupportedFileFormatException('Unsupported configuration format');
        }

        return $parser;
    }

    /**
     * Gets an array of paths
     *
     * @param array $path
     * @return array
     * @throws FileNotFoundException If a file is not found in `$path`
     */
    private function pathFromArray($path)
    {
        $paths = [];

        foreach ($path as $unverifiedPath) {
            try {
                // Check if `$unverifiedPath` is optional
                // If it exists, then it's added to the list
                // If it doesn't, it throws an exception which we catch
                if ($unverifiedPath[0] !== '?') {
                    $paths = array_merge($paths, $this->getValidPath($unverifiedPath));
                    continue;
                }

                $optionalPath = ltrim($unverifiedPath, '?');

                $paths = array_merge($paths, $this->getValidPath($optionalPath));
            } catch (FileNotFoundException $e) {
                // If `$unverifiedPath` is optional, then skip it
                if ($unverifiedPath[0] === '?') {
                    continue;
                }

                // Otherwise rethrow the exception
                throw $e;
            }
        }

        return $paths;
    }

    /**
     * Checks `$path` to see if it is either an array, a directory, or a file
     *
     * @param  string|array $path
     * @return array
     * @throws EmptyDirectoryException If `$path` is an empty directory
     * @throws FileNotFoundException If a file is not found at `$path`
     */
    private function getValidPath($path = null)
    {
        // If `$path` is array
        if (is_array($path)) {
            return $this->pathFromArray($path);
        }

        // If `$path` is a directory
        if (is_dir($path)) {
            $paths = glob($path . '/*.*');

            if (empty($paths)) {
                throw new EmptyDirectoryException("Configuration directory: [$path] is empty");
            }

            return $paths;
        }

        // If `$path` is not a file, throw an exception
        if (!file_exists($path)) {
            throw new FileNotFoundException("Configuration file: [$path] cannot be found");
        }

        return [$path];
    }

    /**
     * @return string
     * @since 0.1
     */
    public function __toString()
    {
        return 'Konfig';
    }
}

#: END OF ./src/Konfig.php FILE


1		<?php
2		/**
3		* Konfig
4		*
5		* Yet another simple configuration loader library.
6		*
7		* @author Xeriab Nabil (aka KodeBurner) <[email protected]>
8		* @license https://raw.github.com/xeriab/konfig/master/LICENSE MIT
9		* @link https://xeriab.github.io/projects/konfig
10		*/
11
12		namespace Exen\Konfig;
13
14		use Exen\Konfig\Exception\EmptyDirectoryException;
15		use Exen\Konfig\Exception\FileNotFoundException;
16		use Exen\Konfig\Exception\UnsupportedFileFormatException;
17
18		final class Konfig extends AbstractKonfig
19		{
20		/**
21		* @var FileParser[] $fileParsers Array of file parsers objects
22		* @since 0.1
23		*/
24		protected $fileParsers;
25
26		/**
27		* Stores loaded configuration files
28		*
29		* @var array $loadedFiles Array of loaded configuration files
30		* @since 0.1
31		*/
32		protected static $loadedFiles = [];
33
34		/**
35		* Loads a supported configuration file format.
36		*
37		* @param string\|array\|mixed $path String file \| configuration array \| Konfig instance
38		* @throws EmptyDirectoryException If `$path` is an empty directory
39		*/
40	33	public function __construct($path, array $parsers = [])
41		{
42	33	$this->setFileParsers($parsers);
43
44	33	$paths = $this->getValidPath($path);
45
46	24	$this->data = [];
47
48	24	foreach ($paths as $path) {
49		// Get file information
50	24	$info = pathinfo($path);
51		// $info = pathinfo($path, PATHINFO_EXTENSION);
52	24	$parts = explode('.', $info['basename']);
53	24	$ext = array_pop($parts);
54
55	24	if ($ext === 'dist') {
56	3	$ext = array_pop($parts);
57	2	}
58
59	24	$parser = $this->getParser($ext);
60
61		// Try and load file
62	21	$this->data = array_replace_recursive($this->data, (array) $parser->parse($path));
63
64	21	self::$loadedFiles[$path] = true;
65	14	}
66
67	21	parent::__construct($this->data);
68	21	}
69
70		/**
71		* Static method for loading a Konfig instance.
72		*
73		* @param string\|array\|mixed $path string file \| configuration array \| Konfig instance
74		* @return Konfig
75		*/
76	3	public static function load($path = null)
77		{
78	3	return new static($path);
79		}
80
81		/**
82		* Static method for getting loaded Konfig files.
83		*
84		* @return array
85		*/
86		public static function loaded()
87		{
88		return self::$loadedFiles;
89		}
90
91		/**
92		* Static method for getting all Konfig keys.
93		*
94		* @return array
95		*/
96		public static function keys()
97		{
98		// @TODO: Fix this soon
99		}
100
101		/**
102		* @return FileParser[]
103		* @since 0.1
104		*/
105		public function getFileParsers()
106		{
107		return $this->fileParsers;
108		}
109
110		/**
111		* @return void
112		* @since 0.1
113		*/
114		protected function addFileParser(FileParser $fileParser)
115		{
116		$this->fileParsers[] = $fileParser;
117		}
118
119		/**
120		* @return void
121		* @since 0.1
122		*/
123		protected function setFileParsers(array $fileParsers = [])
124		{
125		if (empty($fileParsers)) {
126		$fileParsers = [
127		new FileParser\Xml(),
128		new FileParser\Ini(),
129		new FileParser\Json(),
130		new FileParser\Yaml(),
131		new FileParser\Neon(),
132		new FileParser\Toml(),
133		new FileParser\Php(),
134		];
135		}
136
137		$this->fileParsers = [];
138
139		foreach ($fileParsers as $fileParser) {
140		$this->addFileParser($fileParser);
141		}
142		}
143
144		/**
145		* Gets a parser for a given file extension
146		*
147		* @param string $ext
148		* @return Konfig\FileParser
149		* @throws UnsupportedFileFormatException If `$path` is an unsupported file format
150		*/
151	27	private function getParser($ext)
152		{
153	27	$parser = null;
154
155	27	if (empty($ext)) {
156		// @TODO: Throw an exception.
157		}
158
159	27	$fileParsers = $this->getFileParsers();
160
161	27	foreach ($fileParsers as $fileParser) {
162	27	if (in_array($ext, $fileParser->getSupportedFileExtensions(), true)) {
163	21	$parser = $fileParser;
164	23	break;
165		}
166	18	}
167
168		// If none exist, then throw an exception
169	27	if (is_null($parser)) {
170	6	throw new UnsupportedFileFormatException('Unsupported configuration format');
171		}
172
173	21	return $parser;
174		}
175
176		/**
177		* Gets an array of paths
178		*
179		* @param array $path
180		* @return array
181		* @throws FileNotFoundException If a file is not found in `$path`
182		*/
183		private function pathFromArray($path)
184		{
185		$paths = [];
186
187		foreach ($path as $unverifiedPath) {
188		try {
189		// Check if `$unverifiedPath` is optional
190		// If it exists, then it's added to the list
191		// If it doesn't, it throws an exception which we catch
192		if ($unverifiedPath[0] !== '?') {
193		$paths = array_merge($paths, $this->getValidPath($unverifiedPath));
194		continue;
195		}
196
197		$optionalPath = ltrim($unverifiedPath, '?');
198
199		$paths = array_merge($paths, $this->getValidPath($optionalPath));
200		} catch (FileNotFoundException $e) {
201		// If `$unverifiedPath` is optional, then skip it
202		if ($unverifiedPath[0] === '?') {
203		continue;
204		}
205
206		// Otherwise rethrow the exception
207		throw $e;
208		}
209		}
210
211		return $paths;
212		}
213
214		/**
215		* Checks `$path` to see if it is either an array, a directory, or a file
216		*
217		* @param string\|array $path
218		* @return array
219		* @throws EmptyDirectoryException If `$path` is an empty directory
220		* @throws FileNotFoundException If a file is not found at `$path`
221		*/
222	30	private function getValidPath($path = null)
223		{
224		// If `$path` is array
225	30	if (is_array($path)) {
226	12	return $this->pathFromArray($path);
227		}
228
229		// If `$path` is a directory
230	30	if (is_dir($path)) {
231	6	$paths = glob($path . '/.');
232
233	6	if (empty($paths)) {
234	3	throw new EmptyDirectoryException("Configuration directory: [$path] is empty");
235		}
236
237	3	return $paths;
238		}
239
240		// If `$path` is not a file, throw an exception
241	24	if (!file_exists($path)) {
242	9	throw new FileNotFoundException("Configuration file: [$path] cannot be found");
243		}
244
245	21	return [$path];
246		}
247
248		/**
249		* @return string
250		* @since 0.1
251		*/
252		public function __toString()
253		{
254		return 'Konfig';
255		}
256		}
257
258		#: END OF ./src/Konfig.php FILE
259

xeriab / konfig

Push — master ( adf7fc...68b7f3 )

Konfig::pathFromArray() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like