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

Completed

Push — master ( b06bec...8d39d6 )

by Xeriab

created 2016-10-11 23:22 UTC

Konfig::setFileParsers() A

↳ Parent: Konfig

Complexity

Conditions	3
Paths	4

Size

Total Lines	20
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes

Metric	Value
dl	0
loc	20
ccs	0
cts	16
cp	0
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	13
nc	4
nop	1
crap	12

<?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\Exception;
use Exen\Konfig\Exception\EmptyDirectoryException;
use Exen\Konfig\Exception\FileNotFoundException;
use Exen\Konfig\Exception\UnsupportedFileFormatException;

use Exen\Konfig\Arr;

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

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

    /**
     * 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 = null, 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;
        }
        
        self::$loadedData = $this->data;

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

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

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

    /**
     * Static method for getting all Konfig keys.
     *
     * @codeCoverageIgnore
     * @return array
     */
    public static function keys()
    {
        return Arr::recursiveKeys(self::$loadedData);
    }

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

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

    /**
     * @return void
     * @since 0.1.0
     */
    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 File extension
     * @return Konfig\FileParser
     * @throws Exception If `$ext` is empty
     * @throws UnsupportedFileFormatException If `$path` is an unsupported file format
     */
    private function getParser($ext = null)
    {
        $parser = null;

        if (empty($ext)) {
            throw new Exception('Files with empty extensions are not allowed');
        }

        $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 Path to analyze and handle
     * @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 Path to analyze and handle
     * @return array
     * @throws EmptyDirectoryException If `$path` is an empty directory
     * @throws FileNotFoundException If a file is not found at `$path`
     */
    private function getValidPath($path)
    {
        // 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
     * @codeCoverageIgnore
     * @since 0.1.2
     */
    public function __toString()
    {
        return 'Exen\Konfig\Konfig' . PHP_EOL;
    }
}

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


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

xeriab / konfig

Push — master ( b06bec...8d39d6 )

Konfig::setFileParsers() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like