ICanBoogie\View\View

Complexity

Total Complexity

44

Size/Duplication

Total Lines	489
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	13

Importance

Changes	12
Bugs	0	Features	4

23 Methods

Rating	Name	Duplication	Size	Complexity
A	get_controller()	0	4	1
A	get_variables()	0	4	1
A	get_content()	0	4	2
A	set_content()	0	4	1
A	lazy_get_template()	0	21	3
B	get_template_resolvers()	0	24	1
C	lazy_get_layout()	0	36	7
A	get_layout_resolvers()	0	18	1
A	__construct()	0	11	1
A	jsonSerialize()	0	10	1
A	offsetExists()	0	4	1
A	offsetGet()	0	9	2
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	assign()	0	6	1
A	resolve_template()	0	14	3
A	decorate_with()	0	4	1
A	decorate()	0	11	2
A	render()	0	23	3
A	render_with_template()	0	15	2
A	prepare_engine_args()	0	15	2
A	on_action()	0	16	3
A	ensure_without_this()	0	12	3

<?php

/*
 * This file is part of the ICanBoogie package.
 *
 * (c) Olivier Laviale <olivier.laviale@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ICanBoogie\View;

use ICanBoogie\EventCollectionProvider;
use ICanBoogie\OffsetNotDefined;
use ICanBoogie\PropertyNotDefined;
use ICanBoogie\PrototypeTrait;
use ICanBoogie\Render\TemplateName;
use ICanBoogie\Render\TemplateNotFound;
use ICanBoogie\Routing\Controller;

/**
 * A view.
 *
 * @property-read Controller $controller The controller invoking the view.
 * @property-read array $variables The variables to pass to the template.
 * @property mixed $content The content of the view.
 * @property string $layout The name of the layout that should decorate the content.
 * @property string $template The name of the template that should render the content.
 * @property-read callable[] $layout_resolvers @internal
 * @property-read callable[] $template_resolvers @internal
 */
class View implements \ArrayAccess, \JsonSerializable
{
	use PrototypeTrait;
	use ViewBindings;

	const TEMPLATE_TYPE_VIEW = 1;
	const TEMPLATE_TYPE_LAYOUT = 2;
	const TEMPLATE_TYPE_PARTIAL = 3;

	const TEMPLATE_PREFIX_VIEW = '';
	const TEMPLATE_PREFIX_LAYOUT = '@';
	const TEMPLATE_PREFIX_PARTIAL = '_';

	static private $template_type_name = [

		self::TEMPLATE_TYPE_VIEW => 'template',
		self::TEMPLATE_TYPE_LAYOUT => 'layout',
		self::TEMPLATE_TYPE_PARTIAL=> 'partial'

	];

	static private $template_prefix = [

		self::TEMPLATE_TYPE_VIEW => self::TEMPLATE_PREFIX_VIEW,
		self::TEMPLATE_TYPE_LAYOUT => self::TEMPLATE_PREFIX_LAYOUT,
		self::TEMPLATE_TYPE_PARTIAL=> self::TEMPLATE_PREFIX_PARTIAL

	];

	/**
	 * @var Controller
	 */
	private $controller;

	/**
	 * @see $controller
	 *
	 * @return Controller
	 */
	protected function get_controller()
	{
		return $this->controller;
	}

	/**
	 * View's variables.
	 *
	 * @var array
	 */
	private $variables = [];

	/**
	 * @see $variables
	 *
	 * @return array
	 */
	protected function get_variables()
	{
		return $this->variables;
	}

	/**
	 * @see $content
	 *
	 * @return mixed
	 */
	protected function get_content()
	{
		return isset($this->variables['content']) ? $this->variables['content'] : null;
	}

	/**
	 * @see $content
	 *
	 * @param mixed $content
	 */
	protected function set_content($content)
	{
		$this->variables['content'] = $content;
	}

	private $decorators = [];

	/**
	 * Return the name of the template.
	 *
	 * The template name is resolved as follows:
	 *
	 * - The `template` property of the route.
	 * - The `template` property of the controller.
	 * - The `{$controller->name}/{$controller->action}`, if the controller has an `action`
	 * property.
	 *
	 * @return string|null
	 */
	protected function lazy_get_template()
	{
		$controller = $this->controller;

		foreach ($this->template_resolvers as $provider)
		{
			try
			{
				return $provider($controller);
			}
			catch (PropertyNotDefined $e)
			{
				#
				# Resolver failed, we continue with the next.
				#
			}

		}

		return null;
	}

	/**
	 * Returns an array of callable used to resolve the {@link $template} property.
	 *
	 * @return callable[]
	 *
	 * @internal
	 */
	protected function get_template_resolvers()
	{
		return [

			function ($controller) {

				return $controller->route->template;

			},

			function ($controller) {

				return $controller->template;

			},

			function ($controller) {

				return $controller->name . "/" . $controller->action;

			}

		];
	}

	/**
	 * Returns the name of the layout.
	 *
	 * The layout name is resolved as follows:
	 *
	 * - The `layout` property of the route.
	 * - The `layout` property of the controller.
	 * - If the identifier of the route starts with "admin:", "admin" is returned.
	 * - If the route pattern is "/" and a "home" layout template is available, "home" is returned.
	 * - If the "@page" template is available, "page" is returned.
	 * - "default" is returned.
	 *
	 * @return string
	 */
	protected function lazy_get_layout()
	{
		$controller = $this->controller;

		foreach ($this->layout_resolvers as $resolver)
		{
			try
			{
				return $resolver($controller);
			}
			catch (PropertyNotDefined $e)
			{
				#
				# Resolver failed, we continue with the next.
				#
			}

		}

		if (strpos($controller->route->id, "admin:") === 0)
		{
			return 'admin';
		}

		if ($controller->route->pattern == "/" && $this->resolve_template('home', self::TEMPLATE_PREFIX_LAYOUT))
		{
			return 'home';
		}

		if ($this->resolve_template('page', self::TEMPLATE_PREFIX_LAYOUT))
		{
			return 'page';
		}

		return 'default';
	}

	/**
	 * Returns an array of callable used to resolve the {@link $template} property.
	 *
	 * @return callable[]
	 *
	 * @internal
	 */
	protected function get_layout_resolvers()
	{
		return [

			function ($controller) {

				return $controller->route->layout;

			},

			function ($controller) {

				return $controller->layout;

			}

		];
	}

	/**
	 * An event hook is attached to the `action` event of the controller for late rendering,
	 * which only happens if the response is `null`.
	 *
	 * @param Controller $controller The controller that invoked the view.
	 */
	public function __construct(Controller $controller)
	{
		$this->controller = $controller;
		$this['view'] = $this;

		EventCollectionProvider::provide()->attach_to($controller, function (Controller\ActionEvent $event, Controller $target) {

			$this->on_action($event);

		});
	}

	/**
	 * @inheritdoc
	 *
	 * Returns an array with the following keys: `template`, `layout`, and `variables`.
	 */
	public function jsonSerialize()
	{
		return [

			'template' => $this->template,
			'layout' => $this->layout,
			'variables' => $this->ensure_without_this($this->variables)

		];
	}

	/**
	 * @inheritdoc
	 */
	public function offsetExists($offset)
	{
		return array_key_exists($offset, $this->variables);
	}

	/**
	 * @inheritdoc
	 *
	 * @throws OffsetNotDefined if the offset is not defined.
	 */
	public function offsetGet($offset)
	{
		if (!$this->offsetExists($offset))
		{
			throw new OffsetNotDefined([ $offset, $this ]);
		}

		return $this->variables[$offset];
	}

	/**
	 * @inheritdoc
	 */
	public function offsetSet($offset, $value)
	{
		$this->variables[$offset] = $value;
	}

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

	/**
	 * Assign multiple variables.
	 *
	 * @param array $variables
	 *
	 * @return $this
	 */
	public function assign(array $variables)
	{
		$this->variables = array_merge($this->variables, $variables);

		return $this;
	}

	/**
	 * Resolve a template pathname from its name and type.
	 *
	 * @param string $name Name of the template.
	 * @param string $prefix Template prefix.
	 * @param array $tried Reference to an array where tried paths are collected.
	 *
	 * @return string|false
	 */
	protected function resolve_template($name, $prefix, &$tried = [])
	{
		$tried = $tried ?: [];

		if ($prefix)
		{
			$name = TemplateName::from($name);
			$name = $name->with_prefix($prefix);
		}

		$resolver = $this->template_resolver;

		return $resolver->resolve($name, $this->engines->extensions, $tried);
	}

	/**
	 * Add a template to decorate the content with.
	 *
	 * @param string $template Name of the template.
	 */
	public function decorate_with($template)
	{
		$this->decorators[] = $template;
	}

	/**
	 * Decorate the content.
	 *
	 * @param mixed $content The content to decorate.
	 *
	 * @return mixed
	 */
	protected function decorate($content)
	{
		$decorators = array_reverse($this->decorators);

		foreach ($decorators as $template)
		{
			$content = $this->render_with_template($content, $template, self::TEMPLATE_TYPE_LAYOUT);
		}

		return $content;
	}

	/**
	 * Render the view.
	 *
	 * @return string
	 */
	public function render()
	{
		$steps = [

			[ $this->template, self::TEMPLATE_TYPE_VIEW ],
			[ $this->layout, self::TEMPLATE_TYPE_LAYOUT ]

		];

		$content = $this->content;

		foreach ($steps as list($template, $type))
		{
			if (!$template)
			{
				continue;
			}

			$content = $this->render_with_template($content, $template, $type);
		}

		return $this->decorate($content);
	}

	/**
	 * Renders the content using a template.
	 *
	 * @param mixed $content The content to render.
	 * @param string $template Name of the template.
	 * @param string $type Type of the template.
	 *
	 * @return string
	 */
	protected function render_with_template($content, $template, $type)
	{
		$pathname = $this->resolve_template($template, self::$template_prefix[$type], $tries);

		if (!$pathname)
		{
			$type_name = self::$template_type_name[$type];

			throw new TemplateNotFound("There is no $type_name matching `$template`.", $tries);
		}

		list($thisArg, $variables) = $this->prepare_engine_args($content, $type);

		return $this->engines->render($pathname, $thisArg, $variables);
	}

	/**
	 * Prepares engine arguments.
	 *
	 * @param mixed $content
	 * @param string $type
	 *
	 * @return array
	 */
	protected function prepare_engine_args($content, $type)
	{
		$variables = $this->variables;

		if ($type == self::TEMPLATE_TYPE_LAYOUT)
		{
			$variables['content'] = $content;

			return [ $this, $variables ];
		}

		$variables['view'] = $this;

		return [ $content, $variables ];
	}

	/**
	 * Renders the view on `Controller::action` event.
	 *
	 * **Note:** The view is not rendered if the event's response is defined, which is the case
	 * when the controller obtained a result after its execution.
	 *
	 * @param Controller\ActionEvent $event
	 */
	protected function on_action(Controller\ActionEvent $event)
	{
		if ($event->result !== null)
		{
			return;
		}

		new View\BeforeRenderEvent($this, $event->result);

		if ($event->result !== null)
		{
			return;
		}

		$event->result = $this->render();
	}

	/**
	 * Ensures the array does not include our instance.
	 *
	 * @param array $array
	 *
	 * @return array
	 */
	private function ensure_without_this(array $array)
	{
		foreach ($array as $key => $value)
		{
			if ($value === $this)
			{
				unset($array[$key]);
			}
		}

		return $array;
	}
}