allejo\stakx\Document\PermalinkDocumentTrait

Complexity

Total Complexity

13

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

97.56%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	handleSpecialRedirects()	0	3	1
A	getTargetFile()	0	17	3
A	getPermalink()	0	10	1
A	getRedirects()	0	11	2
A	getPathPermalink()	0	24	3
A	sanitizePermalink()	0	27	3

<?php

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

namespace allejo\stakx\Document;

use allejo\stakx\Filesystem\FilesystemLoader as fs;
use allejo\stakx\RuntimeStatus;
use allejo\stakx\Service;

trait PermalinkDocumentTrait
{
    /** @var string */
    protected $permalink = null;

    /** @var array */
    protected $redirects = null;

    /** Extensions that need to be stripped from permalinks. */
    private static $extensionsToStrip = ['twig'];

    /**
     * {@inheritdoc}
     */
    public function handleSpecialRedirects()
    {
    }

    /**
     * {@inheritdoc}
     */
    final public function getTargetFile($permalink = null)
    {
        if ($permalink === null)
        {
            $permalink = $this->getPermalink();

Consider using a different name than the parameter $permalink. This often makes code more readable.

        }

        $missingFile = (substr($permalink, -1) == '/');
        $permalink = str_replace('/', DIRECTORY_SEPARATOR, $permalink);

Consider using a different name than the parameter $permalink. This often makes code more readable.

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

Consider using a different name than the parameter $permalink. This often makes code more readable.

        }

        return ltrim($permalink, DIRECTORY_SEPARATOR);
    }

    /**
     * {@inheritdoc}
     */
    final public function getPermalink()
    {
        $this->buildPermalink();

It seems like buildPermalink() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->permalink = $this->sanitizePermalink($this->permalink);

It seems like $this->sanitizePermalink($this->permalink) can also be of type array<integer,string>. However, the property $permalink is declared as type string. Maybe add an additional type check?

        $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;
    }

    /**
     * {@inheritdoc}
     */
    final public function getRedirects()

The return type could not be reliably inferred; please add a @return annotation.

    {
        if ($this->redirects === null)
        {
            $this->getPermalink();
        }

        $this->handleSpecialRedirects();

        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
     */
    final protected 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());

It seems like getRelativeFilePath() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $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

Should the return type not be string|string[]?

     */
    final private function sanitizePermalink($permalink)
    {
        // Remove multiple '/' together
        $permalink = preg_replace('/\/+/', '/', $permalink);

Consider using a different name than the parameter $permalink. This often makes code more readable.

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

Consider using a different name than the parameter $permalink. This often makes code more readable.

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

Consider using a different name than the parameter $permalink. This often makes code more readable.

        if (in_array(fs::getExtension($permalink), self::$extensionsToStrip))

$permalink is of type string, but the function expects a object<string>.

        {
            $permalink = fs::removeExtension($permalink);

$permalink is of type string, but the function expects a object<string>.

Consider using a different name than the parameter $permalink. This often makes code more readable.

        }

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

Consider using a different name than the parameter $permalink. This often makes code more readable.

        // Convert permalinks to lower case
        if (!Service::hasRunTimeFlag(RuntimeStatus::COMPILER_PRESERVE_CASE))
        {
            $permalink = mb_strtolower($permalink, 'UTF-8');

Consider using a different name than the parameter $permalink. This often makes code more readable.

        }

        return $permalink;
    }
}