Charcoal\View\ViewableTrait

Complexity

Total Complexity

14

Size/Duplication

Total Lines	155
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__toString()	0	4	1
A	setTemplateIdent()	0	5	1
A	templateIdent()	0	4	1
A	setView()	0	5	1
A	view()	0	4	1
A	render()	0	8	2
A	renderTemplate()	0	4	1
A	setViewController()	0	12	3
A	viewController()	0	8	2
A	setDynamicTemplate()	0	4	1

<?php

declare(strict_types=1);

namespace Charcoal\View;

use InvalidArgumentException;

// From 'charcoal-view'
use Charcoal\View\ViewInterface;

/**
 * Implementation, as trait, of the {@see \Charcoal\View\ViewableInterface}.
 */
trait ViewableTrait
{
    /**
     * The object's template identifier.
     *
     * @var string
     */
    private $templateIdent = '';

    /**
     * The context for the {@see self::$view} to render templates.
     *
     * @var ViewableInterface
     */
    private $viewController;

    /**
     * The renderable view.
     *
     * @var ViewInterface
     */
    private $view;

    /**
     * Render the viewable object.
     *
     * @return string
     */
    public function __toString()
    {
        return $this->render();
    }

    /**
     * Set the template identifier for this viewable object.
     *
     * Usually, a path to a file containing the template to be rendered at runtime.
     *
     * @param string $templateIdent The template ID.
     * @return self
     */
    public function setTemplateIdent(string $templateIdent)
    {
        $this->templateIdent = $templateIdent;
        return $this;
    }

    /**
     * Retrieve the template identifier for this viewable object.
     *
     * @return string
     */
    public function templateIdent(): string
    {
        return $this->templateIdent;
    }

    /**
     * Set the renderable view.
     *
     * @param ViewInterface|array $view The view instance to use to render.
     * @throws InvalidArgumentException If the view parameter is not an array or a View object.
     * @return self
     */
    public function setView(ViewInterface $view)
    {
        $this->view = $view;
        return $this;
    }

    /**
     * Retrieve the renderable view.
     *
     * @return ViewInterface The object's View instance.
     */
    public function view()
    {
        return $this->view;
    }

    /**
     * Render the template by the given identifier.
     *
     * Usually, a path to a file containing the template to be rendered at runtime.
     *
     * @param string $templateIdent The template to load, parse, and render.
     *     If NULL, will use the object's previously set template identifier.
     * @return string The rendered template.
     */
    public function render(?string $templateIdent = null): string
    {
        if ($templateIdent === null) {
            $templateIdent = $this->templateIdent();
        }

        return $this->view()->render($templateIdent, $this->viewController());
    }

    /**
     * Render the given template from string.
     *
     * @param string $templateString The template  to render from string.
     * @return string The rendered template.
     */
    public function renderTemplate(string $templateString): string
    {
        return $this->view()->renderTemplate($templateString, $this->viewController());
    }

    /**
     * Set a view controller for the template's context.
     *
     * @param ViewableInterface|object|array|null $controller A view controller to use when rendering.
     * @throws InvalidArgumentException If the controller is invalid.
     * @return self
     */
    public function setViewController($controller)
    {
        if (is_scalar($controller) || is_resource($controller)) {
            throw new InvalidArgumentException(
                'View controller must be an object, null or an array'
            );
        }

        $this->viewController = $controller;

It seems like $controller can also be of type array. However, the property $viewController is declared as type object<Charcoal\View\ViewableInterface>. Maybe add an additional type check?

        return $this;
    }

    /**
     * Retrieve a view controller for the template's context.
     *
     * If no controller has been defined, it will return itself.
     *
     * @return mixed
     */
    public function viewController()
    {
        if ($this->viewController === null) {
            return $this;
        }

        return $this->viewController;
    }

    /**
     * @param string      $varName       The name of the variable to set this template unto.
     * @param string|null $templateIdent The "dynamic template" to set. null to clear.
     * @return void
     */
    public function setDynamicTemplate(string $varName, ?string $templateIdent): void
    {
        $this->view()->setDynamicTemplate($varName, $templateIdent);
    }
}