View::ensure_without_this() - Code Metrics - ICanBoogie/View - Measure and Improve Code Quality continuously with Scrutinizer

View::ensure_without_this() A
last analyzed 2016-11-07 11:42 UTC

↳ Parent: View

Complexity

Conditions	3
Paths	3

Size

Total Lines	12
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	12
c	0
b	0
f	0
rs	9.4285
cc	3
eloc	5
nc	3
nop	1

<?php

/*
 * This file is part of the ICanBoogie package.
 *
 * (c) Olivier Laviale <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ICanBoogie\View;

use ICanBoogie\Accessor\AccessorTrait;
use ICanBoogie\EventCollectionProvider;
use ICanBoogie\OffsetNotDefined;
use ICanBoogie\PropertyNotDefined;
use ICanBoogie\Render\Renderer;
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 Renderer $renderer 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 AccessorTrait;

	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 = '_';

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

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

	/**
	 * @var Renderer
	 */
	private $renderer;

	/**
	 * @return Renderer
	 */
	protected function get_renderer()
	{
		return $this->renderer;
	}

	/**
	 * 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.
	 * @param Renderer $renderer
	 */
	public function __construct(Controller $controller, Renderer $renderer)
	{
		$this->controller = $controller;
		$this->renderer = $renderer;
		$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)->with_prefix($prefix);
		}

		try
		{
			return $this->renderer->resolve_template($name);
		}
		catch (TemplateNotFound $e)
		{
			$tried = $e->tried;

			return null;
		}
	}

	/**
	 * 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 string
	 */
	protected function decorate($content)
	{
		$decorators = array_reverse($this->decorators);

		foreach ($decorators as $template)
		{
			$content = $this->renderer->render([

				Renderer::OPTION_CONTENT => $content,
				Renderer::OPTION_LAYOUT => $template

			]);
		}

		return $content;
	}

	/**
	 * Render the view.
	 *
	 * @return string
	 */
	public function render()
	{
		return $this->decorate($this->renderer->render([

			Renderer::OPTION_CONTENT => $this->content,
			Renderer::OPTION_TEMPLATE => $this->template,
			Renderer::OPTION_LAYOUT => $this->layout,
			Renderer::OPTION_LOCALS => $this->variables

		]));
	}

	/**
	 * Render a partial.
	 *
	 * @param string $template
	 * @param array $locals
	 * @param array $options
	 *
	 * @return string
	 */
	public function partial($template, array $locals = [], array $options = [])
	{
		return $this->renderer->render([

			Renderer::OPTION_PARTIAL => $template,
			Renderer::OPTION_LOCALS => $locals

		], $options);
	}

	/**
	 * 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;
	}
}


1			<?php
2
3			/*
4			* This file is part of the ICanBoogie package.
5			*
6			* (c) Olivier Laviale <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace ICanBoogie\View;
13
14			use ICanBoogie\Accessor\AccessorTrait;
15			use ICanBoogie\EventCollectionProvider;
16			use ICanBoogie\OffsetNotDefined;
17			use ICanBoogie\PropertyNotDefined;
18			use ICanBoogie\Render\Renderer;
19			use ICanBoogie\Render\TemplateName;
20			use ICanBoogie\Render\TemplateNotFound;
21			use ICanBoogie\Routing\Controller;
22
23			/**
24			* A view.
25			*
26			* @property-read Controller $controller The controller invoking the view.
27			* @property-read Renderer $renderer The controller invoking the view.
28			* @property-read array $variables The variables to pass to the template.
29			* @property mixed $content The content of the view.
30			* @property string $layout The name of the layout that should decorate the content.
31			* @property string $template The name of the template that should render the content.
32			* @property-read callable[] $layout_resolvers @internal
33			* @property-read callable[] $template_resolvers @internal
34			*/
35			class View implements \ArrayAccess, \JsonSerializable
36			{
37			use AccessorTrait;
38
39			const TEMPLATE_TYPE_VIEW = 1;
40			const TEMPLATE_TYPE_LAYOUT = 2;
41			const TEMPLATE_TYPE_PARTIAL = 3;
42
43			const TEMPLATE_PREFIX_VIEW = '';
44			const TEMPLATE_PREFIX_LAYOUT = '@';
45			const TEMPLATE_PREFIX_PARTIAL = '_';
46
47			/**
48			* @var Controller
49			*/
50			private $controller;
51
52			/**
53			* @return Controller
54			*/
55			protected function get_controller()
56			{
57			return $this->controller;
58			}
59
60			/**
61			* @var Renderer
62			*/
63			private $renderer;
64
65			/**
66			* @return Renderer
67			*/
68			protected function get_renderer()
69			{
70			return $this->renderer;
71			}
72
73			/**
74			* View's variables.
75			*
76			* @var array
77			*/
78			private $variables = [];
79
80			/**
81			* @see $variables
82			*
83			* @return array
84			*/
85			protected function get_variables()
86			{
87			return $this->variables;
88			}
89
90			/**
91			* @see $content
92			*
93			* @return mixed
94			*/
95			protected function get_content()
96			{
97			return isset($this->variables['content']) ? $this->variables['content'] : null;
98			}
99
100			/**
101			* @see $content
102			*
103			* @param mixed $content
104			*/
105			protected function set_content($content)
106			{
107			$this->variables['content'] = $content;
108			}
109
110			private $decorators = [];
111
112			/**
113			* Return the name of the template.
114			*
115			* The template name is resolved as follows:
116			*
117			* - The `template` property of the route.
118			* - The `template` property of the controller.
119			* - The `{$controller->name}/{$controller->action}`, if the controller has an `action`
120			* property.
121			*
122			* @return string\|null
123			*/
124			protected function lazy_get_template()
125			{
126			$controller = $this->controller;
127
128			foreach ($this->template_resolvers as $provider)
129			{
130			try
131			{
132			return $provider($controller);
133			}
134			catch (PropertyNotDefined $e)
135			{
136			#
137			# Resolver failed, we continue with the next.
138			#
139			}
140
141			}
142
143			return null;
144			}
145
146			/**
147			* Returns an array of callable used to resolve the {@link $template} property.
148			*
149			* @return callable[]
150			*
151			* @internal
152			*/
153			protected function get_template_resolvers()
154			{
155			return [
156
157			function ($controller) {
158
159			return $controller->route->template;
160
161			},
162
163			function ($controller) {
164
165			return $controller->template;
166
167			},
168
169			function ($controller) {
170
171			return $controller->name . "/" . $controller->action;
172
173			}
174
175			];
176			}
177
178			/**
179			* Returns the name of the layout.
180			*
181			* The layout name is resolved as follows:
182			*
183			* - The `layout` property of the route.
184			* - The `layout` property of the controller.
185			* - If the identifier of the route starts with "admin:", "admin" is returned.
186			* - If the route pattern is "/" and a "home" layout template is available, "home" is returned.
187			* - If the "@page" template is available, "page" is returned.
188			* - "default" is returned.
189			*
190			* @return string
191			*/
192			protected function lazy_get_layout()
193			{
194			$controller = $this->controller;
195
196			foreach ($this->layout_resolvers as $resolver)
197			{
198			try
199			{
200			return $resolver($controller);
201			}
202			catch (PropertyNotDefined $e)
203			{
204			#
205			# Resolver failed, we continue with the next.
206			#
207			}
208
209			}
210
211			if (strpos($controller->route->id, "admin:") === 0)
212			{
213			return 'admin';
214			}
215
216			if ($controller->route->pattern == "/" && $this->resolve_template('home', self::TEMPLATE_PREFIX_LAYOUT))
217			{
218			return 'home';
219			}
220
221			if ($this->resolve_template('page', self::TEMPLATE_PREFIX_LAYOUT))
222			{
223			return 'page';
224			}
225
226			return 'default';
227			}
228
229			/**
230			* Returns an array of callable used to resolve the {@link $template} property.
231			*
232			* @return callable[]
233			*
234			* @internal
235			*/
236			protected function get_layout_resolvers()
237			{
238			return [
239
240			function ($controller) {
241
242			return $controller->route->layout;
243
244			},
245
246			function ($controller) {
247
248			return $controller->layout;
249
250			}
251
252			];
253			}
254
255			/**
256			* An event hook is attached to the `action` event of the controller for late rendering,
257			* which only happens if the response is `null`.
258			*
259			* @param Controller $controller The controller that invoked the view.
260			* @param Renderer $renderer
261			*/
262			public function __construct(Controller $controller, Renderer $renderer)
263			{
264			$this->controller = $controller;
265			$this->renderer = $renderer;
266			$this['view'] = $this;
267
268			EventCollectionProvider::provide()->attach_to($controller, function (Controller\ActionEvent $event, Controller $target) {
269
270			$this->on_action($event);
271
272			});
273			}
274
275			/**
276			* @inheritdoc
277			*
278			* Returns an array with the following keys: `template`, `layout`, and `variables`.
279			*/
280			public function jsonSerialize()
281			{
282			return [
283
284			'template' => $this->template,
285			'layout' => $this->layout,
286			'variables' => $this->ensure_without_this($this->variables)
287
288			];
289			}
290
291			/**
292			* @inheritdoc
293			*/
294			public function offsetExists($offset)
295			{
296			return array_key_exists($offset, $this->variables);
297			}
298
299			/**
300			* @inheritdoc
301			*
302			* @throws OffsetNotDefined if the offset is not defined.
303			*/
304			public function offsetGet($offset)
305			{
306			if (!$this->offsetExists($offset))
307			{
308			throw new OffsetNotDefined([ $offset, $this ]);
309			}
310
311			return $this->variables[$offset];
312			}
313
314			/**
315			* @inheritdoc
316			*/
317			public function offsetSet($offset, $value)
318			{
319			$this->variables[$offset] = $value;
320			}
321
322			/**
323			* @inheritdoc
324			*/
325			public function offsetUnset($offset)
326			{
327			unset($this->variables[$offset]);
328			}
329
330			/**
331			* Assign multiple variables.
332			*
333			* @param array $variables
334			*
335			* @return $this
336			*/
337			public function assign(array $variables)
338			{
339			$this->variables = array_merge($this->variables, $variables);
340
341			return $this;
342			}
343
344			/**
345			* Resolve a template pathname from its name and type.
346			*
347			* @param string $name Name of the template.
348			* @param string $prefix Template prefix.
349			* @param array $tried Reference to an array where tried paths are collected.
350			*
351			* @return string\|false
352			*/
353			protected function resolve_template($name, $prefix, &$tried = [])
354			{
355			$tried = $tried ?: [];
356
357			if ($prefix)
358			{
359			$name = TemplateName::from($name)->with_prefix($prefix);
360			}
361
362			try
363			{
364			return $this->renderer->resolve_template($name);
365			}
366			catch (TemplateNotFound $e)
367			{
368			$tried = $e->tried;
369
370			return null;
371			}
372			}
373
374			/**
375			* Add a template to decorate the content with.
376			*
377			* @param string $template Name of the template.
378			*/
379			public function decorate_with($template)
380			{
381			$this->decorators[] = $template;
382			}
383
384			/**
385			* Decorate the content.
386			*
387			* @param mixed $content The content to decorate.
388			*
389			* @return string
390			*/
391			protected function decorate($content)
392			{
393			$decorators = array_reverse($this->decorators);
394
395			foreach ($decorators as $template)
396			{
397			$content = $this->renderer->render([
398
399			Renderer::OPTION_CONTENT => $content,
400			Renderer::OPTION_LAYOUT => $template
401
402			]);
403			}
404
405			return $content;
406			}
407
408			/**
409			* Render the view.
410			*
411			* @return string
412			*/
413			public function render()
414			{
415			return $this->decorate($this->renderer->render([
416
417			Renderer::OPTION_CONTENT => $this->content,
418			Renderer::OPTION_TEMPLATE => $this->template,
419			Renderer::OPTION_LAYOUT => $this->layout,
420			Renderer::OPTION_LOCALS => $this->variables
421
422			]));
423			}
424
425			/**
426			* Render a partial.
427			*
428			* @param string $template
429			* @param array $locals
430			* @param array $options
431			*
432			* @return string
433			*/
434			public function partial($template, array $locals = [], array $options = [])
435			{
436			return $this->renderer->render([
437
438			Renderer::OPTION_PARTIAL => $template,
439			Renderer::OPTION_LOCALS => $locals
440
441			], $options);
442			}
443
444			/**
445			* Renders the view on `Controller::action` event.
446			*
447			* Note: The view is not rendered if the event's response is defined, which is the case
448			* when the controller obtained a result after its execution.
449			*
450			* @param Controller\ActionEvent $event
451			*/
452			protected function on_action(Controller\ActionEvent $event)
453			{
454			if ($event->result !== null)
455			{
456			return;
457			}
458
459			new View\BeforeRenderEvent($this, $event->result);
460
461			if ($event->result !== null)
462			{
463			return;
464			}
465
466			$event->result = $this->render();
467			}
468
469			/**
470			* Ensures the array does not include our instance.
471			*
472			* @param array $array
473			*
474			* @return array
475			*/
476			private function ensure_without_this(array $array)
477			{
478			foreach ($array as $key => $value)
479			{
480			if ($value === $this)
481			{
482			unset($array[$key]);
483			}
484			}
485
486			return $array;
487			}
488			}
489

ICanBoogie / View

View::ensure_without_this() A last analyzed 2016-11-07 11:42 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

View::ensure_without_this() A
last analyzed 2016-11-07 11:42 UTC