allejo\stakx\Document\DataItem

Complexity

Total Complexity

22

Size/Duplication

Total Lines	191
Duplicated Lines	16.75 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

50%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	setDataTransformer()	0	5	1
A	evaluateFrontMatter()	11	30	4
A	buildPermalink()	0	3	1
A	readContents()	0	5	1
A	getContent()	0	4	1
A	isDraft()	0	4	1
A	createJail()	0	11	1
A	jsonSerialize()	0	4	1
A	getIterator()	0	4	1
A	offsetExists()	0	4	2
A	offsetGet()	21	21	5
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1

<?php

/**
 * @copyright 2018 Vladimir Jimenez
 * @license   https://github.com/stakx-io/stakx/blob/master/LICENSE.md MIT
 */

namespace allejo\stakx\Document;

use allejo\stakx\DataTransformer\DataTransformerInterface;
use allejo\stakx\DataTransformer\DataTransformerManager;
use allejo\stakx\Filesystem\File;
use allejo\stakx\FrontMatter\FrontMatterParser;

class DataItem extends ReadableDocument implements CollectableItem, TemplateReadyDocument, PermalinkDocument
{
    use CollectableItemTrait;
    use PermalinkDocumentTrait;

    /** @var DataTransformerInterface */
    protected $dataTransformer;

    /** @var array */
    protected $frontMatter;

    /** @var array */
    protected $data;

    /**
     * DataItem constructor.
     */
    public function __construct(File $file)
    {
        $this->noReadOnConstructor = true;

        parent::__construct($file);
    }

    /**
     * Set the transformer used to convert the file contents into an array,.
     */
    public function setDataTransformer(DataTransformerManager $manager)
    {
        $this->dataTransformer = $manager->getTransformer($this->getExtension());
        $this->readContent();
    }

    /**
     * {@inheritdoc}
     */
    public function evaluateFrontMatter(array $variables = [], array $complexVariables = [])
    {
        $this->frontMatter = array_merge($this->data, $variables);
        $parser = new FrontMatterParser($this->frontMatter, [
            'basename' => $this->getBasename(),
            'filename' => $this->getFileName(),
            'filePath' => $this->getRelativeFilePath(),
        ]);
        $parser->addComplexVariables($complexVariables);
        $parser->parse();

        if (!is_null($parser) && $parser->hasExpansion())
        {
            throw new \LogicException('The permalink for this item has not been set.');
        }

        $permalink = $this->frontMatter['permalink'];

        if (is_array($permalink))

This code seems to be duplicated across your project.

        {
            $this->permalink = $permalink[0];
            array_shift($permalink);
            $this->redirects = $permalink;
        }
        else
        {
            $this->permalink = $permalink;
            $this->redirects = [];
        }
    }

    /**
     * {@inheritdoc}
     */
    public function buildPermalink($force = false)
    {
    }

    /**
     * {@inheritdoc}
     */
    public function readContents($mixed)
    {
        $content = $this->file->getContents();
        $this->data = $this->dataTransformer->transformData($content);
    }

    /**
     * {@inheritdoc}
     */
    public function getContent()
    {
        return $this->data;

The return type of return $this->data; (array) is incompatible with the return type of the parent method allejo\stakx\Document\ReadableDocument::getContent of type string.

    }

    /**
     * {@inheritdoc}
     */
    public function isDraft()
    {
        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function createJail()
    {
        $whiteListedFunctions = array_merge(FrontMatterDocument::$whiteListedFunctions, [
        ]);

        $jailedFunctions = [
            'getDataset' => 'getNamespace',
        ];

        return new JailedDocument($this, $whiteListedFunctions, $jailedFunctions);
    }

    ///
    // JsonSerializable implementation
    ///

    /**
     * {@inheritdoc}
     */
    public function jsonSerialize()
    {
        return $this->data;
    }

    ///
    // IteratorAggregate implementation
    ///

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

    ///
    // ArrayAccess implementation
    ///

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

    /**
     * {@inheritdoc}
     */
    public function offsetGet($offset)

This method seems to be duplicated in your project.

    {
        $fxnCall = 'get' . ucfirst($offset);

        if (in_array($fxnCall, FrontMatterDocument::$whiteListedFunctions) && method_exists($this, $fxnCall))
        {
            return call_user_func_array([$this, $fxnCall], []);
        }

        if (isset($this->data[$offset]))
        {
            return $this->data[$offset];
        }

        if (isset($this->frontMatter[$offset]))
        {
            return $this->frontMatter[$offset];
        }

        return null;
    }

    /**
     * {@inheritdoc}
     */
    public function offsetSet($offset, $value)
    {
        throw new \LogicException('DataItems are read-only.');
    }

    /**
     * {@inheritdoc}
     */
    public function offsetUnset($offset)
    {
        throw new \LogicException('DataItems are read-only.');
    }
}