Document::setInclude() - Code Metrics - Inspection of "New resource-based API" - tobscure/json-api - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#119)

by Toby

created 2017-03-28 11:18 UTC

Document::setInclude() A

↳ Parent: Document

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	1.2963

Importance

Changes

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

<?php

/*
 * This file is part of JSON-API.
 *
 * (c) Toby Zerner <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Tobscure\JsonApi;

use JsonSerializable;

class Document implements JsonSerializable
{
    use LinksTrait;
    use SelfLinkTrait;
    use PaginationLinksTrait;
    use MetaTrait;

    const MEDIA_TYPE = 'application/vnd.api+json';
    const DEFAULT_API_VERSION = '1.0';

    /**
     * The primary data.
     *
     * @var ResourceInterface|ResourceInterface[]|null
     */
    protected $data;

    /**
     * The errors array.
     *
     * @var Error[]|null
     */
    protected $errors;

    /**
     * The jsonapi array.
     *
     * @var array|null
     */
    protected $jsonapi;

    /**
     * Relationships to include.
     *
     * @var array
     */
    protected $include = [];

    /**
     * Sparse fieldsets.
     *
     * @var array
     */
    protected $fields = [];

    /**
     * Use named constructors instead.
     */
    private function __construct()
    {
    }

    /**
     * @param ResourceInterface|ResourceInterface[] $data
     *
     * @return self
     */
    public static function fromData($data)
    {
        $document = new self;
        $document->setData($data);

        return $document;
    }

    /**
     * @param array $meta
     *
     * @return self
     */
    public static function fromMeta(array $meta)
    {
        $document = new self;
        $document->replaceMeta($meta);

        return $document;
    }

    /**
     * @param Error[] $errors
     *
     * @return self
     */
    public static function fromErrors(array $errors)
    {
        $document = new self;
        $document->setErrors($errors);

        return $document;
    }

    /**
     * Get the primary data.
     *
     * @return ResourceInterface|ResourceInterface[]|null $data
     */
    public function getData()
    {
        return $this->data;
    }

    /**
     * Set the data object.
     *
     * @param ResourceInterface|ResourceInterface[]|null $data
     */
    public function setData($data)
    {
        $this->data = $data;
    }

    /**
     * Get the errors array.
     *
     * @return Error[]|null $errors
     */
    public function getErrors()
    {
        return $this->errors;
    }

    /**
     * Set the errors array.
     *
     * @param Error[]|null $errors
     */
    public function setErrors(array $errors = null)
    {
        $this->errors = $errors;
    }

    /**
     * Set the jsonapi version.
     *
     * @param string $version
     */
    public function setApiVersion($version)
    {
        $this->jsonapi['version'] = $version;
    }

    /**
     * Set the jsonapi meta information.
     * 
     * @param array $meta
     */
    public function setApiMeta(array $meta)
    {
        $this->jsonapi['meta'] = $meta;
    }

    /**
     * Get the relationships to include.
     *
     * @return string[] $include
     */
    public function getInclude()
    {
        return $this->include;
    }

    /**
     * Set the relationships to include.
     *
     * @param string[] $include
     */
    public function setInclude(array $include)
    {
        $this->include = $include;
    }

    /**
     * Get the sparse fieldsets.
     *
     * @return array[] $fields
     */
    public function getFields()
    {
        return $this->fields;
    }

    /**
     * Set the sparse fieldsets.
     *
     * @param array[] $fields
     */
    public function setFields(array $fields)
    {
        $this->fields = $fields;
    }

    /**
     * Serialize for JSON usage.
     *
     * @return array
     */
    public function jsonSerialize()
    {
        $document = [
            'links' => $this->links,
            'meta' => $this->meta,
            'errors' => $this->errors,
            'jsonapi' => $this->jsonapi
        ];

        if ($this->data) {
            $isCollection = is_array($this->data);

            // Build a multi-dimensional map of all of the distinct resources
            // that are present in the document, indexed by type and ID. This is
            // done by recursively looping through each of the resources and
            // their included relationships. We do this so that any resources
            // that are duplicated may be merged back into a single instance.
            $map = [];
            $resources = $isCollection ? $this->data : [$this->data];

            $this->mergeResources($map, $resources, $this->include);

            // Now extract the document's primary resource(s) from the resource
            // map, and flatten the map's remaining resources to be included in
            // the document's "included" array.
            foreach ($resources as $resource) {
                $type = $resource->getType();
                $id = $resource->getId();

                if (isset($map[$type][$id])) {
                    $primary[] = $map[$type][$id];
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
                    unset($map[$type][$id]);
                }
            }

            $document['data'] = $isCollection ? $primary : $primary[0];
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            $document['included'] = call_user_func_array('array_merge', $map);
        }

        return array_filter($document);
    }

    /**
     * Build the JSON-API document and encode it as a JSON string.
     *
     * @return string
     */
    public function __toString()
    {
        return json_encode($this->jsonSerialize());
    }

    /**
     * Recursively add the given resources and their relationships to a map.
     *
     * @param array &$map The map to merge resources into.
     * @param ResourceInterface[] $resources
     * @param array $include An array of relationship paths to include.
     */
    private function mergeResources(array &$map, array $resources, array $include)
    {
        // Index relationship paths so that we have a list of the direct
        // relationships that will be included on these resources, and arrays
        // of their respective nested relationships.
        $include = $this->indexRelationshipPaths($include);

        foreach ($resources as $resource) {
            $relationships = [];

            // Get each of the relationships we're including on this resource,
            // and add their resources (and their relationships, and so on) to
            // the map.
            foreach ($include as $name => $nested) {
                if (! ($relationship = $resource->getRelationship($name))) {
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
                    continue;
                }

                $relationships[$name] = $relationship;

                if ($data = $relationship->getData()) {
                    $children = is_array($data) ? $data : [$data];

                    $this->mergeResources($map, $children, $nested);
                }
            }

            // Serialize the resource into an array and add it to the map. If
            // it is already present, its properties will be merged into the
            // existing resource.
            $this->mergeResource($map, $resource, $relationships);
        }
    }

    /**
     * Merge the given resource into a resource map.
     *
     * If it is already present in the map, its properties will be merged into
     * the existing resource.
     *
     * @param array &$map
     * @param ResourceInterface $resource
     * @param Relationship[] $relationships
     */
    private function mergeResource(array &$map, ResourceInterface $resource, array $relationships)
    {
        $type = $resource->getType();
        $id = $resource->getId();
        $meta = $resource->getMeta();
        $links = $resource->getLinks();

        $fields = isset($this->fields[$type]) ? $this->fields[$type] : null;

        $attributes = $resource->getAttributes($fields);

        if ($fields) {
            $keys = array_flip($fields);

            $attributes = array_intersect_key($attributes, $keys);
            $relationships = array_intersect_key($relationships, $keys);
        }

        $props = array_filter(compact('attributes', 'relationships', 'links', 'meta'));

        if (empty($map[$type][$id])) {
            $map[$type][$id] = compact('type', 'id') + $props;
        } else {
            $map[$type][$id] = array_replace_recursive($map[$type][$id], $props);
        }        
    }

    /**
     * Index relationship paths by top-level relationships.
     *
     * Given an array of relationship paths such as:
     *
     * ['user', 'user.employer', 'user.employer.country', 'comments']
     *
     * Returns an array with key-value pairs of top-level relationships and
     * their nested relationships:
     *
     * ['user' => ['employer', 'employer.country'], 'comments' => []]
     *
     * @param string[] $paths
     *
     * @return array[]
     */
    private function indexRelationshipPaths(array $paths)
    {
        $tree = [];

        foreach ($paths as $path) {
            list($primary, $nested) = array_pad(explode('.', $path, 2), 2, null);

            if (! isset($tree[$primary])) {
                $tree[$primary] = [];
            }

            if ($nested) {
                $tree[$primary][] = $nested;
            }
        }

        return $tree;
    }
}


1		<?php
2
3		/*
4		* This file is part of JSON-API.
5		*
6		* (c) Toby Zerner <[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 Tobscure\JsonApi;
13
14		use JsonSerializable;
15
16		class Document implements JsonSerializable
17		{
18		use LinksTrait;
19		use SelfLinkTrait;
20		use PaginationLinksTrait;
21		use MetaTrait;
22
23		const MEDIA_TYPE = 'application/vnd.api+json';
24		const DEFAULT_API_VERSION = '1.0';
25
26		/**
27		* The primary data.
28		*
29		* @var ResourceInterface\|ResourceInterface[]\|null
30		*/
31		protected $data;
32
33		/**
34		* The errors array.
35		*
36		* @var Error[]\|null
37		*/
38		protected $errors;
39
40		/**
41		* The jsonapi array.
42		*
43		* @var array\|null
44		*/
45		protected $jsonapi;
46
47		/**
48		* Relationships to include.
49		*
50		* @var array
51		*/
52	12	protected $include = [];
53
54	12	/**
55	12	* Sparse fieldsets.
56		*
57		* @var array
58		*/
59		protected $fields = [];
60
61		/**
62		* Use named constructors instead.
63		*/
64		private function __construct()
65	9	{
66		}
67	9
68		/**
69	9	* @param ResourceInterface\|ResourceInterface[] $data
70	9	*
71		* @return self
72		*/
73		public static function fromData($data)
74	9	{
75	3	$document = new self;
76	3	$document->setData($data);
77	9
78	9	return $document;
79		}
80
81	9	/**
82	3	* @param array $meta
83		*
84	3	* @return self
85		*/
86		public static function fromMeta(array $meta)
87		{
88	3	$document = new self;
89		$document->replaceMeta($meta);
90
91		return $document;
92	3	}
93
94		/**
95		* @param Error[] $errors
96	3	*
97	3	* @return self
98	9	*/
99	9	public static function fromErrors(array $errors)
100		{
101	9	$document = new self;
102		$document->setErrors($errors);
103
104	3	return $document;
105	9	}
106
107	9	/**
108		* Get the primary data.
109		*
110		* @return ResourceInterface\|ResourceInterface[]\|null $data
111		*/
112		public function getData()
113		{
114		return $this->data;
115		}
116	3
117		/**
118	3	* Set the data object.
119	3	*
120		* @param ResourceInterface\|ResourceInterface[]\|null $data
121	3	*/
122		public function setData($data)
123		{
124	3	$this->data = $data;
125		}
126
127	3	/**
128		* Get the errors array.
129		*
130		* @return Error[]\|null $errors
131		*/
132		public function getErrors()
133		{
134		return $this->errors;
135		}
136
137		/**
138		* Set the errors array.
139		*
140		* @param Error[]\|null $errors
141		*/
142		public function setErrors(array $errors = null)
143		{
144		$this->errors = $errors;
145		}
146
147		/**
148		* Set the jsonapi version.
149		*
150		* @param string $version
151		*/
152		public function setApiVersion($version)
153		{
154		$this->jsonapi['version'] = $version;
155		}
156
157		/**
158		* Set the jsonapi meta information.
159		*
160		* @param array $meta
161		*/
162		public function setApiMeta(array $meta)
163		{
164		$this->jsonapi['meta'] = $meta;
165		}
166
167		/**
168		* Get the relationships to include.
169		*
170		* @return string[] $include
171		*/
172		public function getInclude()
173		{
174		return $this->include;
175		}
176
177	12	/**
178		* Set the relationships to include.
179	12	*
180		* @param string[] $include
181	12	*/
182		public function setInclude(array $include)
183		{
184		$this->include = $include;
185	12	}
186	9
187		/**
188	9	* Get the sparse fieldsets.
189		*
190	9	* @return array[] $fields
191	3	*/
192	3	public function getFields()
193	3	{
194	3	return $this->fields;
195	9	}
196
197	12	/**
198		* Set the sparse fieldsets.
199		*
200		* @param array[] $fields
201	12	*/
202		public function setFields(array $fields)
203		{
204		$this->fields = $fields;
205	12	}
206
207		/**
208		* Serialize for JSON usage.
209	12	*
210		* @return array
211		*/
212		public function jsonSerialize()
213		{
214		$document = [
215		'links' => $this->links,
216		'meta' => $this->meta,
217	6	'errors' => $this->errors,
218		'jsonapi' => $this->jsonapi
219	6	];
220
221		if ($this->data) {
222		$isCollection = is_array($this->data);
223
224		// Build a multi-dimensional map of all of the distinct resources
225		// that are present in the document, indexed by type and ID. This is
226		// done by recursively looping through each of the resources and
227		// their included relationships. We do this so that any resources
228		// that are duplicated may be merged back into a single instance.
229		$map = [];
230		$resources = $isCollection ? $this->data : [$this->data];
231
232		$this->mergeResources($map, $resources, $this->include);
233
234		// Now extract the document's primary resource(s) from the resource
235		// map, and flatten the map's remaining resources to be included in
236		// the document's "included" array.
237		foreach ($resources as $resource) {
238		$type = $resource->getType();
239		$id = $resource->getId();
240
241		if (isset($map[$type][$id])) {
242		$primary[] = $map[$type][$id];
		0 ignored issues – show Coding Style Comprehensibility introduced 2017-03-09 05:44 UTC by Report Bug Copy Issue Report `$primary` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$primary = array();` before regardless. Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code. Let’s take a look at an example: foreach ($collection as $item) { $myArray['foo'] = $item->getFoo(); if ($item->hasBar()) { $myArray['bar'] = $item->getBar(); } // do something with $myArray } As you can see in this example, the array `$myArray` is initialized the first time when the foreach loop is entered. You can also see that the value of the `bar` key is only written conditionally; thus, its value might result from a previous iteration. This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization `$myArray = array()` either outside or inside the foreach loop. Loading history...
243		unset($map[$type][$id]);
244		}
245		}
246
247		$document['data'] = $isCollection ? $primary : $primary[0];
		0 ignored issues – show Bug introduced 2017-03-09 05:44 UTC by Report Bug Copy Issue Report The variable `$primary` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
248		$document['included'] = call_user_func_array('array_merge', $map);
249		}
250
251		return array_filter($document);
252		}
253
254		/**
255		* Build the JSON-API document and encode it as a JSON string.
256		*
257		* @return string
258		*/
259		public function __toString()
260		{
261		return json_encode($this->jsonSerialize());
262		}
263
264		/**
265		* Recursively add the given resources and their relationships to a map.
266		*
267		* @param array &$map The map to merge resources into.
268		* @param ResourceInterface[] $resources
269		* @param array $include An array of relationship paths to include.
270		*/
271		private function mergeResources(array &$map, array $resources, array $include)
272		{
273		// Index relationship paths so that we have a list of the direct
274		// relationships that will be included on these resources, and arrays
275		// of their respective nested relationships.
276		$include = $this->indexRelationshipPaths($include);
277
278		foreach ($resources as $resource) {
279		$relationships = [];
280
281		// Get each of the relationships we're including on this resource,
282		// and add their resources (and their relationships, and so on) to
283		// the map.
284		foreach ($include as $name => $nested) {
285		if (! ($relationship = $resource->getRelationship($name))) {
		0 ignored issues – show Bug introduced 2017-03-09 05:44 UTC by Report Bug Copy Issue Report Are you sure the assignment to `$relationship` is correct as `$resource->getRelationship($name)` (which targets `Tobscure\JsonApi\Resourc...face::getRelationship()`) seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
286		continue;
287		}
288
289		$relationships[$name] = $relationship;
290
291		if ($data = $relationship->getData()) {
292		$children = is_array($data) ? $data : [$data];
293
294		$this->mergeResources($map, $children, $nested);
295		}
296		}
297
298		// Serialize the resource into an array and add it to the map. If
299		// it is already present, its properties will be merged into the
300		// existing resource.
301		$this->mergeResource($map, $resource, $relationships);
302		}
303		}
304
305		/**
306		* Merge the given resource into a resource map.
307		*
308		* If it is already present in the map, its properties will be merged into
309		* the existing resource.
310		*
311		* @param array &$map
312		* @param ResourceInterface $resource
313		* @param Relationship[] $relationships
314		*/
315		private function mergeResource(array &$map, ResourceInterface $resource, array $relationships)
316		{
317		$type = $resource->getType();
318		$id = $resource->getId();
319		$meta = $resource->getMeta();
320		$links = $resource->getLinks();
321
322		$fields = isset($this->fields[$type]) ? $this->fields[$type] : null;
323
324		$attributes = $resource->getAttributes($fields);
325
326		if ($fields) {
327		$keys = array_flip($fields);
328
329		$attributes = array_intersect_key($attributes, $keys);
330		$relationships = array_intersect_key($relationships, $keys);
331		}
332
333		$props = array_filter(compact('attributes', 'relationships', 'links', 'meta'));
334
335		if (empty($map[$type][$id])) {
336		$map[$type][$id] = compact('type', 'id') + $props;
337		} else {
338		$map[$type][$id] = array_replace_recursive($map[$type][$id], $props);
339		}
340		}
341
342		/**
343		* Index relationship paths by top-level relationships.
344		*
345		* Given an array of relationship paths such as:
346		*
347		* ['user', 'user.employer', 'user.employer.country', 'comments']
348		*
349		* Returns an array with key-value pairs of top-level relationships and
350		* their nested relationships:
351		*
352		* ['user' => ['employer', 'employer.country'], 'comments' => []]
353		*
354		* @param string[] $paths
355		*
356		* @return array[]
357		*/
358		private function indexRelationshipPaths(array $paths)
359		{
360		$tree = [];
361
362		foreach ($paths as $path) {
363		list($primary, $nested) = array_pad(explode('.', $path, 2), 2, null);
364
365		if (! isset($tree[$primary])) {
366		$tree[$primary] = [];
367		}
368
369		if ($nested) {
370		$tree[$primary][] = $nested;
371		}
372		}
373
374		return $tree;
375		}
376		}
377

tobscure / json-api

Pull Request — master (#119)

Document::setInclude() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like