Scope::getParentScopes() - Code Metrics - Inspection of "Implement \JsonSerializable for Scopes (#462)" - thephpleague/fractal - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1cb9cd...ecf884 )

by Korvin

created 2019-07-04 21:11 UTC

Scope::getParentScopes() A

↳ Parent: Scope

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0
crap	1

<?php

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

namespace League\Fractal;

use InvalidArgumentException;
use League\Fractal\Resource\Collection;
use League\Fractal\Resource\Item;
use League\Fractal\Resource\Primitive;
use League\Fractal\Resource\NullResource;
use League\Fractal\Resource\ResourceInterface;
use League\Fractal\Serializer\SerializerAbstract;

/**
 * Scope
 *
 * The scope class acts as a tracker, relating a specific resource in a specific
 * context. For example, the same resource could be attached to multiple scopes.
 * There are root scopes, parent scopes and child scopes.
 */
class Scope implements \JsonSerializable
{
    /**
     * @var array
     */
    protected $availableIncludes = [];

    /**
     * @var string
     */
    protected $scopeIdentifier;

    /**
     * @var \League\Fractal\Manager
     */
    protected $manager;

    /**
     * @var ResourceInterface
     */
    protected $resource;

    /**
     * @var array
     */
    protected $parentScopes = [];

    /**
     * Create a new scope instance.
     *
     * @param Manager           $manager
     * @param ResourceInterface $resource
     * @param string            $scopeIdentifier
     *
     * @return void
     */
    public function __construct(Manager $manager, ResourceInterface $resource, $scopeIdentifier = null)
    {
        $this->manager = $manager;
        $this->resource = $resource;
        $this->scopeIdentifier = $scopeIdentifier;
    }

    /**
     * Embed a scope as a child of the current scope.
     *
     * @internal
     *
     * @param string            $scopeIdentifier
     * @param ResourceInterface $resource
     *
     * @return \League\Fractal\Scope
     */
    public function embedChildScope($scopeIdentifier, $resource)
    {
        return $this->manager->createData($resource, $scopeIdentifier, $this);
    }

    /**
     * Get the current identifier.
     *
     * @return string
     */
    public function getScopeIdentifier()
    {
        return $this->scopeIdentifier;
    }

    /**
     * Get the unique identifier for this scope.
     *
     * @param string $appendIdentifier
     *
     * @return string
     */
    public function getIdentifier($appendIdentifier = null)
    {
        $identifierParts = array_merge($this->parentScopes, [$this->scopeIdentifier, $appendIdentifier]);

        return implode('.', array_filter($identifierParts));
    }

    /**
     * Getter for parentScopes.
     *
     * @return mixed
     */
    public function getParentScopes()
    {
        return $this->parentScopes;
    }

    /**
     * Getter for resource.
     *
     * @return ResourceInterface
     */
    public function getResource()
    {
        return $this->resource;
    }

    /**
     * Getter for manager.
     *
     * @return \League\Fractal\Manager
     */
    public function getManager()
    {
        return $this->manager;
    }

    /**
     * Is Requested.
     *
     * Check if - in relation to the current scope - this specific segment is allowed.
     * That means, if a.b.c is requested and the current scope is a.b, then c is allowed. If the current
     * scope is a then c is not allowed, even if it is there and potentially transformable.
     *
     * @internal
     *
     * @param string $checkScopeSegment
     *
     * @return bool Returns the new number of elements in the array.
     */
    public function isRequested($checkScopeSegment)

    {
        if ($this->parentScopes) {

            $scopeArray = array_slice($this->parentScopes, 1);
            array_push($scopeArray, $this->scopeIdentifier, $checkScopeSegment);
        } else {
            $scopeArray = [$checkScopeSegment];
        }

        $scopeString = implode('.', (array) $scopeArray);

        return in_array($scopeString, $this->manager->getRequestedIncludes());
    }

    /**
     * Is Excluded.
     *
     * Check if - in relation to the current scope - this specific segment should
     * be excluded. That means, if a.b.c is excluded and the current scope is a.b,
     * then c will not be allowed in the transformation whether it appears in
     * the list of default or available, requested includes.
     *
     * @internal
     *
     * @param string $checkScopeSegment
     *
     * @return bool
     */
    public function isExcluded($checkScopeSegment)

    {
        if ($this->parentScopes) {

            $scopeArray = array_slice($this->parentScopes, 1);
            array_push($scopeArray, $this->scopeIdentifier, $checkScopeSegment);
        } else {
            $scopeArray = [$checkScopeSegment];
        }

        $scopeString = implode('.', (array) $scopeArray);

        return in_array($scopeString, $this->manager->getRequestedExcludes());
    }

    /**
     * Push Parent Scope.
     *
     * Push a scope identifier into parentScopes
     *
     * @internal
     *
     * @param string $identifierSegment
     *
     * @return int Returns the new number of elements in the array.
     */
    public function pushParentScope($identifierSegment)
    {
        return array_push($this->parentScopes, $identifierSegment);
    }

    /**
     * Set parent scopes.
     *
     * @internal
     *
     * @param string[] $parentScopes Value to set.
     *
     * @return $this
     */
    public function setParentScopes($parentScopes)
    {
        $this->parentScopes = $parentScopes;

        return $this;
    }

    /**
     * Convert the current data for this scope to an array.
     *
     * @return array
     */
    public function toArray()
    {
        list($rawData, $rawIncludedData) = $this->executeResourceTransformers();

        $serializer = $this->manager->getSerializer();

        $data = $this->serializeResource($serializer, $rawData);

        // If the serializer wants the includes to be side-loaded then we'll
        // serialize the included data and merge it with the data.
        if ($serializer->sideloadIncludes()) {
            //Filter out any relation that wasn't requested
            $rawIncludedData = array_map(array($this, 'filterFieldsets'), $rawIncludedData);

            $includedData = $serializer->includedData($this->resource, $rawIncludedData);

            // If the serializer wants to inject additional information
            // about the included resources, it can do so now.
            $data = $serializer->injectData($data, $rawIncludedData);

            if ($this->isRootScope()) {
                // If the serializer wants to have a final word about all
                // the objects that are sideloaded, it can do so now.
                $includedData = $serializer->filterIncludes(
                    $includedData,
                    $data
                );
            }

            $data = $data + $includedData;
        }

        if (!empty($this->availableIncludes)) {
            $data = $serializer->injectAvailableIncludeData($data, $this->availableIncludes);
        }

        if ($this->resource instanceof Collection) {
            if ($this->resource->hasCursor()) {
                $pagination = $serializer->cursor($this->resource->getCursor());
            } elseif ($this->resource->hasPaginator()) {
                $pagination = $serializer->paginator($this->resource->getPaginator());
            }

            if (! empty($pagination)) {
                $this->resource->setMetaValue(key($pagination), current($pagination));
            }
        }

        // Pull out all of OUR metadata and any custom meta data to merge with the main level data
        $meta = $serializer->meta($this->resource->getMeta());

        // in case of returning NullResource we should return null and not to go with array_merge
        if (is_null($data)) {
            if (!empty($meta)) {
                return $meta;
            }
            return null;
        }

        return $data + $meta;
    }

    /**
     * @return array
     */
    public function jsonSerialize()
    {
        return $this->toArray();
    }

  /**
     * Convert the current data for this scope to JSON.
     *
     * @param int $options
     *
     * @return string
     */
    public function toJson($options = 0)
    {
        return json_encode($this, $options);
    }

    /**
     * Transformer a primitive resource
     *
     * @return mixed
     */
    public function transformPrimitiveResource()
    {
        if (! ($this->resource instanceof Primitive)) {
            throw new InvalidArgumentException(
                'Argument $resource should be an instance of League\Fractal\Resource\Primitive'
            );
        }

        $transformer = $this->resource->getTransformer();
        $data = $this->resource->getData();

        if (null === $transformer) {
            $transformedData = $data;
        } elseif (is_callable($transformer)) {
            $transformedData = call_user_func($transformer, $data);
        } else {
            $transformer->setCurrentScope($this);
            $transformedData = $transformer->transform($data);
        }

        return $transformedData;
    }

    /**
     * Execute the resources transformer and return the data and included data.
     *
     * @internal
     *
     * @return array
     */
    protected function executeResourceTransformers()
    {
        $transformer = $this->resource->getTransformer();
        $data = $this->resource->getData();

        $transformedData = $includedData = [];

        if ($this->resource instanceof Item) {
            list($transformedData, $includedData[]) = $this->fireTransformer($transformer, $data);
        } elseif ($this->resource instanceof Collection) {
            foreach ($data as $value) {
                list($transformedData[], $includedData[]) = $this->fireTransformer($transformer, $value);
            }
        } elseif ($this->resource instanceof NullResource) {
            $transformedData = null;
            $includedData = [];
        } else {
            throw new InvalidArgumentException(
                'Argument $resource should be an instance of League\Fractal\Resource\Item'
                .' or League\Fractal\Resource\Collection'
            );
        }

        return [$transformedData, $includedData];
    }

    /**
     * Serialize a resource
     *
     * @internal
     *
     * @param SerializerAbstract $serializer
     * @param mixed              $data
     *
     * @return array
     */
    protected function serializeResource(SerializerAbstract $serializer, $data)
    {
        $resourceKey = $this->resource->getResourceKey();

        if ($this->resource instanceof Collection) {
            return $serializer->collection($resourceKey, $data);
        }

        if ($this->resource instanceof Item) {
            return $serializer->item($resourceKey, $data);
        }

        return $serializer->null();
    }

    /**
     * Fire the main transformer.
     *
     * @internal
     *
     * @param TransformerAbstract|callable $transformer
     * @param mixed                        $data
     *
     * @return array
     */
    protected function fireTransformer($transformer, $data)
    {
        $includedData = [];

        if (is_callable($transformer)) {
            $transformedData = call_user_func($transformer, $data);
        } else {
            $transformer->setCurrentScope($this);
            $transformedData = $transformer->transform($data);
        }

        if ($this->transformerHasIncludes($transformer)) {
            $includedData = $this->fireIncludedTransformers($transformer, $data);
            $transformedData = $this->manager->getSerializer()->mergeIncludes($transformedData, $includedData);
        }

        //Stick only with requested fields
        $transformedData = $this->filterFieldsets($transformedData);

        return [$transformedData, $includedData];
    }

    /**
     * Fire the included transformers.
     *
     * @internal
     *
     * @param \League\Fractal\TransformerAbstract $transformer
     * @param mixed                               $data
     *
     * @return array
     */
    protected function fireIncludedTransformers($transformer, $data)
    {
        $this->availableIncludes = $transformer->getAvailableIncludes();

        return $transformer->processIncludedResources($this, $data) ?: [];
    }

    /**
     * Determine if a transformer has any available includes.
     *
     * @internal
     *
     * @param TransformerAbstract|callable $transformer
     *
     * @return bool
     */
    protected function transformerHasIncludes($transformer)
    {
        if (! $transformer instanceof TransformerAbstract) {
            return false;
        }

        $defaultIncludes = $transformer->getDefaultIncludes();
        $availableIncludes = $transformer->getAvailableIncludes();

        return ! empty($defaultIncludes) || ! empty($availableIncludes);
    }

    /**
     * Check, if this is the root scope.
     *
     * @return bool
     */
    protected function isRootScope()
    {
        return empty($this->parentScopes);
    }

    /**
     * Filter the provided data with the requested filter fieldset for
     * the scope resource
     *
     * @internal
     *
     * @param array  $data
     *
     * @return array
     */
    protected function filterFieldsets(array $data)
    {
        if (!$this->hasFilterFieldset()) {
            return $data;
        }
        $serializer = $this->manager->getSerializer();
        $requestedFieldset = iterator_to_array($this->getFilterFieldset());
        //Build the array of requested fieldsets with the mandatory serializer fields
        $filterFieldset = array_flip(
            array_merge(
                $serializer->getMandatoryFields(),
                $requestedFieldset
            )
        );
        return array_intersect_key($data, $filterFieldset);
    }

    /**
     * Return the requested filter fieldset for the scope resource
     *
     * @internal
     *
     * @return \League\Fractal\ParamBag|null
     */
    protected function getFilterFieldset()
    {
        return $this->manager->getFieldset($this->getResourceType());
    }

    /**
     * Check if there are requested filter fieldsets for the scope resource.
     *
     * @internal
     *
     * @return bool
     */
    protected function hasFilterFieldset()
    {
        return $this->getFilterFieldset() !== null;
    }

    /**
     * Return the scope resource type.
     *
     * @internal
     *
     * @return string
     */
    protected function getResourceType()
    {
        return $this->resource->getResourceKey();
    }
}


1			<?php
2
3			/*
4			* This file is part of the League\Fractal package.
5			*
6			* (c) Phil Sturgeon <[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 League\Fractal;
13
14			use InvalidArgumentException;
15			use League\Fractal\Resource\Collection;
16			use League\Fractal\Resource\Item;
17			use League\Fractal\Resource\Primitive;
18			use League\Fractal\Resource\NullResource;
19			use League\Fractal\Resource\ResourceInterface;
20			use League\Fractal\Serializer\SerializerAbstract;
21
22			/**
23			* Scope
24			*
25			* The scope class acts as a tracker, relating a specific resource in a specific
26			* context. For example, the same resource could be attached to multiple scopes.
27			* There are root scopes, parent scopes and child scopes.
28			*/
29			class Scope implements \JsonSerializable
30			{
31			/**
32			* @var array
33			*/
34			protected $availableIncludes = [];
35
36			/**
37			* @var string
38			*/
39			protected $scopeIdentifier;
40
41			/**
42			* @var \League\Fractal\Manager
43			*/
44			protected $manager;
45
46			/**
47			* @var ResourceInterface
48			*/
49			protected $resource;
50
51			/**
52			* @var array
53			*/
54			protected $parentScopes = [];
55
56			/**
57			* Create a new scope instance.
58			*
59			* @param Manager $manager
60			* @param ResourceInterface $resource
61			* @param string $scopeIdentifier
62			*
63			* @return void
64			*/
65	76		public function __construct(Manager $manager, ResourceInterface $resource, $scopeIdentifier = null)
66			{
67	76		$this->manager = $manager;
68	76		$this->resource = $resource;
69	76		$this->scopeIdentifier = $scopeIdentifier;
70	76		}
71
72			/**
73			* Embed a scope as a child of the current scope.
74			*
75			* @internal
76			*
77			* @param string $scopeIdentifier
78			* @param ResourceInterface $resource
79			*
80			* @return \League\Fractal\Scope
81			*/
82	36		public function embedChildScope($scopeIdentifier, $resource)
83			{
84	36		return $this->manager->createData($resource, $scopeIdentifier, $this);
85			}
86
87			/**
88			* Get the current identifier.
89			*
90			* @return string
91			*/
92	38		public function getScopeIdentifier()
93			{
94	38		return $this->scopeIdentifier;
95			}
96
97			/**
98			* Get the unique identifier for this scope.
99			*
100			* @param string $appendIdentifier
101			*
102			* @return string
103			*/
104	32		public function getIdentifier($appendIdentifier = null)
105			{
106	32		$identifierParts = array_merge($this->parentScopes, [$this->scopeIdentifier, $appendIdentifier]);
107
108	32		return implode('.', array_filter($identifierParts));
109			}
110
111			/**
112			* Getter for parentScopes.
113			*
114			* @return mixed
115			*/
116	38		public function getParentScopes()
117			{
118	38		return $this->parentScopes;
119			}
120
121			/**
122			* Getter for resource.
123			*
124			* @return ResourceInterface
125			*/
126	33		public function getResource()
127			{
128	33		return $this->resource;
129			}
130
131			/**
132			* Getter for manager.
133			*
134			* @return \League\Fractal\Manager
135			*/
136	32		public function getManager()
137			{
138	32		return $this->manager;
139			}
140
141			/**
142			* Is Requested.
143			*
144			* Check if - in relation to the current scope - this specific segment is allowed.
145			* That means, if a.b.c is requested and the current scope is a.b, then c is allowed. If the current
146			* scope is a then c is not allowed, even if it is there and potentially transformable.
147			*
148			* @internal
149			*
150			* @param string $checkScopeSegment
151			*
152			* @return bool Returns the new number of elements in the array.
153			*/
154	44	View Code Duplication	public function isRequested($checkScopeSegment)
			0 ignored issues – show Duplication introduced 2019-06-29 17:12 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
155			{
156	44		if ($this->parentScopes) {
			0 ignored issues – show Bug Best Practice introduced 2016-04-11 09:01 UTC by Report Bug Copy Issue Report The expression `$this->parentScopes` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
157	21		$scopeArray = array_slice($this->parentScopes, 1);
158	21		array_push($scopeArray, $this->scopeIdentifier, $checkScopeSegment);
159	21		} else {
160	44		$scopeArray = [$checkScopeSegment];
161			}
162
163	44		$scopeString = implode('.', (array) $scopeArray);
164
165	44		return in_array($scopeString, $this->manager->getRequestedIncludes());
166			}
167
168			/**
169			* Is Excluded.
170			*
171			* Check if - in relation to the current scope - this specific segment should
172			* be excluded. That means, if a.b.c is excluded and the current scope is a.b,
173			* then c will not be allowed in the transformation whether it appears in
174			* the list of default or available, requested includes.
175			*
176			* @internal
177			*
178			* @param string $checkScopeSegment
179			*
180			* @return bool
181			*/
182	32	View Code Duplication	public function isExcluded($checkScopeSegment)
			0 ignored issues – show Duplication introduced 2019-06-29 17:12 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
183			{
184	32		if ($this->parentScopes) {
			0 ignored issues – show Bug Best Practice introduced 2016-04-11 09:01 UTC by Report Bug Copy Issue Report The expression `$this->parentScopes` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
185	7		$scopeArray = array_slice($this->parentScopes, 1);
186	7		array_push($scopeArray, $this->scopeIdentifier, $checkScopeSegment);
187	7		} else {
188	32		$scopeArray = [$checkScopeSegment];
189			}
190
191	32		$scopeString = implode('.', (array) $scopeArray);
192
193	32		return in_array($scopeString, $this->manager->getRequestedExcludes());
194			}
195
196			/**
197			* Push Parent Scope.
198			*
199			* Push a scope identifier into parentScopes
200			*
201			* @internal
202			*
203			* @param string $identifierSegment
204			*
205			* @return int Returns the new number of elements in the array.
206			*/
207	1		public function pushParentScope($identifierSegment)
208			{
209	1		return array_push($this->parentScopes, $identifierSegment);
210			}
211
212			/**
213			* Set parent scopes.
214			*
215			* @internal
216			*
217			* @param string[] $parentScopes Value to set.
218			*
219			* @return $this
220			*/
221	37		public function setParentScopes($parentScopes)
222			{
223	37		$this->parentScopes = $parentScopes;
224
225	37		return $this;
226			}
227
228			/**
229			* Convert the current data for this scope to an array.
230			*
231			* @return array
232			*/
233	70		public function toArray()
234			{
235	70		list($rawData, $rawIncludedData) = $this->executeResourceTransformers();
236
237	69		$serializer = $this->manager->getSerializer();
238
239	69		$data = $this->serializeResource($serializer, $rawData);
240
241			// If the serializer wants the includes to be side-loaded then we'll
242			// serialize the included data and merge it with the data.
243	68		if ($serializer->sideloadIncludes()) {
244			//Filter out any relation that wasn't requested
245	40		$rawIncludedData = array_map(array($this, 'filterFieldsets'), $rawIncludedData);
246
247	40		$includedData = $serializer->includedData($this->resource, $rawIncludedData);
248
249			// If the serializer wants to inject additional information
250			// about the included resources, it can do so now.
251	40		$data = $serializer->injectData($data, $rawIncludedData);
252
253	40		if ($this->isRootScope()) {
254			// If the serializer wants to have a final word about all
255			// the objects that are sideloaded, it can do so now.
256	40		$includedData = $serializer->filterIncludes(
257	40		$includedData,
258			$data
259	40		);
260	40		}
261
262	40		$data = $data + $includedData;
263	40		}
264
265	68		if (!empty($this->availableIncludes)) {
266	47		$data = $serializer->injectAvailableIncludeData($data, $this->availableIncludes);
267	47		}
268
269	68		if ($this->resource instanceof Collection) {
270	31		if ($this->resource->hasCursor()) {
271	1		$pagination = $serializer->cursor($this->resource->getCursor());
272	31		} elseif ($this->resource->hasPaginator()) {
273	4		$pagination = $serializer->paginator($this->resource->getPaginator());
274	4		}
275
276	31		if (! empty($pagination)) {
277	5		$this->resource->setMetaValue(key($pagination), current($pagination));
278	5		}
279	31		}
280
281			// Pull out all of OUR metadata and any custom meta data to merge with the main level data
282	68		$meta = $serializer->meta($this->resource->getMeta());
283
284			// in case of returning NullResource we should return null and not to go with array_merge
285	68		if (is_null($data)) {
286	2		if (!empty($meta)) {
287	1		return $meta;
288			}
289	1		return null;
290			}
291
292	67		return $data + $meta;
293			}
294
295			/**
296			* @return array
297			*/
298	41		public function jsonSerialize()
299			{
300	41		return $this->toArray();
301			}
302
303			/**
304			* Convert the current data for this scope to JSON.
305			*
306			* @param int $options
307			*
308			* @return string
309			*/
310	40		public function toJson($options = 0)
311			{
312	40		return json_encode($this, $options);
313			}
314
315			/**
316			* Transformer a primitive resource
317			*
318			* @return mixed
319			*/
320	2		public function transformPrimitiveResource()
321			{
322	2		if (! ($this->resource instanceof Primitive)) {
323			throw new InvalidArgumentException(
324			'Argument $resource should be an instance of League\Fractal\Resource\Primitive'
325			);
326			}
327
328	2		$transformer = $this->resource->getTransformer();
329	2		$data = $this->resource->getData();
330
331	2		if (null === $transformer) {
332			$transformedData = $data;
333	2		} elseif (is_callable($transformer)) {
334	2		$transformedData = call_user_func($transformer, $data);
335	2		} else {
336	1		$transformer->setCurrentScope($this);
337	1		$transformedData = $transformer->transform($data);
338			}
339
340	2		return $transformedData;
341			}
342
343			/**
344			* Execute the resources transformer and return the data and included data.
345			*
346			* @internal
347			*
348			* @return array
349			*/
350	62		protected function executeResourceTransformers()
351			{
352	62		$transformer = $this->resource->getTransformer();
353	62		$data = $this->resource->getData();
354
355	62		$transformedData = $includedData = [];
356
357	62		if ($this->resource instanceof Item) {
358	45		list($transformedData, $includedData[]) = $this->fireTransformer($transformer, $data);
359	62		} elseif ($this->resource instanceof Collection) {
360	31		foreach ($data as $value) {
361	30		list($transformedData[], $includedData[]) = $this->fireTransformer($transformer, $value);
362	31		}
363	37		} elseif ($this->resource instanceof NullResource) {
364	5		$transformedData = null;
365	5		$includedData = [];
366	5		} else {
367	2		throw new InvalidArgumentException(
368			'Argument $resource should be an instance of League\Fractal\Resource\Item'
369			.' or League\Fractal\Resource\Collection'
370	2		);
371			}
372
373	60		return [$transformedData, $includedData];
374			}
375
376			/**
377			* Serialize a resource
378			*
379			* @internal
380			*
381			* @param SerializerAbstract $serializer
382			* @param mixed $data
383			*
384			* @return array
385			*/
386	60		protected function serializeResource(SerializerAbstract $serializer, $data)
387			{
388	60		$resourceKey = $this->resource->getResourceKey();
389
390	60		if ($this->resource instanceof Collection) {
391	31		return $serializer->collection($resourceKey, $data);
392			}
393
394	47		if ($this->resource instanceof Item) {
395	45		return $serializer->item($resourceKey, $data);
396			}
397
398	5		return $serializer->null();
399			}
400
401			/**
402			* Fire the main transformer.
403			*
404			* @internal
405			*
406			* @param TransformerAbstract\|callable $transformer
407			* @param mixed $data
408			*
409			* @return array
410			*/
411	58		protected function fireTransformer($transformer, $data)
412			{
413	58		$includedData = [];
414
415	58		if (is_callable($transformer)) {
416	6		$transformedData = call_user_func($transformer, $data);
417	6		} else {
418	52		$transformer->setCurrentScope($this);
419	52		$transformedData = $transformer->transform($data);
420			}
421
422	58		if ($this->transformerHasIncludes($transformer)) {
423	49		$includedData = $this->fireIncludedTransformers($transformer, $data);
424	49		$transformedData = $this->manager->getSerializer()->mergeIncludes($transformedData, $includedData);
425	49		}
426
427			//Stick only with requested fields
428	58		$transformedData = $this->filterFieldsets($transformedData);
429
430	58		return [$transformedData, $includedData];
431			}
432
433			/**
434			* Fire the included transformers.
435			*
436			* @internal
437			*
438			* @param \League\Fractal\TransformerAbstract $transformer
439			* @param mixed $data
440			*
441			* @return array
442			*/
443	49		protected function fireIncludedTransformers($transformer, $data)
444			{
445	49		$this->availableIncludes = $transformer->getAvailableIncludes();
446
447	49		return $transformer->processIncludedResources($this, $data) ?: [];
448			}
449
450			/**
451			* Determine if a transformer has any available includes.
452			*
453			* @internal
454			*
455			* @param TransformerAbstract\|callable $transformer
456			*
457			* @return bool
458			*/
459	58		protected function transformerHasIncludes($transformer)
460			{
461	58		if (! $transformer instanceof TransformerAbstract) {
462	6		return false;
463			}
464
465	52		$defaultIncludes = $transformer->getDefaultIncludes();
466	52		$availableIncludes = $transformer->getAvailableIncludes();
467
468	52		return ! empty($defaultIncludes) \|\| ! empty($availableIncludes);
469			}
470
471			/**
472			* Check, if this is the root scope.
473			*
474			* @return bool
475			*/
476	38		protected function isRootScope()
477			{
478	38		return empty($this->parentScopes);
479			}
480
481			/**
482			* Filter the provided data with the requested filter fieldset for
483			* the scope resource
484			*
485			* @internal
486			*
487			* @param array $data
488			*
489			* @return array
490			*/
491	58		protected function filterFieldsets(array $data)
492			{
493	58		if (!$this->hasFilterFieldset()) {
494	54		return $data;
495			}
496	10		$serializer = $this->manager->getSerializer();
497	10		$requestedFieldset = iterator_to_array($this->getFilterFieldset());
498			//Build the array of requested fieldsets with the mandatory serializer fields
499	10		$filterFieldset = array_flip(
500	10		array_merge(
501	10		$serializer->getMandatoryFields(),
502			$requestedFieldset
503	10		)
504	10		);
505	10		return array_intersect_key($data, $filterFieldset);
506			}
507
508			/**
509			* Return the requested filter fieldset for the scope resource
510			*
511			* @internal
512			*
513			* @return \League\Fractal\ParamBag\|null
514			*/
515	58		protected function getFilterFieldset()
516			{
517	58		return $this->manager->getFieldset($this->getResourceType());
518			}
519
520			/**
521			* Check if there are requested filter fieldsets for the scope resource.
522			*
523			* @internal
524			*
525			* @return bool
526			*/
527	58		protected function hasFilterFieldset()
528			{
529	58		return $this->getFilterFieldset() !== null;
530			}
531
532			/**
533			* Return the scope resource type.
534			*
535			* @internal
536			*
537			* @return string
538			*/
539	58		protected function getResourceType()
540			{
541	58		return $this->resource->getResourceKey();
542			}
543			}
544

thephpleague / fractal

Push — master ( 1cb9cd...ecf884 )

Scope::getParentScopes() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like