Parser::getJsonApiDocumentRelationShips() - Code Metrics - Inspection of "Include attributes in get relationships" - swisnl/json-api-client - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#23)

unknown

created 2018-07-26 13:35 UTC

Parser::getJsonApiDocumentRelationShips() A

↳ Parent: Parser

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

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

<?php

namespace Swis\JsonApi\Client\JsonApi;

use Art4\JsonApiClient\DocumentInterface as Art4JsonApiDocumentInterface;
use Art4\JsonApiClient\ResourceCollectionInterface;
use Art4\JsonApiClient\ResourceItemInterface;
use Art4\JsonApiClient\Utils\Manager as Art4JsonApiClientManager;
use Swis\JsonApi\Client\Collection;
use Swis\JsonApi\Client\CollectionDocument;
use Swis\JsonApi\Client\Document;
use Swis\JsonApi\Client\Errors\ErrorCollection;
use Swis\JsonApi\Client\Interfaces\DocumentInterface;
use Swis\JsonApi\Client\Interfaces\ParserInterface;
use Swis\JsonApi\Client\ItemDocument;

class Parser implements ParserInterface
{
    /**
     * @var \Art4\JsonApiClient\Utils\Manager
     */
    protected $manager;

    /**
     * @var \Swis\JsonApi\Client\JsonApi\Hydrator
     */
    private $hydrator;

    /**
     * @var \Swis\JsonApi\Client\JsonApi\ErrorsParser
     */
    private $errorsParser;

    /**
     * @param \Art4\JsonApiClient\Utils\Manager         $manager
     * @param \Swis\JsonApi\Client\JsonApi\Hydrator     $hydrator
     * @param \Swis\JsonApi\Client\JsonApi\ErrorsParser $errorsParser
     */
    public function __construct(Art4JsonApiClientManager $manager, Hydrator $hydrator, ErrorsParser $errorsParser)
    {
        $this->manager = $manager;
        $this->hydrator = $hydrator;
        $this->errorsParser = $errorsParser;
    }

    /**
     * @return \Swis\JsonApi\Client\JsonApi\Hydrator
     */
    public function getHydrator(): Hydrator
    {
        return $this->hydrator;
    }

    /**
     * @param string $json
     *
     * @throws \DomainException
     *
     * @return \Swis\JsonApi\Client\Interfaces\DocumentInterface
     */
    public function deserialize(string $json): DocumentInterface
    {
        $jsonApiDocument = $this->getJsonApiDocument($json);

        if ($jsonApiDocument->has('data')) {
            $document = $this->buildDataDocument($jsonApiDocument);
        } else {
            $document = new Document();
        }

        $document->setLinks($this->parseLinks($jsonApiDocument));
        $document->setErrors($this->parseErrors($jsonApiDocument));
        $document->setMeta($this->parseMeta($jsonApiDocument));

        return $document;
    }

    /**
     * @param string $json
     *
     * @throws \DomainException
     *
     * @return \Art4\JsonApiClient\DocumentInterface
     */
    private function getJsonApiDocument(string $json): Art4JsonApiDocumentInterface
    {
        $jsonApiDocument = $this->manager->parse($json);

        if (!$jsonApiDocument instanceof Art4JsonApiDocumentInterface) {
            throw new \DomainException('Result is not a JSON API Document');
        }

        return $jsonApiDocument;
    }

    /**
     * @param \Art4\JsonApiClient\DocumentInterface $jsonApiDocument
     *
     * @throws \DomainException
     *includedInDocument
     *
     * @return \Swis\JsonApi\Client\Interfaces\DocumentInterface
     */
    protected function buildDataDocument(Art4JsonApiDocumentInterface $jsonApiDocument): DocumentInterface
    {
        $data = $this->getJsonApiDocumentData($jsonApiDocument);
        $includedInDocument = $this->getJsonApiDocumentIncluded($jsonApiDocument);
        $relationshipsInDocument = $this->getJsonApiDocumentRelationShips($jsonApiDocument);
        $allHydratedItems = new Collection();
        $allJsonApiItems = new Collection();

        if ($data instanceof ResourceItemInterface) {
            $item = $this->hydrator->hydrateItem($data);
            $allHydratedItems->push($item);
            $allJsonApiItems->push($data);

            $document = new ItemDocument();
            $document->setData($item);
        } elseif ($data instanceof ResourceCollectionInterface) {

            $collection = $this->hydrator->hydrateCollection($data);
            $allHydratedItems = $allHydratedItems->concat($collection);
            $allJsonApiItems = $allJsonApiItems->concat(new Collection($data->asArray()));

            $document = new CollectionDocument();
            $document->setData($collection);
        } else {
            throw new \DomainException('Data is not Collection or Item');
        }

        $included = null;
        if ($includedInDocument) {
            $included = $this->hydrator->hydrateCollection($includedInDocument);
            $allHydratedItems = $allHydratedItems->concat($included);
            $allJsonApiItems = $allJsonApiItems->concat(new Collection($includedInDocument->asArray()));
        }

        if ($relationshipsInDocument) {
            $relationships = $this->hydrator->hydrateRelationCollection($relationshipsInDocument);
            if ($includedInDocument) {
                $newRelationships = new Collection();
                foreach ($relationships as $relationship) {
                    $id = $relationship->getId();
                    $type = $relationship->getType();
                    $desiredObject = null;


                    //check duplicate
                    $desiredObject = $included->first(function ($item) use ($id, $type) {
                        return ($item->getId() == $id) && ($item->getType() == $type);
                    });
                    if (is_null($desiredObject)) {
                        $newRelationships->push($relationship);
                    }
                }
            } else {
                $newRelationships = $relationships;

            }
        }

        //$allHydratedItems Items will be in response
        $this->hydrator->hydrateRelationships($allJsonApiItems, $allHydratedItems);
        if ($included) {
            $document->setIncluded($included);
        }

        return $document;
    }

    /**
     * @param \Art4\JsonApiClient\DocumentInterface $document
     *
     * @throws \DomainException
     *
     * @return \Art4\JsonApiClient\ResourceItemInterface|\Art4\JsonApiClient\ResourceCollectionInterface
     */
    private function getJsonApiDocumentData(Art4JsonApiDocumentInterface $document)
    {
        $resource = $document->get('data');

        if (!$resource instanceof ResourceItemInterface && !$resource instanceof ResourceCollectionInterface) {
            throw new \DomainException('Result is not a Json API Resource');
        }

        return $resource;
    }

    /**
     * @param \Art4\JsonApiClient\DocumentInterface $document
     *
     * @return \Art4\JsonApiClient\ResourceCollection|null
     */
    private function getJsonApiDocumentIncluded(Art4JsonApiDocumentInterface $document)
    {
        if ($document->has('included')) {
            return $document->get('included');
        }

        return null;
    }

    /**
     * @param \Art4\JsonApiClient\DocumentInterface $document
     *
     * @return \Art4\JsonApiClient\ResourceCollection|null
     */
    private function getJsonApiDocumentRelationShips(Art4JsonApiDocumentInterface $document)
    {
        if ($document->has('data.relationships')) {
            return $document->get('data.relationships');
        }

        return null;
    }

    /**
     * @param \Art4\JsonApiClient\DocumentInterface $document
     *
     * @return array
     */
    private function parseLinks(Art4JsonApiDocumentInterface $document): array
    {
        if (!$document->has('links')) {
            return [];
        }

        return $document->get('links')->asArray(true);
    }

    /**
     * @param \Art4\JsonApiClient\DocumentInterface $document
     *
     * @return \Swis\JsonApi\Client\Errors\ErrorCollection
     */
    private function parseErrors(Art4JsonApiDocumentInterface $document): ErrorCollection
    {
        if (!$document->has('errors')) {
            return new ErrorCollection();
        }

        return $this->errorsParser->parse($document->get('errors'));
    }

    /**
     * @param \Art4\JsonApiClient\DocumentInterface $document
     *
     * @return array
     */
    private function parseMeta(Art4JsonApiDocumentInterface $document): array
    {
        if (!$document->has('meta')) {
            return [];
        }

        return $document->get('meta')->asArray(true);
    }

    /**
     * @param \Swis\JsonApi\Client\Interfaces\DocumentInterface $document
     *
     * @return string
     */
    public function serialize(DocumentInterface $document): string
    {
    }
}


1			<?php
2
3			namespace Swis\JsonApi\Client\JsonApi;
4
5			use Art4\JsonApiClient\DocumentInterface as Art4JsonApiDocumentInterface;
6			use Art4\JsonApiClient\ResourceCollectionInterface;
7			use Art4\JsonApiClient\ResourceItemInterface;
8			use Art4\JsonApiClient\Utils\Manager as Art4JsonApiClientManager;
9			use Swis\JsonApi\Client\Collection;
10			use Swis\JsonApi\Client\CollectionDocument;
11			use Swis\JsonApi\Client\Document;
12			use Swis\JsonApi\Client\Errors\ErrorCollection;
13			use Swis\JsonApi\Client\Interfaces\DocumentInterface;
14			use Swis\JsonApi\Client\Interfaces\ParserInterface;
15			use Swis\JsonApi\Client\ItemDocument;
16
17			class Parser implements ParserInterface
18			{
19			/**
20			* @var \Art4\JsonApiClient\Utils\Manager
21			*/
22			protected $manager;
23
24			/**
25			* @var \Swis\JsonApi\Client\JsonApi\Hydrator
26			*/
27			private $hydrator;
28
29			/**
30			* @var \Swis\JsonApi\Client\JsonApi\ErrorsParser
31			*/
32			private $errorsParser;
33
34			/**
35			* @param \Art4\JsonApiClient\Utils\Manager $manager
36			* @param \Swis\JsonApi\Client\JsonApi\Hydrator $hydrator
37			* @param \Swis\JsonApi\Client\JsonApi\ErrorsParser $errorsParser
38			*/
39			public function __construct(Art4JsonApiClientManager $manager, Hydrator $hydrator, ErrorsParser $errorsParser)
40			{
41			$this->manager = $manager;
42			$this->hydrator = $hydrator;
43			$this->errorsParser = $errorsParser;
44			}
45
46			/**
47			* @return \Swis\JsonApi\Client\JsonApi\Hydrator
48			*/
49			public function getHydrator(): Hydrator
50			{
51			return $this->hydrator;
52			}
53
54			/**
55			* @param string $json
56			*
57			* @throws \DomainException
58			*
59			* @return \Swis\JsonApi\Client\Interfaces\DocumentInterface
60			*/
61			public function deserialize(string $json): DocumentInterface
62			{
63			$jsonApiDocument = $this->getJsonApiDocument($json);
64
65			if ($jsonApiDocument->has('data')) {
66			$document = $this->buildDataDocument($jsonApiDocument);
67			} else {
68			$document = new Document();
69			}
70
71			$document->setLinks($this->parseLinks($jsonApiDocument));
72			$document->setErrors($this->parseErrors($jsonApiDocument));
73			$document->setMeta($this->parseMeta($jsonApiDocument));
74
75			return $document;
76			}
77
78			/**
79			* @param string $json
80			*
81			* @throws \DomainException
82			*
83			* @return \Art4\JsonApiClient\DocumentInterface
84			*/
85			private function getJsonApiDocument(string $json): Art4JsonApiDocumentInterface
86			{
87			$jsonApiDocument = $this->manager->parse($json);
88
89			if (!$jsonApiDocument instanceof Art4JsonApiDocumentInterface) {
90			throw new \DomainException('Result is not a JSON API Document');
91			}
92
93			return $jsonApiDocument;
94			}
95
96			/**
97			* @param \Art4\JsonApiClient\DocumentInterface $jsonApiDocument
98			*
99			* @throws \DomainException
100			*includedInDocument
101			*
102			* @return \Swis\JsonApi\Client\Interfaces\DocumentInterface
103			*/
104			protected function buildDataDocument(Art4JsonApiDocumentInterface $jsonApiDocument): DocumentInterface
105			{
106			$data = $this->getJsonApiDocumentData($jsonApiDocument);
107			$includedInDocument = $this->getJsonApiDocumentIncluded($jsonApiDocument);
108			$relationshipsInDocument = $this->getJsonApiDocumentRelationShips($jsonApiDocument);
109			$allHydratedItems = new Collection();
110			$allJsonApiItems = new Collection();
111
112			if ($data instanceof ResourceItemInterface) {
113			$item = $this->hydrator->hydrateItem($data);
114			$allHydratedItems->push($item);
115			$allJsonApiItems->push($data);
116
117			$document = new ItemDocument();
118			$document->setData($item);
119			} elseif ($data instanceof ResourceCollectionInterface) {
			0 ignored issues – show introduced 2018-06-01 11:55 UTC by Report Bug Copy Issue Report `$data` is always a sub-type of `Art4\JsonApiClient\ResourceCollectionInterface`. Loading history...
120			$collection = $this->hydrator->hydrateCollection($data);
121			$allHydratedItems = $allHydratedItems->concat($collection);
122			$allJsonApiItems = $allJsonApiItems->concat(new Collection($data->asArray()));
123
124			$document = new CollectionDocument();
125			$document->setData($collection);
126			} else {
127			throw new \DomainException('Data is not Collection or Item');
128			}
129
130			$included = null;
131			if ($includedInDocument) {
132			$included = $this->hydrator->hydrateCollection($includedInDocument);
133			$allHydratedItems = $allHydratedItems->concat($included);
134			$allJsonApiItems = $allJsonApiItems->concat(new Collection($includedInDocument->asArray()));
135			}
136
137			if ($relationshipsInDocument) {
138			$relationships = $this->hydrator->hydrateRelationCollection($relationshipsInDocument);
139			if ($includedInDocument) {
140			$newRelationships = new Collection();
141			foreach ($relationships as $relationship) {
142			$id = $relationship->getId();
143			$type = $relationship->getType();
144			$desiredObject = null;
			0 ignored issues – show Unused Code introduced 2018-07-26 13:12 UTC by Report Bug Copy Issue Report The assignment to `$desiredObject` is dead and can be removed. Loading history...
145
146			//check duplicate
147			$desiredObject = $included->first(function ($item) use ($id, $type) {
148			return ($item->getId() == $id) && ($item->getType() == $type);
149			});
150			if (is_null($desiredObject)) {
151			$newRelationships->push($relationship);
152			}
153			}
154			} else {
155			$newRelationships = $relationships;
			0 ignored issues – show Unused Code introduced 2018-07-26 13:12 UTC by Report Bug Copy Issue Report The assignment to `$newRelationships` is dead and can be removed. Loading history...
156			}
157			}
158
159			//$allHydratedItems Items will be in response
160			$this->hydrator->hydrateRelationships($allJsonApiItems, $allHydratedItems);
161			if ($included) {
162			$document->setIncluded($included);
163			}
164
165			return $document;
166			}
167
168			/**
169			* @param \Art4\JsonApiClient\DocumentInterface $document
170			*
171			* @throws \DomainException
172			*
173			* @return \Art4\JsonApiClient\ResourceItemInterface\|\Art4\JsonApiClient\ResourceCollectionInterface
174			*/
175			private function getJsonApiDocumentData(Art4JsonApiDocumentInterface $document)
176			{
177			$resource = $document->get('data');
178
179			if (!$resource instanceof ResourceItemInterface && !$resource instanceof ResourceCollectionInterface) {
180			throw new \DomainException('Result is not a Json API Resource');
181			}
182
183			return $resource;
184			}
185
186			/**
187			* @param \Art4\JsonApiClient\DocumentInterface $document
188			*
189			* @return \Art4\JsonApiClient\ResourceCollection\|null
190			*/
191			private function getJsonApiDocumentIncluded(Art4JsonApiDocumentInterface $document)
192			{
193			if ($document->has('included')) {
194			return $document->get('included');
195			}
196
197			return null;
198			}
199
200			/**
201			* @param \Art4\JsonApiClient\DocumentInterface $document
202			*
203			* @return \Art4\JsonApiClient\ResourceCollection\|null
204			*/
205			private function getJsonApiDocumentRelationShips(Art4JsonApiDocumentInterface $document)
206			{
207			if ($document->has('data.relationships')) {
208			return $document->get('data.relationships');
209			}
210
211			return null;
212			}
213
214			/**
215			* @param \Art4\JsonApiClient\DocumentInterface $document
216			*
217			* @return array
218			*/
219			private function parseLinks(Art4JsonApiDocumentInterface $document): array
220			{
221			if (!$document->has('links')) {
222			return [];
223			}
224
225			return $document->get('links')->asArray(true);
226			}
227
228			/**
229			* @param \Art4\JsonApiClient\DocumentInterface $document
230			*
231			* @return \Swis\JsonApi\Client\Errors\ErrorCollection
232			*/
233			private function parseErrors(Art4JsonApiDocumentInterface $document): ErrorCollection
234			{
235			if (!$document->has('errors')) {
236			return new ErrorCollection();
237			}
238
239			return $this->errorsParser->parse($document->get('errors'));
240			}
241
242			/**
243			* @param \Art4\JsonApiClient\DocumentInterface $document
244			*
245			* @return array
246			*/
247			private function parseMeta(Art4JsonApiDocumentInterface $document): array
248			{
249			if (!$document->has('meta')) {
250			return [];
251			}
252
253			return $document->get('meta')->asArray(true);
254			}
255
256			/**
257			* @param \Swis\JsonApi\Client\Interfaces\DocumentInterface $document
258			*
259			* @return string
260			*/
261			public function serialize(DocumentInterface $document): string
262			{
263			}
264			}
265

swisnl / json-api-client

Pull Request — master (#23)

Parser::getJsonApiDocumentRelationShips() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like