Document::offsetExists() - Code Metrics - Inspection of "Merge pull request #45 from stakx-io/feature/44-ou..." - stakx-io/stakx - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8dfbb4...5f3e12 )

by Vladimir

created 2017-04-09 21:04 UTC

Document::offsetExists() A

↳ Parent: Document

Complexity

Conditions	4
Paths	3

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	4

Importance

Changes

Metric	Value
cc	4
eloc	5
nc	3
nop	1
dl	0
loc	11
ccs	5
cts	5
cp	1
crap	4
rs	9.2
c	0
b	0
f	0

<?php

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

namespace allejo\stakx\FrontMatter;

use allejo\stakx\Document\JailedDocumentInterface;
use allejo\stakx\Exception\FileAwareException;
use allejo\stakx\Exception\InvalidSyntaxException;
use allejo\stakx\FrontMatter\Exception\YamlVariableUndefinedException;
use allejo\stakx\System\Filesystem;
use Symfony\Component\Filesystem\Exception\FileNotFoundException;
use Symfony\Component\Filesystem\Exception\IOException;
use Symfony\Component\Finder\SplFileInfo;
use Symfony\Component\Yaml\Exception\ParseException;
use Symfony\Component\Yaml\Yaml;

abstract class Document implements WritableDocumentInterface, JailedDocumentInterface, \ArrayAccess

{
    const TEMPLATE = "---\n%s\n---\n\n%s";

    protected static $whiteListFunctions = array(
        'getPermalink', 'getRedirects', 'getTargetFile', 'getName', 'getFilePath', 'getRelativeFilePath', 'getContent',
        'getExtension', 'getFrontMatter'
    );

    /**
     * An array to keep track of collection or data dependencies used inside of a Twig template.
     *
     * $dataDependencies['collections'] = array()
     * $dataDependencies['data'] = array()
     *
     * @var array
     */
    protected $dataDependencies;

    /**
     * FrontMatter values that can be injected or set after the file has been parsed. Values in this array will take
     * precedence over values in $frontMatter.
     *
     * @var array
     */
    protected $writableFrontMatter;

    /**
     * A list of Front Matter values that should not be returned directly from the $frontMatter array. Values listed
     * here have dedicated functions that handle those Front Matter values and the respective functions should be called
     * instead.
     *
     * @var string[]
     */
    protected $frontMatterBlacklist;

    /**
     * Set to true if the front matter has already been evaluated with variable interpolation.
     *
     * @var bool
     */
    protected $frontMatterEvaluated;

    /**
     * @var Parser
     */
    protected $frontMatterParser;

    /**
     * An array containing the Yaml of the file.
     *
     * @var array
     */
    protected $frontMatter;

    /**
     * Set to true if the body has already been parsed as markdown or any other format.
     *
     * @var bool
     */
    protected $bodyContentEvaluated;

    /**
     * Only the body of the file, i.e. the content.
     *
     * @var string
     */
    protected $bodyContent;

    /**
     * The permalink for this object.
     *
     * @var string
     */
    protected $permalink;

    /**
     * A filesystem object.
     *
     * @var Filesystem
     */
    protected $fs;


    /**
     * The extension of the file.
     *
     * @var string
     */
    private $extension;

    /**
     * The number of lines that Twig template errors should offset.
     *
     * @var int
     */
    private $lineOffset;

    /**
     * A list URLs that will redirect to this object.
     *
     * @var string[]
     */
    private $redirects;

    /**
     * The original file path to the ContentItem.
     *
     * @var SplFileInfo
     */
    private $filePath;

    /**
     * ContentItem constructor.
     *
     * @param string $filePath The path to the file that will be parsed into a ContentItem
     *
     * @throws FileNotFoundException The given file path does not exist
     * @throws IOException           The file was not a valid ContentItem. This would meam there was no front matter or
     *                               no body
     */
    public function __construct($filePath)
    {
        $this->frontMatterBlacklist = array('permalink', 'redirects');
        $this->writableFrontMatter = array();

        $this->filePath = $filePath;

        $this->fs = new Filesystem();

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

        $this->extension = strtolower($this->fs->getExtension($filePath));

        $this->refreshFileContent();
    }

    /**
     * Return the body of the Content Item.
     *
     * @return string
     */
    abstract public function getContent();

    /**
     * Get the extension of the current file.
     *
     * @return string
     */
    final public function getExtension()
    {
        return $this->extension;
    }

    /**
     * Get the original file path.
     *
     * @return string

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

    /**
     * The number of lines that are taken up by FrontMatter and white space.
     *
     * @return int
     */
    final public function getLineOffset()
    {
        return $this->lineOffset;
    }

    /**
     * Get the name of the item, which is just the file name without the extension.
     *
     * @return string
     */
    final public function getName()
    {
        return $this->fs->getBaseName($this->filePath);
    }

    /**
     * Get the relative path to this file relative to the root of the Stakx website.
     *
     * @return string
     */
    final 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);
    }

    /**
     * Get the destination of where this Content Item would be written to when the website is compiled.
     *
     * @return string
     */
    final public function getTargetFile()
    {
        $permalink = $this->getPermalink();
        $missingFile = (substr($permalink, -1) == '/');
        $permalink = str_replace('/', DIRECTORY_SEPARATOR, $permalink);

        if ($missingFile)
        {
            $permalink = rtrim($permalink, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . 'index.html';
        }

        return ltrim($permalink, DIRECTORY_SEPARATOR);
    }

    /**
     * Check whether this object has a reference to a collection or data item.
     *
     * @param string $namespace 'collections' or 'data'
     * @param string $needle
     *
     * @return bool
     */
    final public function hasTwigDependency($namespace, $needle)
    {
        return in_array($needle, $this->dataDependencies[$namespace]);
    }

    /**
     * Read the file, and parse its contents.
     */
    final 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))
        {
            throw new FileNotFoundException(null, 0, null, $this->filePath);
        }

        $rawFileContents = file_get_contents($this->filePath);
        $fileStructure = array();
        preg_match('/---\R(.*?\R)?---(\s+)(.*)/s', $rawFileContents, $fileStructure);

        if (count($fileStructure) != 4)
        {
            throw new InvalidSyntaxException('Invalid FrontMatter file', 0, null, $this->getRelativeFilePath());
        }

        if (empty(trim($fileStructure[3])))
        {
            throw new InvalidSyntaxException('FrontMatter files must have a body to render', 0, null, $this->getRelativeFilePath());
        }

        $this->lineOffset = substr_count($fileStructure[1], "\n") + substr_count($fileStructure[2], "\n");
        $this->bodyContent = $fileStructure[3];

        if (!empty(trim($fileStructure[1])))
        {
            $this->frontMatter = Yaml::parse($fileStructure[1], Yaml::PARSE_DATETIME);
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

            if (!empty($this->frontMatter) && !is_array($this->frontMatter))
            {
                throw new ParseException('The evaluated FrontMatter should be an array');
            }
        }
        else
        {
            $this->frontMatter = array();
        }

        $this->frontMatterEvaluated = false;
        $this->bodyContentEvaluated = false;
        $this->permalink = null;

        $this->findTwigDataDependencies('collections');
        $this->findTwigDataDependencies('data');
    }

    /**
     * Get all of the references to either DataItems or ContentItems inside of given string.
     *
     * @param string $filter 'collections' or 'data'
     */
    private function findTwigDataDependencies($filter)
    {
        $regex = '/{[{%](?:.+)?(?:' . $filter . ')(?:\.|\[\')(\w+)(?:\'\])?.+[%}]}/';
        $results = array();

        preg_match_all($regex, $this->bodyContent, $results);

        $this->dataDependencies[$filter] = array_unique($results[1]);
    }

    //
    // Permalink and redirect functionality
    //

    /**
     * Get the permalink of this Content Item.
     *
     * @throws \Exception
     *
     * @return string
     */
    final public function getPermalink()
    {
        if (!is_null($this->permalink))
        {
            return $this->permalink;
        }

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

        $permalink = (is_array($this->frontMatter) && isset($this->frontMatter['permalink'])) ?
            $this->frontMatter['permalink'] : $this->getPathPermalink();

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

        $this->permalink = $this->sanitizePermalink($this->permalink);
        $this->permalink = str_replace(DIRECTORY_SEPARATOR, '/', $this->permalink);
        $this->permalink = '/' . ltrim($this->permalink, '/'); // Permalinks should always use '/' and not be OS specific

        return $this->permalink;
    }

    /**
     * Get an array of URLs that will redirect to.
     *
     * @return string[]

     */
    final public function getRedirects()
    {
        if (is_null($this->redirects))
        {
            $this->getPermalink();
        }

        return $this->redirects;
    }

    /**
     * Get the permalink based off the location of where the file is relative to the website. This permalink is to be
     * used as a fallback in the case that a permalink is not explicitly specified in the Front Matter.
     *
     * @return string
     */
    private function getPathPermalink()
    {
        // Remove the protocol of the path, if there is one and prepend a '/' to the beginning
        $cleanPath = preg_replace('/[\w|\d]+:\/\//', '', $this->getRelativeFilePath());
        $cleanPath = ltrim($cleanPath, DIRECTORY_SEPARATOR);

        // Handle vfs:// paths by replacing their forward slashes with the OS appropriate directory separator
        if (DIRECTORY_SEPARATOR !== '/')
        {
            $cleanPath = str_replace('/', DIRECTORY_SEPARATOR, $cleanPath);
        }

        // Check the first folder and see if it's a data folder (starts with an underscore) intended for stakx
        $folders = explode(DIRECTORY_SEPARATOR, $cleanPath);

        if (substr($folders[0], 0, 1) === '_')
        {
            array_shift($folders);
        }

        $cleanPath = implode(DIRECTORY_SEPARATOR, $folders);

        return $cleanPath;
    }

    /**
     * Sanitize a permalink to remove unsupported characters or multiple '/' and replace spaces with hyphens.
     *
     * @param string $permalink A permalink
     *
     * @return string $permalink The sanitized permalink
     */
    private function sanitizePermalink($permalink)
    {
        // Remove multiple '/' together
        $permalink = preg_replace('/\/+/', '/', $permalink);


        // Replace all spaces with hyphens
        $permalink = str_replace(' ', '-', $permalink);


        // Remove all disallowed characters
        $permalink = preg_replace('/[^0-9a-zA-Z-_\/\\\.]/', '', $permalink);


        // Handle unnecessary extensions
        $extensionsToStrip = array('twig');

        if (in_array($this->fs->getExtension($permalink), $extensionsToStrip))
        {
            $permalink = $this->fs->removeExtension($permalink);

        }

        // Remove any special characters before a sane value
        $permalink = preg_replace('/^[^0-9a-zA-Z-_]*/', '', $permalink);


        // Convert permalinks to lower case
        $permalink = mb_strtolower($permalink, 'UTF-8');


        return $permalink;
    }

    //
    // WritableFrontMatter Implementation
    //

    /**
     * {@inheritdoc}
     */
    final public function evaluateFrontMatter($variables = null)
    {
        if (!is_null($variables))
        {
            $this->frontMatter = array_merge($this->frontMatter, $variables);
            $this->evaluateYaml($this->frontMatter);
        }
    }

    /**
     * {@inheritdoc}
     */
    final public function getFrontMatter($evaluateYaml = true)
    {
        if (is_null($this->frontMatter))
        {
            $this->frontMatter = array();
        }
        elseif (!$this->frontMatterEvaluated && $evaluateYaml)
        {
            $this->evaluateYaml($this->frontMatter);
        }

        return $this->frontMatter;
    }

    /**
     * {@inheritdoc}
     */
    final public function hasExpandedFrontMatter()
    {
        return !is_null($this->frontMatterParser) && $this->frontMatterParser->hasExpansion();
    }

    /**
     * {@inheritdoc.
     */
    final public function appendFrontMatter(array $frontMatter)
    {
        foreach ($frontMatter as $key => $value)
        {
            $this->writableFrontMatter[$key] = $value;
        }
    }

    /**
     * {@inheritdoc.
     */
    final public function deleteFrontMatter($key)
    {
        if (!isset($this->writableFrontMatter[$key]))
        {
            return;
        }

        unset($this->writableFrontMatter[$key]);
    }

    /**
     * {@inheritdoc.
     */
    final public function setFrontMatter(array $frontMatter)
    {
        if (!is_array($frontMatter))
        {
            throw new \InvalidArgumentException('An array is required for setting the writable FrontMatter');
        }

        $this->writableFrontMatter = $frontMatter;
    }

    /**
     * Evaluate an array of data for FrontMatter variables. This function will modify the array in place.
     *
     * @param array $yaml An array of data containing FrontMatter variables
     *
     * @throws YamlVariableUndefinedException A FrontMatter variable used does not exist
     */
    private function evaluateYaml(&$yaml)
    {
        try
        {
            $this->frontMatterParser = new Parser($yaml);
            $this->frontMatterEvaluated = true;
        }
        catch (\Exception $e)
        {
            throw FileAwareException::castException($e, $this->getRelativeFilePath());
        }
    }

    //
    // ArrayAccess Implementation
    //

    /**
     * {@inheritdoc}
     */
    public function offsetSet($offset, $value)
    {
        if (is_null($offset))
        {
            throw new \InvalidArgumentException('$offset cannot be null');
        }

        $this->writableFrontMatter[$offset] = $value;
    }

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

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

        return method_exists($this, $fxnCall) && in_array($fxnCall, static::$whiteListFunctions);
    }

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

    /**
     * {@inheritdoc}
     */
    public function offsetGet($offset)
    {
        $fxnCall = 'get' . ucfirst($offset);

        if (in_array($fxnCall, self::$whiteListFunctions) && method_exists($this, $fxnCall))
        {
            return call_user_func_array(array($this, $fxnCall), array());
        }

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

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

        return null;
    }
}


1		<?php
2
3		/**
4		* @copyright 2017 Vladimir Jimenez
5		* @license https://github.com/allejo/stakx/blob/master/LICENSE.md MIT
6		*/
7
8		namespace allejo\stakx\FrontMatter;
9
10		use allejo\stakx\Document\JailedDocumentInterface;
11		use allejo\stakx\Exception\FileAwareException;
12		use allejo\stakx\Exception\InvalidSyntaxException;
13		use allejo\stakx\FrontMatter\Exception\YamlVariableUndefinedException;
14		use allejo\stakx\System\Filesystem;
15		use Symfony\Component\Filesystem\Exception\FileNotFoundException;
16		use Symfony\Component\Filesystem\Exception\IOException;
17		use Symfony\Component\Finder\SplFileInfo;
18		use Symfony\Component\Yaml\Exception\ParseException;
19		use Symfony\Component\Yaml\Yaml;
20
21		abstract class Document implements WritableDocumentInterface, JailedDocumentInterface, \ArrayAccess
		0 ignored issues – show Coding Style introduced 2017-03-25 04:29 UTC by Report Bug Copy Issue Report `Document` does not seem to conform to the naming convention (`^Abstract\|Factory$`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
22		{
23		const TEMPLATE = "---\n%s\n---\n\n%s";
24
25		protected static $whiteListFunctions = array(
26		'getPermalink', 'getRedirects', 'getTargetFile', 'getName', 'getFilePath', 'getRelativeFilePath', 'getContent',
27		'getExtension', 'getFrontMatter'
28		);
29
30		/**
31		* An array to keep track of collection or data dependencies used inside of a Twig template.
32		*
33		* $dataDependencies['collections'] = array()
34		* $dataDependencies['data'] = array()
35		*
36		* @var array
37		*/
38		protected $dataDependencies;
39
40		/**
41		* FrontMatter values that can be injected or set after the file has been parsed. Values in this array will take
42		* precedence over values in $frontMatter.
43		*
44		* @var array
45		*/
46		protected $writableFrontMatter;
47
48		/**
49		* A list of Front Matter values that should not be returned directly from the $frontMatter array. Values listed
50		* here have dedicated functions that handle those Front Matter values and the respective functions should be called
51		* instead.
52		*
53		* @var string[]
54		*/
55		protected $frontMatterBlacklist;
56
57		/**
58		* Set to true if the front matter has already been evaluated with variable interpolation.
59		*
60		* @var bool
61		*/
62		protected $frontMatterEvaluated;
63
64		/**
65		* @var Parser
66		*/
67		protected $frontMatterParser;
68
69		/**
70		* An array containing the Yaml of the file.
71		*
72		* @var array
73		*/
74		protected $frontMatter;
75
76		/**
77		* Set to true if the body has already been parsed as markdown or any other format.
78		*
79		* @var bool
80		*/
81		protected $bodyContentEvaluated;
82
83		/**
84		* Only the body of the file, i.e. the content.
85		*
86		* @var string
87		*/
88		protected $bodyContent;
89
90		/**
91		* The permalink for this object.
92		*
93		* @var string
94		*/
95		protected $permalink;
96
97		/**
98		* A filesystem object.
99		*
100		* @var Filesystem
101		*/
102		protected $fs;
		0 ignored issues – show Comprehensibility introduced 2017-03-25 02:33 UTC by Report Bug Copy Issue Report Avoid variables with short names like $fs. Configured minimum length is 3. Short variable names may make your code harder to understand. Variable names should be self-descriptive. This check looks for variable names who are shorter than a configured minimum. Loading history...
103
104		/**
105		* The extension of the file.
106		*
107		* @var string
108		*/
109		private $extension;
110
111		/**
112		* The number of lines that Twig template errors should offset.
113		*
114		* @var int
115		*/
116		private $lineOffset;
117
118		/**
119		* A list URLs that will redirect to this object.
120		*
121		* @var string[]
122		*/
123		private $redirects;
124
125		/**
126		* The original file path to the ContentItem.
127		*
128		* @var SplFileInfo
129		*/
130		private $filePath;
131
132		/**
133		* ContentItem constructor.
134		*
135		* @param string $filePath The path to the file that will be parsed into a ContentItem
136		*
137		* @throws FileNotFoundException The given file path does not exist
138		* @throws IOException The file was not a valid ContentItem. This would meam there was no front matter or
139		* no body
140		*/
141	116	public function __construct($filePath)
142		{
143	116	$this->frontMatterBlacklist = array('permalink', 'redirects');
144	116	$this->writableFrontMatter = array();
145
146	116	$this->filePath = $filePath;
		0 ignored issues – show Documentation Bug introduced 2016-12-10 22:52 UTC by Report Bug Copy Issue Report It seems like `$filePath` of type `string` is incompatible with the declared type `object<Symfony\Component\Finder\SplFileInfo>` of property `$filePath`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
147	116	$this->fs = new Filesystem();
148
149	116	if (!$this->fs->exists($filePath))
150	116	{
151	1	throw new FileNotFoundException("The following file could not be found: ${filePath}");
152		}
153
154		$this->extension = strtolower($this->fs->getExtension($filePath));
155
156		$this->refreshFileContent();
157		}
158
159		/**
160		* Return the body of the Content Item.
161		*
162		* @return string
163		*/
164		abstract public function getContent();
165
166		/**
167		* Get the extension of the current file.
168		*
169		* @return string
170		*/
171		final public function getExtension()
172		{
173	7	return $this->extension;
174		}
175
176		/**
177		* Get the original file path.
178		*
179		* @return string
		0 ignored issues – show Documentation introduced 2016-12-10 22:52 UTC by Report Bug Copy Issue Report Should the return type not be `SplFileInfo`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
180		*/
181		final public function getFilePath()
182		{
183	19	return $this->filePath;
184		}
185
186		/**
187		* The number of lines that are taken up by FrontMatter and white space.
188		*
189		* @return int
190		*/
191		final public function getLineOffset()
192		{
193		return $this->lineOffset;
194		}
195
196		/**
197		* Get the name of the item, which is just the file name without the extension.
198		*
199		* @return string
200		*/
201		final public function getName()
202		{
203	37	return $this->fs->getBaseName($this->filePath);
204		}
205
206		/**
207		* Get the relative path to this file relative to the root of the Stakx website.
208		*
209		* @return string
210		*/
211		final public function getRelativeFilePath()
212		{
213	65	if ($this->filePath instanceof SplFileInfo)
214	65	{
215	39	return $this->filePath->getRelativePathname();
216		}
217
218		// TODO ensure that we always get SplFileInfo objects, even when handling VFS documents
219	28	return $this->fs->getRelativePath($this->filePath);
220		}
221
222		/**
223		* Get the destination of where this Content Item would be written to when the website is compiled.
224		*
225		* @return string
226		*/
227		final public function getTargetFile()
228		{
229	20	$permalink = $this->getPermalink();
230	20	$missingFile = (substr($permalink, -1) == '/');
231	20	$permalink = str_replace('/', DIRECTORY_SEPARATOR, $permalink);
232
233		if ($missingFile)
234	20	{
235	12	$permalink = rtrim($permalink, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . 'index.html';
236	12	}
237
238	20	return ltrim($permalink, DIRECTORY_SEPARATOR);
239		}
240
241		/**
242		* Check whether this object has a reference to a collection or data item.
243		*
244		* @param string $namespace 'collections' or 'data'
245		* @param string $needle
246		*
247		* @return bool
248		*/
249		final public function hasTwigDependency($namespace, $needle)
250		{
251		return in_array($needle, $this->dataDependencies[$namespace]);
252		}
253
254		/**
255		* Read the file, and parse its contents.
256		*/
257		final public function refreshFileContent()
258		{
259		// This function can be called after the initial object was created and the file may have been deleted since the
260		// creation of the object.
261	115	if (!$this->fs->exists($this->filePath))
262	115	{
263	1	throw new FileNotFoundException(null, 0, null, $this->filePath);
264		}
265
266	115	$rawFileContents = file_get_contents($this->filePath);
267	115	$fileStructure = array();
268	115	preg_match('/---\R(.?\R)?---(\s+)(.)/s', $rawFileContents, $fileStructure);
269
270	115	if (count($fileStructure) != 4)
271	115	{
272	9	throw new InvalidSyntaxException('Invalid FrontMatter file', 0, null, $this->getRelativeFilePath());
273		}
274
275	106	if (empty(trim($fileStructure[3])))
276	106	{
277	1	throw new InvalidSyntaxException('FrontMatter files must have a body to render', 0, null, $this->getRelativeFilePath());
278		}
279
280	105	$this->lineOffset = substr_count($fileStructure[1], "\n") + substr_count($fileStructure[2], "\n");
281	105	$this->bodyContent = $fileStructure[3];
282
283	105	if (!empty(trim($fileStructure[1])))
284	105	{
285	89	$this->frontMatter = Yaml::parse($fileStructure[1], Yaml::PARSE_DATETIME);
		0 ignored issues – show Documentation Bug introduced 2017-02-27 19:53 UTC by Report Bug Copy Issue Report It seems like `\Symfony\Component\Yaml\...l\Yaml::PARSE_DATETIME)` can also be of type `string` or `object<stdClass>`. However, the property `$frontMatter` is declared as type `array`. Maybe add an additional type check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly. For example, imagine you have a variable `$accountId` that can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to the `id` property of an instance of the `Account` class. This class holds a proper account, so the id value must no longer be false. Either this assignment is in error or a type check should be added for that assignment. class Id { public $id; public function __construct($id) { $this->id = $id; } } class Account { /** @var Id $id */ public $id; } $account_id = false; if (starsAreRight()) { $account_id = new Id(42); } $account = new Account(); if ($account instanceof Id) { $account->id = $account_id; } Loading history...
286
287	89	if (!empty($this->frontMatter) && !is_array($this->frontMatter))
288	89	{
289	1	throw new ParseException('The evaluated FrontMatter should be an array');
290		}
291	88	}
292		else
293		{
294	19	$this->frontMatter = array();
295		}
296
297	104	$this->frontMatterEvaluated = false;
298	104	$this->bodyContentEvaluated = false;
299	104	$this->permalink = null;
300
301	104	$this->findTwigDataDependencies('collections');
302	104	$this->findTwigDataDependencies('data');
303	104	}
304
305		/**
306		* Get all of the references to either DataItems or ContentItems inside of given string.
307		*
308		* @param string $filter 'collections' or 'data'
309		*/
310		private function findTwigDataDependencies($filter)
311		{
312	104	$regex = '/{[{%](?:.+)?(?:' . $filter . ')(?:\.\|\[\')(\w+)(?:\'\])?.+[%}]}/';
313	104	$results = array();
314
315	104	preg_match_all($regex, $this->bodyContent, $results);
316
317	104	$this->dataDependencies[$filter] = array_unique($results[1]);
318	104	}
319
320		//
321		// Permalink and redirect functionality
322		//
323
324		/**
325		* Get the permalink of this Content Item.
326		*
327		* @throws \Exception
328		*
329		* @return string
330		*/
331		final public function getPermalink()
332		{
333	39	if (!is_null($this->permalink))
334	39	{
335	8	return $this->permalink;
336		}
337
338	37	if (!is_null($this->frontMatterParser) && $this->frontMatterParser->hasExpansion())
339	37	{
340		throw new \Exception('The permalink for this item has not been set');
341		}
342
343	37	$permalink = (is_array($this->frontMatter) && isset($this->frontMatter['permalink'])) ?
344	37	$this->frontMatter['permalink'] : $this->getPathPermalink();
345
346	37	if (is_array($permalink))
347	37	{
348	19	$this->permalink = $permalink[0];
349	19	array_shift($permalink);
350	19	$this->redirects = $permalink;
351	19	}
352		else
353		{
354	24	$this->permalink = $permalink;
355	24	$this->redirects = array();
356		}
357
358	37	$this->permalink = $this->sanitizePermalink($this->permalink);
359	37	$this->permalink = str_replace(DIRECTORY_SEPARATOR, '/', $this->permalink);
360	37	$this->permalink = '/' . ltrim($this->permalink, '/'); // Permalinks should always use '/' and not be OS specific
361
362	37	return $this->permalink;
363		}
364
365		/**
366		* Get an array of URLs that will redirect to.
367		*
368		* @return string[]
		0 ignored issues – show Documentation introduced 2016-11-21 01:51 UTC by Report Bug Copy Issue Report Should the return type not be `null\|string[]`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
369		*/
370		final public function getRedirects()
371		{
372	14	if (is_null($this->redirects))
373	14	{
374	3	$this->getPermalink();
375	3	}
376
377	14	return $this->redirects;
378		}
379
380		/**
381		* Get the permalink based off the location of where the file is relative to the website. This permalink is to be
382		* used as a fallback in the case that a permalink is not explicitly specified in the Front Matter.
383		*
384		* @return string
385		*/
386		private function getPathPermalink()
387		{
388		// Remove the protocol of the path, if there is one and prepend a '/' to the beginning
389	3	$cleanPath = preg_replace('/[\w\|\d]+:\/\//', '', $this->getRelativeFilePath());
390	3	$cleanPath = ltrim($cleanPath, DIRECTORY_SEPARATOR);
391
392		// Handle vfs:// paths by replacing their forward slashes with the OS appropriate directory separator
393	3	if (DIRECTORY_SEPARATOR !== '/')
394	3	{
395		$cleanPath = str_replace('/', DIRECTORY_SEPARATOR, $cleanPath);
396		}
397
398		// Check the first folder and see if it's a data folder (starts with an underscore) intended for stakx
399	3	$folders = explode(DIRECTORY_SEPARATOR, $cleanPath);
400
401	3	if (substr($folders[0], 0, 1) === '_')
402	3	{
403	1	array_shift($folders);
404	1	}
405
406	3	$cleanPath = implode(DIRECTORY_SEPARATOR, $folders);
407
408	3	return $cleanPath;
409		}
410
411		/**
412		* Sanitize a permalink to remove unsupported characters or multiple '/' and replace spaces with hyphens.
413		*
414		* @param string $permalink A permalink
415		*
416		* @return string $permalink The sanitized permalink
417		*/
418		private function sanitizePermalink($permalink)
419		{
420		// Remove multiple '/' together
421	37	$permalink = preg_replace('/\/+/', '/', $permalink);
		0 ignored issues – show Coding Style introduced 2017-03-25 02:33 UTC by Report Bug Copy Issue Report Consider using a different name than the parameter `$permalink`. This often makes code more readable. Loading history...
422
423		// Replace all spaces with hyphens
424	37	$permalink = str_replace(' ', '-', $permalink);
		0 ignored issues – show Coding Style introduced 2017-03-25 02:33 UTC by Report Bug Copy Issue Report Consider using a different name than the parameter `$permalink`. This often makes code more readable. Loading history...
425
426		// Remove all disallowed characters
427	37	$permalink = preg_replace('/[^0-9a-zA-Z-_\/\\\.]/', '', $permalink);
		0 ignored issues – show Coding Style introduced 2017-03-25 02:33 UTC by Report Bug Copy Issue Report Consider using a different name than the parameter `$permalink`. This often makes code more readable. Loading history...
428
429		// Handle unnecessary extensions
430	37	$extensionsToStrip = array('twig');
431
432	37	if (in_array($this->fs->getExtension($permalink), $extensionsToStrip))
433	37	{
434	4	$permalink = $this->fs->removeExtension($permalink);
		0 ignored issues – show Coding Style introduced 2017-03-25 02:33 UTC by Report Bug Copy Issue Report Consider using a different name than the parameter `$permalink`. This often makes code more readable. Loading history...
435	4	}
436
437		// Remove any special characters before a sane value
438	37	$permalink = preg_replace('/^[^0-9a-zA-Z-_]*/', '', $permalink);
		0 ignored issues – show Coding Style introduced 2017-03-25 02:33 UTC by Report Bug Copy Issue Report Consider using a different name than the parameter `$permalink`. This often makes code more readable. Loading history...
439
440		// Convert permalinks to lower case
441	37	$permalink = mb_strtolower($permalink, 'UTF-8');
		0 ignored issues – show Coding Style introduced 2017-03-25 02:33 UTC by Report Bug Copy Issue Report Consider using a different name than the parameter `$permalink`. This often makes code more readable. Loading history...
442
443	37	return $permalink;
444		}
445
446		//
447		// WritableFrontMatter Implementation
448		//
449
450		/**
451		* {@inheritdoc}
452		*/
453		final public function evaluateFrontMatter($variables = null)
454		{
455	7	if (!is_null($variables))
456	7	{
457	7	$this->frontMatter = array_merge($this->frontMatter, $variables);
458	7	$this->evaluateYaml($this->frontMatter);
459	7	}
460	7	}
461
462		/**
463		* {@inheritdoc}
464		*/
465		final public function getFrontMatter($evaluateYaml = true)
466		{
467	29	if (is_null($this->frontMatter))
468	29	{
469		$this->frontMatter = array();
470		}
471	29	elseif (!$this->frontMatterEvaluated && $evaluateYaml)
472		{
473	23	$this->evaluateYaml($this->frontMatter);
474	22	}
475
476	28	return $this->frontMatter;
477		}
478
479		/**
480		* {@inheritdoc}
481		*/
482		final public function hasExpandedFrontMatter()
483		{
484	2	return !is_null($this->frontMatterParser) && $this->frontMatterParser->hasExpansion();
485		}
486
487		/**
488		* {@inheritdoc.
489		*/
490		final public function appendFrontMatter(array $frontMatter)
491		{
492		foreach ($frontMatter as $key => $value)
493		{
494		$this->writableFrontMatter[$key] = $value;
495		}
496		}
497
498		/**
499		* {@inheritdoc.
500		*/
501		final public function deleteFrontMatter($key)
502		{
503		if (!isset($this->writableFrontMatter[$key]))
504		{
505		return;
506		}
507
508		unset($this->writableFrontMatter[$key]);
509		}
510
511		/**
512		* {@inheritdoc.
513		*/
514		final public function setFrontMatter(array $frontMatter)
515		{
516	2	if (!is_array($frontMatter))
517	2	{
518		throw new \InvalidArgumentException('An array is required for setting the writable FrontMatter');
519		}
520
521	2	$this->writableFrontMatter = $frontMatter;
522	2	}
523
524		/**
525		* Evaluate an array of data for FrontMatter variables. This function will modify the array in place.
526		*
527		* @param array $yaml An array of data containing FrontMatter variables
528		*
529		* @throws YamlVariableUndefinedException A FrontMatter variable used does not exist
530		*/
531		private function evaluateYaml(&$yaml)
532		{
533		try
534		{
535	30	$this->frontMatterParser = new Parser($yaml);
536	29	$this->frontMatterEvaluated = true;
537		}
538	30	catch (\Exception $e)
539		{
540	1	throw FileAwareException::castException($e, $this->getRelativeFilePath());
541		}
542	29	}
543
544		//
545		// ArrayAccess Implementation
546		//
547
548		/**
549		* {@inheritdoc}
550		*/
551		public function offsetSet($offset, $value)
552		{
553		if (is_null($offset))
554		{
555		throw new \InvalidArgumentException('$offset cannot be null');
556		}
557
558		$this->writableFrontMatter[$offset] = $value;
559		}
560
561		/**
562		* {@inheritdoc}
563		*/
564		public function offsetExists($offset)
565		{
566	31	if (isset($this->writableFrontMatter[$offset]) \|\| isset($this->frontMatter[$offset]))
567	31	{
568	30	return true;
569		}
570
571	14	$fxnCall = 'get' . ucfirst($offset);
572
573	14	return method_exists($this, $fxnCall) && in_array($fxnCall, static::$whiteListFunctions);
574		}
575
576		/**
577		* {@inheritdoc}
578		*/
579		public function offsetUnset($offset)
580		{
581		unset($this->writableFrontMatter[$offset]);
582		}
583
584		/**
585		* {@inheritdoc}
586		*/
587		public function offsetGet($offset)
588		{
589	48	$fxnCall = 'get' . ucfirst($offset);
590
591	48	if (in_array($fxnCall, self::$whiteListFunctions) && method_exists($this, $fxnCall))
592	48	{
593	6	return call_user_func_array(array($this, $fxnCall), array());
594		}
595
596	42	if (isset($this->writableFrontMatter[$offset]))
597	42	{
598		return $this->writableFrontMatter[$offset];
599		}
600
601	42	if (isset($this->frontMatter[$offset]))
602	42	{
603	41	return $this->frontMatter[$offset];
604		}
605
606	5	return null;
607		}
608		}
609

stakx-io / stakx

Push — master ( 8dfbb4...5f3e12 )

Document::offsetExists() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like