Block::isChildOf() - Code Metrics - Inspection of "Merge branch 'release2.10.6'" - RicLeP/laravel-storyblok - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 328472...7b9327 )

by Richard

created 2022-03-24 11:26 UTC

Block::isChildOf() A

↳ Parent: Block

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
c	0
b	0
f	0
nc	1
nop	1
dl	0
loc	3
rs	10

<?php


namespace Riclep\Storyblok;

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
use Illuminate\View\View;
use Riclep\Storyblok\Exceptions\UnableToRenderException;
use Riclep\Storyblok\Fields\Asset;
use Riclep\Storyblok\Fields\Image;
use Riclep\Storyblok\Fields\MultiAsset;
use Riclep\Storyblok\Fields\RichText;
use Riclep\Storyblok\Fields\Table;
use Riclep\Storyblok\Traits\CssClasses;
use Riclep\Storyblok\Traits\HasChildClasses;
use Riclep\Storyblok\Traits\HasMeta;
use Storyblok\ApiException;

class Block implements \IteratorAggregate, \JsonSerializable
{
	use CssClasses;
	use HasChildClasses;
	use HasMeta;

	/**
	 * @var bool resolve UUID relations automatically
	 */
	public $_autoResolveRelations = false;

	/**
	 * @var array list of field names containing relations to resolve
	 */
	public $_resolveRelations = [];

	/**
	 * @var bool Remove unresolved relations such as those that 404
	 */
	public $_filterRelations = true;

	/**
	 * @var array the path of nested components
	 */
	public $_componentPath = [];

	/**
	 * @var array the path of nested components
	 */
	protected $_casts = [];

	/**
	 * @var Collection all the fields for the Block
	 */
	private $_fields;

	/**
	 * @var Page|Block reference to the parent Block or Page
	 */
	private $_parent;

	/**
	 * Takes the Block’s content and a reference to the parent
	 * @param $content
	 * @param $parent
	 */
	public function __construct($content, $parent = null)
	{
		$this->_parent = $parent;
		$this->preprocess($content);

		if ($parent) {
			$this->_componentPath = array_merge($parent->_componentPath, [Str::lower($this->meta()['component'])]);
		}

		$this->processFields();

		// run automatic traits - methods matching initTraitClassName()
		foreach (class_uses_recursive($this) as $trait) {
			if (method_exists($this, $method = 'init' . class_basename($trait))) {
				$this->{$method}();
			}
		}
	}

	/**
	 * Returns the containing every field of content
	 *
	 * @return Collection
	 */
	public function content() {
		return $this->_fields;
	}

	/**
	 * Checks if the fields contain the specified key
	 *
	 * @param $key
	 * @return bool
	 */
	public function has($key) {
		return $this->_fields->has($key);
	}

	/**
	 * Returns the parent Block
	 *
	 * @return Block
	 */
	public function parent() {
		return $this->_parent;
	}

	/**
	 * Returns the page this Block belongs to
	 *
	 * @return Block
	 */
	public function page() {
		if ($this->parent() instanceof Page) {

			return $this->parent();
		}

		return $this->parent()->page();
	}

	/**
	 * Returns the first matching view, passing it the fields
	 *
	 * @return View
	 * @throws UnableToRenderException
	 */
	public function render() {
		try {
			return view()->first($this->views(), ['block' => $this]);
		} catch (\Exception $exception) {
			throw new UnableToRenderException('None of the views in the given array exist.', $this);
		}
	}

	/**
	 * Returns an array of possible views for the current Block based on
	 * it’s $componentPath match the component prefixed by each of it’s
	 * ancestors in turn, starting with the closest, for example:
	 *
	 * $componentPath = ['page', 'parent', 'child', 'this_block'];
	 *
	 * Becomes a list of possible views like so:
	 * ['child.this_block', 'parent.this_block', 'page.this_block'];
	 *
	 * Override this method with your custom implementation for
	 * ultimate control
	 *
	 * @return array
	 */
	public function views() {
		$compontentPath = $this->_componentPath;
		array_pop($compontentPath);

		$views = array_map(function($path) {
			return config('storyblok.view_path') . 'blocks.' . $path . '.' . $this->component();
		}, $compontentPath);

		$views = array_reverse($views);

		$views[] = config('storyblok.view_path') . 'blocks.' . $this->component();

		return $views;
	}

	/**
	 * Returns a component X generations previous
	 *
	 * @param $generation int
	 * @return mixed
	 */
	public function ancestorComponentName($generation)
	{
		return $this->_componentPath[count($this->_componentPath) - ($generation + 1)];
	}

	/**
	 * Checks if the current component is a child of another
	 *
	 * @param $parent string
	 * @return bool
	 */
	public function isChildOf($parent)
	{
		return $this->_componentPath[count($this->_componentPath) - 2] === $parent;
	}

	/**
	 * Checks if the component is an ancestor of another
	 *
	 * @param $parent string
	 * @return bool
	 */
	public function isAncestorOf($parent)
	{
		return in_array($parent, $this->parent()->_componentPath);
	}

	/**
	 * Returns the current Block’s component name from Storyblok
	 *
	 * @return string
	 */
	public function component() {
		return $this->_meta['component'];
	}


	/**
	 * Returns the HTML comment required for making this Block clickable in
	 * Storyblok’s visual editor. Don’t forget to set comments to true in
	 * your Vue.js app configuration.
	 *
	 * @return string
	 */
	public function editorLink() {
		if (array_key_exists('_editable', $this->_meta) && config('storyblok.edit_mode')) {
			return $this->_meta['_editable'];
		}

		return '';
	}


	/**
	 * Magic accessor to pull content from the _fields collection. Works just like
	 * Laravel’s model accessors. Matches public methods with the follow naming
	 * convention getSomeFieldAttribute() - called via $block->some_field
	 *
	 * @param $key
	 * @return null|string
	 */
	public function __get($key) {
		$accessor = 'get' . Str::studly($key) . 'Attribute';

		if (method_exists($this, $accessor)) {
			return $this->$accessor();
		}

		if ($this->has($key)) {
			return $this->_fields[$key];
		}

		return null;
	}

	/**
	 * Loops over every field to get the ball rolling
	 */
	private function processFields() {
		$this->_fields->transform(function ($field, $key) {
			return $this->getFieldType($field, $key);
		});
	}

	/**
	 * Converts fields into Field Classes based on various properties of their content
	 *
	 * @param $field
	 * @param $key
	 * @return array|Collection|mixed|Asset|Image|MultiAsset|RichText|Table
	 * @throws \Storyblok\ApiException
	 */
	private function getFieldType($field, $key) {
		$factory = new FieldFactory();
		return $factory->build($this, $field, $key);
	}

	/**
	 * Storyblok returns fields and other meta content at the same level so
	 * let’s do a little tidying up first
	 *
	 * @param $content
	 */
	private function preprocess($content) {
		$this->_fields = collect(array_diff_key($content, array_flip(['_editable', '_uid', 'component'])));

		// remove non-content keys
		$this->_meta = array_intersect_key($content, array_flip(['_editable', '_uid', 'component']));
	}

	/**
	 * Casting Block to JSON
	 *
	 * @return Collection|mixed
	 */
	public function jsonSerialize()
	{
		return $this->content();
	}

	/**
	 * Let’s up loop over the fields in Blade without needing to
	 * delve deep into the content collection
	 *
	 * @return \Traversable
	 */
	public function getIterator() {
		return $this->_fields;
	}

	public function getRelation(RequestStory $request, $relation) {
		try {
			$response = $request->get($relation);

			$class = $this->getChildClassName('Block', $response['content']['component']);
			$relationClass = new $class($response['content'], $this);

			$relationClass->addMeta([
				'name' => $response['name'],
				'published_at' => $response['published_at'],
				'full_slug' => $response['full_slug'],
			]);

			return $relationClass;
		} catch (ApiException $e) {
			return null;
		}
	}

	public function getCasts() {
		return $this->_casts;
	}
}

1			<?php
2
3
4			namespace Riclep\Storyblok;
5
6			use Illuminate\Support\Collection;
7			use Illuminate\Support\Str;
8			use Illuminate\View\View;
9			use Riclep\Storyblok\Exceptions\UnableToRenderException;
10			use Riclep\Storyblok\Fields\Asset;
11			use Riclep\Storyblok\Fields\Image;
12			use Riclep\Storyblok\Fields\MultiAsset;
13			use Riclep\Storyblok\Fields\RichText;
14			use Riclep\Storyblok\Fields\Table;
15			use Riclep\Storyblok\Traits\CssClasses;
16			use Riclep\Storyblok\Traits\HasChildClasses;
17			use Riclep\Storyblok\Traits\HasMeta;
18			use Storyblok\ApiException;
19
20			class Block implements \IteratorAggregate, \JsonSerializable
21			{
22			use CssClasses;
23			use HasChildClasses;
24			use HasMeta;
25
26			/**
27			* @var bool resolve UUID relations automatically
28			*/
29			public $_autoResolveRelations = false;
30
31			/**
32			* @var array list of field names containing relations to resolve
33			*/
34			public $_resolveRelations = [];
35
36			/**
37			* @var bool Remove unresolved relations such as those that 404
38			*/
39			public $_filterRelations = true;
40
41			/**
42			* @var array the path of nested components
43			*/
44			public $_componentPath = [];
45
46			/**
47			* @var array the path of nested components
48			*/
49			protected $_casts = [];
50
51			/**
52			* @var Collection all the fields for the Block
53			*/
54			private $_fields;
55
56			/**
57			* @var Page\|Block reference to the parent Block or Page
58			*/
59			private $_parent;
60
61			/**
62			* Takes the Block’s content and a reference to the parent
63			* @param $content
64			* @param $parent
65			*/
66			public function __construct($content, $parent = null)
67			{
68			$this->_parent = $parent;
69			$this->preprocess($content);
70
71			if ($parent) {
72			$this->_componentPath = array_merge($parent->_componentPath, [Str::lower($this->meta()['component'])]);
73			}
74
75			$this->processFields();
76
77			// run automatic traits - methods matching initTraitClassName()
78			foreach (class_uses_recursive($this) as $trait) {
79			if (method_exists($this, $method = 'init' . class_basename($trait))) {
80			$this->{$method}();
81			}
82			}
83			}
84
85			/**
86			* Returns the containing every field of content
87			*
88			* @return Collection
89			*/
90			public function content() {
91			return $this->_fields;
92			}
93
94			/**
95			* Checks if the fields contain the specified key
96			*
97			* @param $key
98			* @return bool
99			*/
100			public function has($key) {
101			return $this->_fields->has($key);
102			}
103
104			/**
105			* Returns the parent Block
106			*
107			* @return Block
108			*/
109			public function parent() {
110			return $this->_parent;
111			}
112
113			/**
114			* Returns the page this Block belongs to
115			*
116			* @return Block
117			*/
118			public function page() {
119			if ($this->parent() instanceof Page) {
			0 ignored issues – show introduced 2020-07-28 13:29 UTC by Report Bug Copy Issue Report `$this->parent()` is never a sub-type of `Riclep\Storyblok\Page`. Loading history...
120			return $this->parent();
121			}
122
123			return $this->parent()->page();
124			}
125
126			/**
127			* Returns the first matching view, passing it the fields
128			*
129			* @return View
130			* @throws UnableToRenderException
131			*/
132			public function render() {
133			try {
134			return view()->first($this->views(), ['block' => $this]);
135			} catch (\Exception $exception) {
136			throw new UnableToRenderException('None of the views in the given array exist.', $this);
137			}
138			}
139
140			/**
141			* Returns an array of possible views for the current Block based on
142			* it’s $componentPath match the component prefixed by each of it’s
143			* ancestors in turn, starting with the closest, for example:
144			*
145			* $componentPath = ['page', 'parent', 'child', 'this_block'];
146			*
147			* Becomes a list of possible views like so:
148			* ['child.this_block', 'parent.this_block', 'page.this_block'];
149			*
150			* Override this method with your custom implementation for
151			* ultimate control
152			*
153			* @return array
154			*/
155			public function views() {
156			$compontentPath = $this->_componentPath;
157			array_pop($compontentPath);
158
159			$views = array_map(function($path) {
160			return config('storyblok.view_path') . 'blocks.' . $path . '.' . $this->component();
161			}, $compontentPath);
162
163			$views = array_reverse($views);
164
165			$views[] = config('storyblok.view_path') . 'blocks.' . $this->component();
166
167			return $views;
168			}
169
170			/**
171			* Returns a component X generations previous
172			*
173			* @param $generation int
174			* @return mixed
175			*/
176			public function ancestorComponentName($generation)
177			{
178			return $this->_componentPath[count($this->_componentPath) - ($generation + 1)];
179			}
180
181			/**
182			* Checks if the current component is a child of another
183			*
184			* @param $parent string
185			* @return bool
186			*/
187			public function isChildOf($parent)
188			{
189			return $this->_componentPath[count($this->_componentPath) - 2] === $parent;
190			}
191
192			/**
193			* Checks if the component is an ancestor of another
194			*
195			* @param $parent string
196			* @return bool
197			*/
198			public function isAncestorOf($parent)
199			{
200			return in_array($parent, $this->parent()->_componentPath);
201			}
202
203			/**
204			* Returns the current Block’s component name from Storyblok
205			*
206			* @return string
207			*/
208			public function component() {
209			return $this->_meta['component'];
210			}
211
212
213			/**
214			* Returns the HTML comment required for making this Block clickable in
215			* Storyblok’s visual editor. Don’t forget to set comments to true in
216			* your Vue.js app configuration.
217			*
218			* @return string
219			*/
220			public function editorLink() {
221			if (array_key_exists('_editable', $this->_meta) && config('storyblok.edit_mode')) {
222			return $this->_meta['_editable'];
223			}
224
225			return '';
226			}
227
228
229			/**
230			* Magic accessor to pull content from the _fields collection. Works just like
231			* Laravel’s model accessors. Matches public methods with the follow naming
232			* convention getSomeFieldAttribute() - called via $block->some_field
233			*
234			* @param $key
235			* @return null\|string
236			*/
237			public function __get($key) {
238			$accessor = 'get' . Str::studly($key) . 'Attribute';
239
240			if (method_exists($this, $accessor)) {
241			return $this->$accessor();
242			}
243
244			if ($this->has($key)) {
245			return $this->_fields[$key];
246			}
247
248			return null;
249			}
250
251			/**
252			* Loops over every field to get the ball rolling
253			*/
254			private function processFields() {
255			$this->_fields->transform(function ($field, $key) {
256			return $this->getFieldType($field, $key);
257			});
258			}
259
260			/**
261			* Converts fields into Field Classes based on various properties of their content
262			*
263			* @param $field
264			* @param $key
265			* @return array\|Collection\|mixed\|Asset\|Image\|MultiAsset\|RichText\|Table
266			* @throws \Storyblok\ApiException
267			*/
268			private function getFieldType($field, $key) {
269			$factory = new FieldFactory();
270			return $factory->build($this, $field, $key);
271			}
272
273			/**
274			* Storyblok returns fields and other meta content at the same level so
275			* let’s do a little tidying up first
276			*
277			* @param $content
278			*/
279			private function preprocess($content) {
280			$this->_fields = collect(array_diff_key($content, array_flip(['_editable', '_uid', 'component'])));
281
282			// remove non-content keys
283			$this->_meta = array_intersect_key($content, array_flip(['_editable', '_uid', 'component']));
284			}
285
286			/**
287			* Casting Block to JSON
288			*
289			* @return Collection\|mixed
290			*/
291			public function jsonSerialize()
292			{
293			return $this->content();
294			}
295
296			/**
297			* Let’s up loop over the fields in Blade without needing to
298			* delve deep into the content collection
299			*
300			* @return \Traversable
301			*/
302			public function getIterator() {
303			return $this->_fields;
304			}
305
306			public function getRelation(RequestStory $request, $relation) {
307			try {
308			$response = $request->get($relation);
309
310			$class = $this->getChildClassName('Block', $response['content']['component']);
311			$relationClass = new $class($response['content'], $this);
312
313			$relationClass->addMeta([
314			'name' => $response['name'],
315			'published_at' => $response['published_at'],
316			'full_slug' => $response['full_slug'],
317			]);
318
319			return $relationClass;
320			} catch (ApiException $e) {
321			return null;
322			}
323			}
324
325			public function getCasts() {
326			return $this->_casts;
327			}
328			}

RicLeP / laravel-storyblok

Push — master ( 328472...7b9327 )

Block::isChildOf() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like