allejo\stakx\Document\DataItem

Complexity

Total Complexity

28

Size/Duplication

Total Lines	236
Duplicated Lines	1.69 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	16	2
A	getIterator()	0	4	1
A	createJail()	0	6	1
A	offsetExists()	0	4	1
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	getNamespace()	0	4	1
A	setNamespace()	0	4	1
A	getExtension()	0	4	1
A	getFilePath()	0	4	1
A	getName()	0	4	1
A	getRelativeFilePath()	0	10	2
A	refreshFileContent()	4	21	4
A	fromCsv()	0	13	2
A	fromJson()	0	4	1
A	fromXml()	0	4	1
A	fromYaml()	0	4	1
A	fromYml()	0	4	1
A	handleDependencies()	0	7	3

<?php

/**
 * @copyright 2017 Vladimir Jimenez
 * @license   https://github.com/allejo/stakx/blob/master/LICENSE.md MIT
 */

namespace allejo\stakx\Document;

use allejo\stakx\Exception\DependencyMissingException;
use allejo\stakx\Exception\UnsupportedDataTypeException;
use allejo\stakx\System\Filesystem;
use Symfony\Component\Filesystem\Exception\FileNotFoundException;
use Symfony\Component\Finder\SplFileInfo;
use Symfony\Component\Yaml\Yaml;

class DataItem implements
    \ArrayAccess,
    \IteratorAggregate,
    TwigDocumentInterface,
    JailedDocumentInterface
{
    protected $data;

    private $fileExtension;
    private $namespace;
    private $fileName;
    private $filePath;
    private $fs;

Avoid variables with short names like $fs. Configured minimum length is 3.

    public function __construct($filePath)
    {
        $this->fs = new Filesystem();

        if (!$this->fs->exists($filePath))
        {
            throw new FileNotFoundException("The following file could not be found: ${filePath}");
        }

        $this->fileExtension = strtolower($this->fs->getExtension($filePath));
        $this->fileName = $this->fs->getBaseName($filePath);
        $this->filePath = $filePath;
        $this->namespace = '';

        $this->refreshFileContent();
    }

    public function getIterator()
    {
        return new \ArrayIterator($this->data);
    }

    ///
    // Jailed Document implementation
    ///

    /**
     * {@inheritdoc}
     */
    public function createJail()
    {
        return new JailedDocument($this, array(
            'getExtension', 'getFilePath', 'getName', 'getRelativeFilePath'
        ));
    }

    ///
    // ArrayAccess implementation
    ///

    /**
     * {@inheritdoc}
     */
    public function offsetExists($offset)
    {
        return isset($this->data[$offset]);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetGet($offset)
    {
        return $this->data[$offset];
    }

    /**
     * {@inheritdoc}
     */
    public function offsetSet($offset, $value)
    {
        $this->data[$offset] = $value;
    }

    /**
     * {@inheritdoc}
     */
    public function offsetUnset($offset)
    {
        unset($this->data[$offset]);
    }

    ///
    // Twig Document implementation
    ///

    public function getNamespace()
    {
        return $this->namespace;
    }

    public function setNamespace($namespace)
    {
        $this->namespace = $namespace;
    }

    public function getExtension()
    {
        return $this->fileExtension;
    }

    public function getFilePath()
    {
        return $this->filePath;
    }

    public function getName()
    {
        return $this->fileName;
    }

    public function getRelativeFilePath()
    {
        if ($this->filePath instanceof SplFileInfo)
        {
            return $this->filePath->getRelativePathname();
        }

        // TODO ensure that we always get SplFileInfo objects, even when handling VFS documents
        return $this->fs->getRelativePath($this->filePath);
    }

    public function refreshFileContent()
    {
        // This function can be called after the initial object was created and the file may have been deleted since the
        // creation of the object.
        if (!$this->fs->exists($this->filePath))

This code seems to be duplicated across your project.

        {
            throw new FileNotFoundException(null, 0, null, $this->filePath);
        }

        $content = file_get_contents($this->getFilePath());
        $fxnName = 'from' . ucfirst($this->getExtension());

        if (method_exists(get_called_class(), $fxnName))
        {
            $this->data = (null !== ($c = $this->$fxnName($content))) ? $c : array();

Avoid variables with short names like $c. Configured minimum length is 3.

            return;
        }

        throw new UnsupportedDataTypeException($this->getExtension(), "There is no support to handle this file extension.");

The string literal There is no support to handle this file extension. does not require double quotes, as per coding-style, please use single quotes.

    }

    ///
    // File parsing helpers
    ///

    /**
     * Convert from CSV into an associative array.
     *
     * @param string $content CSV formatted text
     *
     * @return array
     */
    private function fromCsv($content)
    {
        $rows = array_map('str_getcsv', explode("\n", trim($content)));
        $columns = array_shift($rows);
        $csv = array();

        foreach ($rows as $row)
        {
            $csv[] = array_combine($columns, $row);
        }

        return $csv;
    }

    /**
     * Convert from JSON into an associative array.
     *
     * @param string $content JSON formatted text
     *
     * @return array
     */
    private function fromJson($content)
    {
        return json_decode($content, true);
    }

    /**
     * Convert from XML into an associative array.
     *
     * @param string $content XML formatted text
     *
     * @return array
     */
    private function fromXml($content)
    {
        return json_decode(json_encode(simplexml_load_string($content)), true);
    }

    /**
     * Convert from YAML into an associative array.
     *
     * @param string $content YAML formatted text
     *
     * @return array

Should the return type not be string|array|\stdClass?

     */
    private function fromYaml($content)
    {
        return Yaml::parse($content, Yaml::PARSE_DATETIME);
    }

    /**
     * An alias for handling `*.yml` files.
     *
     * @param string $content YAML formatted text
     *
     * @return array

Should the return type not be string|array|\stdClass?

     */
    private function fromYml($content)
    {
        return $this->fromYaml($content);
    }

    /**
     * @param string $extension
     *
     * @todo 0.1.0 Create a help page on the main stakx website for this topic and link to it
     *
     * @throws DependencyMissingException
     */
    private function handleDependencies($extension)
    {
        if ($extension === 'xml' && !function_exists('simplexml_load_string'))
        {
            throw new DependencyMissingException('XML', 'XML support is not available with the current PHP installation.');
        }
    }
}