FileLoader::checkAndAddDefaultDecoder() - Code Metrics - chrismichaels84/data-manager - Measure and Improve Code Quality continuously with Scrutinizer

FileLoader::checkAndAddDefaultDecoder() A
last analyzed 2017-03-08 22:15 UTC

↳ Parent: FileLoader

Complexity

Conditions	3
Paths	2

Size

Total Lines	11
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	11
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	7
nc	2
nop	1

<?php
namespace Michaels\Manager;

use Michaels\Manager\Contracts\DecoderInterface;
use Michaels\Manager\Bags\FileBag;
use Michaels\Manager\Exceptions\UnsupportedFilesException;
use Michaels\Manager\Exceptions\BadFileDataException;
use Exception;

/**
 * Loads configuration files and converts them to php arrays using Decoders
 * @package Michaels\Manager
 */
class FileLoader
{
    /**
     * The data which will be decoded.
     * @var array
     */
    protected $dataToDecode = [];

    /**
     * The array of supported Mime types, which is defined in each decoder class.
     * @var array
     */
    protected $supportedMimeTypes = [];

    /**
     * A container for the SPLFileInfo objects
     * @var FileBag
     */
    protected $fileBag;

    /**
     * An array holding data about the loaded decoders.
     * @var array
     */
    protected $decoders = [];

    /**
     * Should there be an attempt to load an unsupported file type (determined by the mime types array), then they
     * will be stored in this array for later display in an error message.
     *
     * @var array
     */
    protected $unsupportedFiles = [];

    /**
     * The data array, once it has been processed through a decoder.
     * @var array
     */
    protected $decodedData = [];

    /**
     * Add a file decoder to the FileLoader
     * @param DecoderInterface $decoder
     */
    public function addDecoder(DecoderInterface $decoder)
    {
        $mimeTypes = $decoder->getMimeType();
        if ($this->isSupportedMimeType($mimeTypes[0])) {
            return; // we already have the decoder loaded!
        }
        $this->supportedMimeTypes = array_merge($this->supportedMimeTypes, $mimeTypes);
        foreach ($mimeTypes as $type) {
            $this->decoders[$type] = $decoder;
        }
    }

    /**
     * Add a file bag, or change an array of SplFileInfo Objects to proper objects.
     *
     * @param mixed $files a FileBag or an array of SplFileInfo objects.
     */
    public function addFiles($files)
    {
        if ($files instanceof FileBag) {
            $this->fileBag = $files;
            return;
        }

        if (is_array($files)) {
            $this->fileBag = new FileBag($files);
            return;
        }
        throw new BadFileDataException('The attempt at adding files to the file loader failed, due to the files not
        being a FileBag Object or an array of SplInfoObjects.');
    }

    /**
     * Process the current FileBag and return an array
     * @param bool $ns
     * @param bool $strict
     * @return array
     */
    public function process($ns = true, $strict = true)
    {
        return $this->decodedData = $this->decodeFileBagData($this->fileBag, $ns, $strict);
    }

    /**
     * Process file bag to load into the data manager.
     * A file bag is an array of SplFileInfo objects.
     *
     * @param array|FileBag $fileBag
     * @param bool $ns
     * @param bool $strict
     * @return array
     * @throws Exception
     */
    public function decodeFileBagData(FileBag $fileBag, $ns = true, $strict = true)
    {
        $decodedData = [];
        $files = $fileBag->getAllFileInfoObjects();
        if (empty($files)) {
            throw new Exception("FileBag is empty. Make sure you have initialized the FileLoader and added files.");
        }

        foreach ($files as $file) {
            list($namespace, $file) = $this->getFilesNamespace($file);

            // Decode the actual file and save data
            $fileData = $this->decodeFile($file, $strict);
            if (is_array($fileData)) {
                foreach ($fileData as $k => $v) {
                    if ($ns === true) {
                        $decodedData[$namespace][$k] = $v;
                    } else {
                        $decodedData[$k] = $v;
                    }
                }
            }
        }

        if (!empty($this->unsupportedFiles)) {
            $badFiles = implode(", ", $this->unsupportedFiles);
            throw new UnsupportedFilesException(
                'The file(s) ' . $badFiles . ' are not supported by the available decoders.'
            );
        }

        return $decodedData;
    }

    /**
     * Check to make sure the mime type is ok.
     * @param string $type A mime type
     * @return bool
     */
    protected function isSupportedMimeType($type)
    {
        return in_array($type, $this->supportedMimeTypes);
    }

    /**
     * Returns the contents of the file.
     *
     * @param \SplFileInfo $file
     * @return string the contents of the file
     */
    public function getFileContents(\SplFileInfo $file)
    {
        if ($file->getExtension() === 'php') {
            $content = include $file->getPathname();
            return $content;
        }

        $level = error_reporting(0);
        $content = file_get_contents($file->getPathname());
        error_reporting($level);
        if (false === $content) {
            $error = error_get_last();
            throw new \RuntimeException($error['message']);
        }
        return $content;
    }

    /**
     * Default decoder class factory method.
     * Checks to make sure we have a default decoder available and if so, adds it as a decoder to the file loader.
     *
     * @param $mimeType
     */
    protected function checkAndAddDefaultDecoder($mimeType)
    {
        $decoderClass = ucfirst($mimeType) . "Decoder";

        if (file_exists(__DIR__ . '/Decoders/' . $decoderClass . '.php') && !$this->isSupportedMimeType($mimeType)) {
            $nameSpace = "Michaels\\Manager\\Decoders\\";
            $fullQualifiedClassName = $nameSpace . $decoderClass;
            $decoder = new $fullQualifiedClassName();
            $this->addDecoder($decoder);
        }
    }

    /**
     * Decodes a single file using registered decoders
     * @param \SplFileInfo $file
     * @param bool $strict
     * @return array|bool
     * @throws Exception
     */
    protected function decodeFile(\SplFileInfo $file, $strict = true)
    {
        $mimeType = $file->getExtension();

        $this->checkAndAddDefaultDecoder($mimeType);

        if ($this->isSupportedMimeType($mimeType)) {

            if (is_readable($file->getPathname())) {
                $data = $this->getFileContents($file);
            } else {
                if ($strict) {
                    throw new \Exception("File not found: {$file->getPathname()}");
                } else {
                    return [];
                }
            }

            return $this->decoders[$mimeType]->decode($data);
        }

        $this->unsupportedFiles[] = $file->getFilename();
        return false;
    }

    /**
     * Returns currently attached custom decoders
     * @return array
     */
    public function getDecoders()
    {
        return $this->decoders;
    }

    /**
     * Returns currently supported Mime Types
     * @return array
     */
    public function getMimeTypes()
    {
        return $this->supportedMimeTypes;
    }

    /**
     * Cleans up a file name for use as a namespace
     * @param $ns
     * @return mixed
     */
    public function sanitizeNamespace($ns)
    {
        // dots to underscores
        $ns = str_replace(".", "_", $ns);

        // spaces to underscores
        $ns = str_replace(" ", "_", $ns);

        // dashes to underscores
        $ns = str_replace("-", "_", $ns);

        // Alpha numeric
        $ns = preg_replace("/[^A-Za-z0-9\.\_\- ]/", '', $ns);

        return $ns;
    }

    /**
     * Gets or creates the file's namespace
     * @param $file
     * @return array with the namespace and fileobject
     */
    protected function getFilesNamespace($file)
    {
        $namespace = null;

        if (is_array($file)) {
            // We are using a custom namespace
            $namespace = $this->sanitizeNamespace($file[1]);
            $file = $file[0];
            return [$namespace, $file];

        } else {
            // We are namespacing using the file's name
            $filename = rtrim($file->getBasename(), '.' . $file->getExtension());
            $namespace = $this->sanitizeNamespace($filename);
            return [$namespace, $file];
        }
    }
}


1			<?php
2			namespace Michaels\Manager;
3
4			use Michaels\Manager\Contracts\DecoderInterface;
5			use Michaels\Manager\Bags\FileBag;
6			use Michaels\Manager\Exceptions\UnsupportedFilesException;
7			use Michaels\Manager\Exceptions\BadFileDataException;
8			use Exception;
9
10			/**
11			* Loads configuration files and converts them to php arrays using Decoders
12			* @package Michaels\Manager
13			*/
14			class FileLoader
15			{
16			/**
17			* The data which will be decoded.
18			* @var array
19			*/
20			protected $dataToDecode = [];
21
22			/**
23			* The array of supported Mime types, which is defined in each decoder class.
24			* @var array
25			*/
26			protected $supportedMimeTypes = [];
27
28			/**
29			* A container for the SPLFileInfo objects
30			* @var FileBag
31			*/
32			protected $fileBag;
33
34			/**
35			* An array holding data about the loaded decoders.
36			* @var array
37			*/
38			protected $decoders = [];
39
40			/**
41			* Should there be an attempt to load an unsupported file type (determined by the mime types array), then they
42			* will be stored in this array for later display in an error message.
43			*
44			* @var array
45			*/
46			protected $unsupportedFiles = [];
47
48			/**
49			* The data array, once it has been processed through a decoder.
50			* @var array
51			*/
52			protected $decodedData = [];
53
54			/**
55			* Add a file decoder to the FileLoader
56			* @param DecoderInterface $decoder
57			*/
58			public function addDecoder(DecoderInterface $decoder)
59			{
60			$mimeTypes = $decoder->getMimeType();
61			if ($this->isSupportedMimeType($mimeTypes[0])) {
62			return; // we already have the decoder loaded!
63			}
64			$this->supportedMimeTypes = array_merge($this->supportedMimeTypes, $mimeTypes);
65			foreach ($mimeTypes as $type) {
66			$this->decoders[$type] = $decoder;
67			}
68			}
69
70			/**
71			* Add a file bag, or change an array of SplFileInfo Objects to proper objects.
72			*
73			* @param mixed $files a FileBag or an array of SplFileInfo objects.
74			*/
75			public function addFiles($files)
76			{
77			if ($files instanceof FileBag) {
78			$this->fileBag = $files;
79			return;
80			}
81
82			if (is_array($files)) {
83			$this->fileBag = new FileBag($files);
84			return;
85			}
86			throw new BadFileDataException('The attempt at adding files to the file loader failed, due to the files not
87			being a FileBag Object or an array of SplInfoObjects.');
88			}
89
90			/**
91			* Process the current FileBag and return an array
92			* @param bool $ns
93			* @param bool $strict
94			* @return array
95			*/
96			public function process($ns = true, $strict = true)
97			{
98			return $this->decodedData = $this->decodeFileBagData($this->fileBag, $ns, $strict);
99			}
100
101			/**
102			* Process file bag to load into the data manager.
103			* A file bag is an array of SplFileInfo objects.
104			*
105			* @param array\|FileBag $fileBag
106			* @param bool $ns
107			* @param bool $strict
108			* @return array
109			* @throws Exception
110			*/
111			public function decodeFileBagData(FileBag $fileBag, $ns = true, $strict = true)
112			{
113			$decodedData = [];
114			$files = $fileBag->getAllFileInfoObjects();
115			if (empty($files)) {
116			throw new Exception("FileBag is empty. Make sure you have initialized the FileLoader and added files.");
117			}
118
119			foreach ($files as $file) {
120			list($namespace, $file) = $this->getFilesNamespace($file);
121
122			// Decode the actual file and save data
123			$fileData = $this->decodeFile($file, $strict);
124			if (is_array($fileData)) {
125			foreach ($fileData as $k => $v) {
126			if ($ns === true) {
127			$decodedData[$namespace][$k] = $v;
128			} else {
129			$decodedData[$k] = $v;
130			}
131			}
132			}
133			}
134
135			if (!empty($this->unsupportedFiles)) {
136			$badFiles = implode(", ", $this->unsupportedFiles);
137			throw new UnsupportedFilesException(
138			'The file(s) ' . $badFiles . ' are not supported by the available decoders.'
139			);
140			}
141
142			return $decodedData;
143			}
144
145			/**
146			* Check to make sure the mime type is ok.
147			* @param string $type A mime type
148			* @return bool
149			*/
150			protected function isSupportedMimeType($type)
151			{
152			return in_array($type, $this->supportedMimeTypes);
153			}
154
155			/**
156			* Returns the contents of the file.
157			*
158			* @param \SplFileInfo $file
159			* @return string the contents of the file
160			*/
161			public function getFileContents(\SplFileInfo $file)
162			{
163			if ($file->getExtension() === 'php') {
164			$content = include $file->getPathname();
165			return $content;
166			}
167
168			$level = error_reporting(0);
169			$content = file_get_contents($file->getPathname());
170			error_reporting($level);
171			if (false === $content) {
172			$error = error_get_last();
173			throw new \RuntimeException($error['message']);
174			}
175			return $content;
176			}
177
178			/**
179			* Default decoder class factory method.
180			* Checks to make sure we have a default decoder available and if so, adds it as a decoder to the file loader.
181			*
182			* @param $mimeType
183			*/
184			protected function checkAndAddDefaultDecoder($mimeType)
185			{
186			$decoderClass = ucfirst($mimeType) . "Decoder";
187
188			if (file_exists(__DIR__ . '/Decoders/' . $decoderClass . '.php') && !$this->isSupportedMimeType($mimeType)) {
189			$nameSpace = "Michaels\\Manager\\Decoders\\";
190			$fullQualifiedClassName = $nameSpace . $decoderClass;
191			$decoder = new $fullQualifiedClassName();
192			$this->addDecoder($decoder);
193			}
194			}
195
196			/**
197			* Decodes a single file using registered decoders
198			* @param \SplFileInfo $file
199			* @param bool $strict
200			* @return array\|bool
201			* @throws Exception
202			*/
203			protected function decodeFile(\SplFileInfo $file, $strict = true)
204			{
205			$mimeType = $file->getExtension();
206
207			$this->checkAndAddDefaultDecoder($mimeType);
208
209			if ($this->isSupportedMimeType($mimeType)) {
210
211			if (is_readable($file->getPathname())) {
212			$data = $this->getFileContents($file);
213			} else {
214			if ($strict) {
215			throw new \Exception("File not found: {$file->getPathname()}");
216			} else {
217			return [];
218			}
219			}
220
221			return $this->decoders[$mimeType]->decode($data);
222			}
223
224			$this->unsupportedFiles[] = $file->getFilename();
225			return false;
226			}
227
228			/**
229			* Returns currently attached custom decoders
230			* @return array
231			*/
232			public function getDecoders()
233			{
234			return $this->decoders;
235			}
236
237			/**
238			* Returns currently supported Mime Types
239			* @return array
240			*/
241			public function getMimeTypes()
242			{
243			return $this->supportedMimeTypes;
244			}
245
246			/**
247			* Cleans up a file name for use as a namespace
248			* @param $ns
249			* @return mixed
250			*/
251			public function sanitizeNamespace($ns)
252			{
253			// dots to underscores
254			$ns = str_replace(".", "_", $ns);
255
256			// spaces to underscores
257			$ns = str_replace(" ", "_", $ns);
258
259			// dashes to underscores
260			$ns = str_replace("-", "_", $ns);
261
262			// Alpha numeric
263			$ns = preg_replace("/[^A-Za-z0-9\.\_\- ]/", '', $ns);
264
265			return $ns;
266			}
267
268			/**
269			* Gets or creates the file's namespace
270			* @param $file
271			* @return array with the namespace and fileobject
272			*/
273			protected function getFilesNamespace($file)
274			{
275			$namespace = null;
276
277			if (is_array($file)) {
278			// We are using a custom namespace
279			$namespace = $this->sanitizeNamespace($file[1]);
280			$file = $file[0];
281			return [$namespace, $file];
282
283			} else {
284			// We are namespacing using the file's name
285			$filename = rtrim($file->getBasename(), '.' . $file->getExtension());
286			$namespace = $this->sanitizeNamespace($filename);
287			return [$namespace, $file];
288			}
289			}
290			}
291

chrismichaels84 / data-manager

FileLoader::checkAndAddDefaultDecoder() A last analyzed 2017-03-08 22:15 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

FileLoader::checkAndAddDefaultDecoder() A
last analyzed 2017-03-08 22:15 UTC