Document - 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-27 13:49 UTC

Document B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	395
Duplicated Lines	1.52 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

67.12%

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
wmc	50
c	2
b	0
f	0
lcom	1
cbo	3
dl	6
loc	395
ccs	49
cts	73
cp	0.6712
rs	8.6206

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getData()	0	4	1
A	setData()	0	6	1
A	getErrors()	0	4	1
A	setErrors()	0	6	1
A	getJsonapi()	0	4	1
A	setJsonapi()	0	6	1
A	getInclude()	0	4	1
A	setInclude()	0	6	1
A	getFields()	0	4	1
A	setFields()	0	6	1
C	toArray()	0	57	11
B	addResourcesToMap()	0	33	6
D	addResourceToMap()	6	43	14
A	indexRelationshipPaths()	0	18	4
A	getFieldsForType()	0	4	2
A	__toString()	0	4	1
A	jsonSerialize()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Document often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Document, and based on these observations, apply Extract Interface, too.

<?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 MetaTrait;

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

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

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

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

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

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

    /**
     * @param ResourceInterface|ResourceInterface[] $data

     */
    public function __construct($data = null)
    {
        $this->data = $data;
    }

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

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

        return $this;
    }

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

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

        return $this;
    }

    /**
     * Get the jsonapi array.
     *
     * @return array|null $jsonapi
     */
    public function getJsonapi()
    {
        return $this->jsonapi;
    }

    /**
     * Set the jsonapi array.
     *
     * @param array|null $jsonapi
     *
     * @return $this
     */
    public function setJsonapi(array $jsonapi = null)
    {
        $this->jsonapi = $jsonapi;

        return $this;
    }

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

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

        return $this;
    }

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

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

        return $this;
    }

    /**
     * Build the JSON-API document as an array.
     *
     * @return array
     */
    public function toArray()
    {
        $document = [];

        if ($this->links) {

            $document['links'] = $this->links;
        }

        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->addResourcesToMap($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]);
                }
            }

            $included = call_user_func_array('array_merge', $map);

            $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;
}

            if ($included) {
                $document['included'] = $included;
            }
        }

        if ($this->meta) {

            $document['meta'] = $this->meta;
        }

        if ($this->errors) {
            $document['errors'] = $this->errors;
        }

        if ($this->jsonapi) {
            $document['jsonapi'] = $this->jsonapi;
        }

        return $document;
    }

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

    /**
     * Serialize for JSON usage.
     *
     * @return array
     */
    public function jsonSerialize()
    {
        return $this->toArray();
    }

    /**
     * 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 addResourcesToMap(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->addResourcesToMap($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->addResourceToMap($map, $resource, $relationships);
        }
    }

    /**
     * Serialize the given resource as an array and add it to the given map.
     *
     * If it is already present in the map, its properties will be merged into
     * the existing array.
     *
     * @param array &$map
     * @param ResourceInterface $resource
     * @param Relationship[] $resource
     */
    private function addResourceToMap(array &$map, ResourceInterface $resource, array $relationships)
    {
        $type = $resource->getType();
        $id = $resource->getId();

        if (empty($map[$type][$id])) {
            $map[$type][$id] = [
                'type' => $type,
                'id' => $id
            ];
        }

        $array = &$map[$type][$id];
        $fields = $this->getFieldsForType($type);

        if ($meta = $resource->getMeta()) {

            $array['meta'] = array_replace_recursive(isset($array['meta']) ? $array['meta'] : [], $meta);
        }

        if ($links = $resource->getLinks()) {

            $array['links'] = array_replace_recursive(isset($array['links']) ? $array['links'] : [], $links);
        }

        if ($attributes = $resource->getAttributes($fields)) {
            if ($fields) {
                $attributes = array_intersect_key($attributes, array_flip($fields));
            }
            if ($attributes) {

                $array['attributes'] = array_replace_recursive(isset($array['attributes']) ? $array['attributes'] : [], $attributes);

            }
        }

        if ($relationships && $fields) {

            $relationships = array_intersect_key($relationships, array_flip($fields));
        }
        if ($relationships) {

            $relationships = array_map(function ($relationship) {
                return $relationship->toArray();
            }, $relationships);

            $array['relationships'] = array_replace_recursive(isset($array['relationships']) ? $array['relationships'] : [], $relationships);

        }
    }

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

    /**
     * Get the fields that should be included for resources of the given type.
     *
     * @param string $type
     *
     * @return array|null
     */
    private function getFieldsForType($type)
    {
        return isset($this->fields[$type]) ? $this->fields[$type] : null;
    }
}


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 MetaTrait;
20
21			const MEDIA_TYPE = 'application/vnd.api+json';
22
23			/**
24			* The data object.
25			*
26			* @var ResourceInterface\|ResourceInterface[]\|null
27			*/
28			protected $data;
29
30			/**
31			* The errors array.
32			*
33			* @var array\|null
34			*/
35			protected $errors;
36
37			/**
38			* The jsonapi array.
39			*
40			* @var array\|null
41			*/
42			protected $jsonapi;
43
44			/**
45			* Relationships to include.
46			*
47			* @var array
48			*/
49			protected $include = [];
50
51			/**
52	12		* Sparse fieldsets.
53			*
54	12		* @var array
55	12		*/
56			protected $fields = [];
57
58			/**
59			* @param ResourceInterface\|ResourceInterface[] $data
			0 ignored issues – show Documentation introduced 2017-03-09 05:44 UTC by Report Bug Copy Issue Report Should the type for parameter `$data` not be `ResourceInterface\|ResourceInterface[]\|null`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
60			*/
61			public function __construct($data = null)
62			{
63			$this->data = $data;
64			}
65	9
66			/**
67	9		* Get the data object.
68			*
69	9		* @return ResourceInterface\|ResourceInterface[]\|null $data
70	9		*/
71			public function getData()
72			{
73			return $this->data;
74	9		}
75	3
76	3		/**
77	9		* Set the data object.
78	9		*
79			* @param ResourceInterface\|ResourceInterface[]\|null $data
80			*
81	9		* @return $this
82	3		*/
83			public function setData($data)
84	3		{
85			$this->data = $data;
86
87			return $this;
88	3		}
89
90			/**
91			* Get the errors array.
92	3		*
93			* @return array\|null $errors
94			*/
95			public function getErrors()
96	3		{
97	3		return $this->errors;
98	9		}
99	9
100			/**
101	9		* Set the errors array.
102			*
103			* @param array\|null $errors
104	3		*
105	9		* @return $this
106			*/
107	9		public function setErrors(array $errors = null)
108			{
109			$this->errors = $errors;
110
111			return $this;
112			}
113
114			/**
115			* Get the jsonapi array.
116	3		*
117			* @return array\|null $jsonapi
118	3		*/
119	3		public function getJsonapi()
120			{
121	3		return $this->jsonapi;
122			}
123
124	3		/**
125			* Set the jsonapi array.
126			*
127	3		* @param array\|null $jsonapi
128			*
129			* @return $this
130			*/
131			public function setJsonapi(array $jsonapi = null)
132			{
133			$this->jsonapi = $jsonapi;
134
135			return $this;
136			}
137
138			/**
139			* Get the relationships to include.
140			*
141			* @return array $include
142			*/
143			public function getInclude()
144			{
145			return $this->include;
146			}
147
148			/**
149			* Set the relationships to include.
150			*
151			* @param array $include
152			*
153			* @return $this
154			*/
155			public function setInclude(array $include)
156			{
157			$this->include = $include;
158
159			return $this;
160			}
161
162			/**
163			* Get the sparse fieldsets.
164			*
165			* @return array $fields
166			*/
167			public function getFields()
168			{
169			return $this->fields;
170			}
171
172			/**
173			* Set the sparse fieldsets.
174			*
175			* @param array $fields
176			*
177	12		* @return $this
178			*/
179	12		public function setFields(array $fields)
180			{
181	12		$this->fields = $fields;
182
183			return $this;
184			}
185	12
186	9		/**
187			* Build the JSON-API document as an array.
188	9		*
189			* @return array
190	9		*/
191	3		public function toArray()
192	3		{
193	3		$document = [];
194	3
195	9		if ($this->links) {
			0 ignored issues – show Bug Best Practice introduced 2017-03-09 05:44 UTC by Report Bug Copy Issue Report The expression `$this->links` 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...
196			$document['links'] = $this->links;
197	12		}
198
199			if ($this->data) {
200			$isCollection = is_array($this->data);
201	12
202			// Build a multi-dimensional map of all of the distinct resources
203			// that are present in the document, indexed by type and ID. This is
204			// done by recursively looping through each of the resources and
205	12		// their included relationships. We do this so that any resources
206			// that are duplicated may be merged back into a single instance.
207			$map = [];
208			$resources = $isCollection ? $this->data : [$this->data];
209	12
210			$this->addResourcesToMap($map, $resources, $this->include);
211
212			// Now extract the document's primary resource(s) from the resource
213			// map, and flatten the map's remaining resources to be included in
214			// the document's "included" array.
215			foreach ($resources as $resource) {
216			$type = $resource->getType();
217	6		$id = $resource->getId();
218
219	6		if (isset($map[$type][$id])) {
220			$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...
221			unset($map[$type][$id]);
222			}
223			}
224
225			$included = call_user_func_array('array_merge', $map);
226
227			$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...
228
229			if ($included) {
230			$document['included'] = $included;
231			}
232			}
233
234			if ($this->meta) {
			0 ignored issues – show Bug Best Practice introduced 2017-03-09 05:44 UTC by Report Bug Copy Issue Report The expression `$this->meta` 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...
235			$document['meta'] = $this->meta;
236			}
237
238			if ($this->errors) {
239			$document['errors'] = $this->errors;
240			}
241
242			if ($this->jsonapi) {
243			$document['jsonapi'] = $this->jsonapi;
244			}
245
246			return $document;
247			}
248
249			/**
250			* Build the JSON-API document and encode it as a JSON string.
251			*
252			* @return string
253			*/
254			public function __toString()
255			{
256			return json_encode($this->toArray());
257			}
258
259			/**
260			* Serialize for JSON usage.
261			*
262			* @return array
263			*/
264			public function jsonSerialize()
265			{
266			return $this->toArray();
267			}
268
269			/**
270			* Recursively add the given resources and their relationships to a map.
271			*
272			* @param array &$map The map to merge resources into.
273			* @param ResourceInterface[] $resources
274			* @param array $include An array of relationship paths to include.
275			*/
276			private function addResourcesToMap(array &$map, array $resources, array $include)
277			{
278			// Index relationship paths so that we have a list of the direct
279			// relationships that will be included on these resources, and arrays
280			// of their respective nested relationships.
281			$include = $this->indexRelationshipPaths($include);
282
283			foreach ($resources as $resource) {
284			$relationships = [];
285
286			// Get each of the relationships we're including on this resource,
287			// and add their resources (and their relationships, and so on) to
288			// the map.
289			foreach ($include as $name => $nested) {
290			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...
291			continue;
292			}
293
294			$relationships[$name] = $relationship;
295
296			if ($data = $relationship->getData()) {
297			$children = is_array($data) ? $data : [$data];
298
299			$this->addResourcesToMap($map, $children, $nested);
300			}
301			}
302
303			// Serialize the resource into an array and add it to the map. If
304			// it is already present, its properties will be merged into the
305			// existing resource.
306			$this->addResourceToMap($map, $resource, $relationships);
307			}
308			}
309
310			/**
311			* Serialize the given resource as an array and add it to the given map.
312			*
313			* If it is already present in the map, its properties will be merged into
314			* the existing array.
315			*
316			* @param array &$map
317			* @param ResourceInterface $resource
318			* @param Relationship[] $resource
319			*/
320			private function addResourceToMap(array &$map, ResourceInterface $resource, array $relationships)
321			{
322			$type = $resource->getType();
323			$id = $resource->getId();
324
325			if (empty($map[$type][$id])) {
326			$map[$type][$id] = [
327			'type' => $type,
328			'id' => $id
329			];
330			}
331
332			$array = &$map[$type][$id];
333			$fields = $this->getFieldsForType($type);
334
335		View Code Duplication	if ($meta = $resource->getMeta()) {
			0 ignored issues – show Duplication introduced 2017-03-09 05:44 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
336			$array['meta'] = array_replace_recursive(isset($array['meta']) ? $array['meta'] : [], $meta);
337			}
338
339		View Code Duplication	if ($links = $resource->getLinks()) {
			0 ignored issues – show Duplication introduced 2017-03-09 05:44 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
340			$array['links'] = array_replace_recursive(isset($array['links']) ? $array['links'] : [], $links);
341			}
342
343			if ($attributes = $resource->getAttributes($fields)) {
344			if ($fields) {
345			$attributes = array_intersect_key($attributes, array_flip($fields));
346			}
347			if ($attributes) {
			0 ignored issues – show Bug Best Practice introduced 2017-03-09 05:44 UTC by Report Bug Copy Issue Report The expression `$attributes` 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...
348			$array['attributes'] = array_replace_recursive(isset($array['attributes']) ? $array['attributes'] : [], $attributes);
			0 ignored issues – show Coding Style introduced 2017-03-09 05:44 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 120 characters; contains 133 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
349			}
350			}
351
352			if ($relationships && $fields) {
			0 ignored issues – show Bug Best Practice introduced 2017-03-09 05:44 UTC by Report Bug Copy Issue Report The expression `$relationships` 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...
353			$relationships = array_intersect_key($relationships, array_flip($fields));
354			}
355			if ($relationships) {
			0 ignored issues – show Bug Best Practice introduced 2017-03-09 05:44 UTC by Report Bug Copy Issue Report The expression `$relationships` 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...
356			$relationships = array_map(function ($relationship) {
357			return $relationship->toArray();
358			}, $relationships);
359
360			$array['relationships'] = array_replace_recursive(isset($array['relationships']) ? $array['relationships'] : [], $relationships);
			0 ignored issues – show Coding Style introduced 2017-03-09 05:44 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 120 characters; contains 141 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
361			}
362			}
363
364			/**
365			* Index relationship paths by top-level relationships.
366			*
367			* Given an array of relationship paths such as:
368			*
369			* ['user', 'user.employer', 'user.employer.country', 'comments']
370			*
371			* Returns an array with key-value pairs of top-level relationships and
372			* their nested relationships:
373			*
374			* ['user' => ['employer', 'employer.country'], 'comments' => []]
375			*
376			* @param array $paths
377			*
378			* @return array
379			*/
380			private function indexRelationshipPaths(array $paths)
381			{
382			$tree = [];
383
384			foreach ($paths as $path) {
385			list($primary, $nested) = array_pad(explode('.', $path, 2), 2, null);
386
387			if (! isset($tree[$primary])) {
388			$tree[$primary] = [];
389			}
390
391			if ($nested) {
392			$tree[$primary][] = $nested;
393			}
394			}
395
396			return $tree;
397			}
398
399			/**
400			* Get the fields that should be included for resources of the given type.
401			*
402			* @param string $type
403			*
404			* @return array\|null
405			*/
406			private function getFieldsForType($type)
407			{
408			return isset($this->fields[$type]) ? $this->fields[$type] : null;
409			}
410			}
411

tobscure / json-api