allejo\stakx\Document\BasePageView

Complexity

Total Complexity

10

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

86.21%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getType()	0	4	1
A	create()	0	19	4
A	createVirtual()	0	16	2
B	createRedirect()	0	25	3

<?php

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

namespace allejo\stakx\Document;

use allejo\stakx\Filesystem\File;
use allejo\stakx\Filesystem\FilesystemLoader as fs;
use org\bovigo\vfs\vfsStream;
use org\bovigo\vfs\vfsStreamWrapper;
use Symfony\Component\Yaml\Yaml;

abstract class BasePageView extends PermalinkFrontMatterDocument implements PermalinkDocument
{
    use TemplateEngineDependent;

    const REPEATER_TYPE = 'repeater';
    const DYNAMIC_TYPE = 'dynamic';
    const STATIC_TYPE = 'static';

    protected $type;

    /**
     * Returns the type of PageView.
     *
     * @return string
     */
    public function getType()
    {
        return $this->type;
    }

    ///
    // Static utilities
    ///

    /**
     * Create the appropriate object type when parsing a PageView.
     *
     * @return DynamicPageView|StaticPageView|RepeaterPageView
     */
    public static function create(File $filePath, array $complexVariables = [])
    {
        $instance = new StaticPageView($filePath);

        if (isset($instance->getRawFrontMatter()['collection']) ||
            isset($instance->getRawFrontMatter()['dataset'])
        ) {
            return new DynamicPageView($filePath);
        }

        $instance->evaluateFrontMatter([], $complexVariables);

        if ($instance->hasExpandedFrontMatter())
        {
            return new RepeaterPageView($filePath);
        }

        return $instance;
    }

    ///
    // Virtual PageViews
    ///

    /**
     * Create a virtual PageView.
     *
     * @param array  $frontMatter The Front Matter that this virtual PageView will have
     * @param string $body        The body of the virtual PageView
     *
     * @return StaticPageView
     */
    public static function createVirtual($frontMatter, $body)
    {
        if (vfsStreamWrapper::getRoot() == null)
        {
            vfsStream::setup();
        }

        $redirectFile = vfsStream::newFile(sprintf('redirect_%s.html.twig', uniqid()));
        $redirectFile
            ->setContent(sprintf(self::TEMPLATE, Yaml::dump($frontMatter, 2), $body))
            ->at(vfsStreamWrapper::getRoot());

        $file = new File($redirectFile->url());

        return new StaticPageView($file);
    }

    /**
     * Create a virtual PageView to create redirect files.
     *
     * @param string      $redirectFrom     The URL that will be redirecting to the target location
     * @param string      $redirectTo       The URL of the destination
     * @param string|bool $redirectTemplate The path to the template
     *
     * @return StaticPageView A virtual PageView with the redirection template
     */
    public static function createRedirect($redirectFrom, $redirectTo, $redirectTemplate = false)
    {
        $frontMatter = array(
            'permalink' => $redirectFrom,
            'redirect'  => $redirectTo,
            'menu'      => false,
        );

        $contentItemBody = fs::getInternalResource('redirect.html.twig');

'redirect.html.twig' is of type string, but the function expects a object<string>.

        try
        {
            if (!empty($redirectTemplate))
            {
                $redirectView = new File($redirectTemplate);

It seems like $redirectTemplate defined by parameter $redirectTemplate on line 103 can also be of type boolean; however, allejo\stakx\Filesystem\File::__construct() does only seem to accept string, maybe add an additional type check?

                $contentItemBody = $redirectView->getContents();
            }
        }
        catch (\Exception $e)
        {
            trigger_error($e->getMessage(), E_USER_WARNING);
        }

        return self::createVirtual($frontMatter, $contentItemBody);
    }
}