Parser::getJsonApiDocumentRelationShips() - Code Metrics - Inspection of "Parser Relation without include object" - swisnl/json-api-client - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#22)

unknown

created 2018-07-26 13:01 UTC

Parser::getJsonApiDocumentRelationShips() A

↳ Parent: Parser

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
eloc	3
dl	0
loc	6
ccs	0
cts	3
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;
use Swis\JsonApi\Client\Items\JenssegersItem;

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			use Swis\JsonApi\Client\Items\JenssegersItem;
17
18			class Parser implements ParserInterface
19			{
20			/**
21			* @var \Art4\JsonApiClient\Utils\Manager
22			*/
23			protected $manager;
24
25			/**
26			* @var \Swis\JsonApi\Client\JsonApi\Hydrator
27			*/
28			private $hydrator;
29
30			/**
31			* @var \Swis\JsonApi\Client\JsonApi\ErrorsParser
32			*/
33			private $errorsParser;
34
35			/**
36			* @param \Art4\JsonApiClient\Utils\Manager $manager
37			* @param \Swis\JsonApi\Client\JsonApi\Hydrator $hydrator
38			* @param \Swis\JsonApi\Client\JsonApi\ErrorsParser $errorsParser
39			*/
40			public function __construct(Art4JsonApiClientManager $manager, Hydrator $hydrator, ErrorsParser $errorsParser)
41			{
42			$this->manager = $manager;
43			$this->hydrator = $hydrator;
44			$this->errorsParser = $errorsParser;
45			}
46
47			/**
48			* @return \Swis\JsonApi\Client\JsonApi\Hydrator
49			*/
50			public function getHydrator(): Hydrator
51			{
52			return $this->hydrator;
53			}
54
55			/**
56			* @param string $json
57			*
58			* @throws \DomainException
59			*
60			* @return \Swis\JsonApi\Client\Interfaces\DocumentInterface
61			*/
62			public function deserialize(string $json): DocumentInterface
63			{
64			$jsonApiDocument = $this->getJsonApiDocument($json);
65
66			if ($jsonApiDocument->has('data')) {
67			$document = $this->buildDataDocument($jsonApiDocument);
68			} else {
69			$document = new Document();
70			}
71
72			$document->setLinks($this->parseLinks($jsonApiDocument));
73			$document->setErrors($this->parseErrors($jsonApiDocument));
74			$document->setMeta($this->parseMeta($jsonApiDocument));
75
76			return $document;
77			}
78
79			/**
80			* @param string $json
81			*
82			* @throws \DomainException
83			*
84			* @return \Art4\JsonApiClient\DocumentInterface
85			*/
86			private function getJsonApiDocument(string $json): Art4JsonApiDocumentInterface
87			{
88			$jsonApiDocument = $this->manager->parse($json);
89
90			if (!$jsonApiDocument instanceof Art4JsonApiDocumentInterface) {
91			throw new \DomainException('Result is not a JSON API Document');
92			}
93
94			return $jsonApiDocument;
95			}
96
97			/**
98			* @param \Art4\JsonApiClient\DocumentInterface $jsonApiDocument
99			*
100			* @throws \DomainException
101			*includedInDocument
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
143			$id = $relationship->getId();
144			$type = $relationship->getType();
145			$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...
146
147			//check duplicate
148			$desiredObject = $included->first(function ($item) use ($id, $type) {
149			return ($item->getId() == $id) && ($item->getType() == $type);
150			});
151			if (is_null($desiredObject)) {
152			$newRelationships->push($relationship);
153			}
154			}
155			} else {
156			$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...
157			}
158			}
159
160
161			//$allHydratedItems Items will be in response
162			$this->hydrator->hydrateRelationships($allJsonApiItems, $allHydratedItems);
163			if ($included) {
164			$document->setIncluded($included);
165			}
166
167			return $document;
168			}
169
170
171			/**
172			* @param \Art4\JsonApiClient\DocumentInterface $document
173			*
174			* @throws \DomainException
175			*
176			* @return \Art4\JsonApiClient\ResourceItemInterface\|\Art4\JsonApiClient\ResourceCollectionInterface
177			*/
178			private function getJsonApiDocumentData(Art4JsonApiDocumentInterface $document)
179			{
180			$resource = $document->get('data');
181
182			if (!$resource instanceof ResourceItemInterface && !$resource instanceof ResourceCollectionInterface) {
183			throw new \DomainException('Result is not a Json API Resource');
184			}
185
186			return $resource;
187			}
188
189			/**
190			* @param \Art4\JsonApiClient\DocumentInterface $document
191			*
192			* @return \Art4\JsonApiClient\ResourceCollection\|null
193			*/
194			private function getJsonApiDocumentIncluded(Art4JsonApiDocumentInterface $document)
195			{
196			if ($document->has('included')) {
197			return $document->get('included');
198			}
199
200			return null;
201			}
202
203			/**
204			* @param \Art4\JsonApiClient\DocumentInterface $document
205			*
206			* @return \Art4\JsonApiClient\ResourceCollection\|null
207			*/
208			private function getJsonApiDocumentRelationShips(Art4JsonApiDocumentInterface $document)
209			{
210			if ($document->has('data.relationships')) {
211			return $document->get('data.relationships');
212			}
213			return null;
214			}
215
216
217			/**
218			* @param \Art4\JsonApiClient\DocumentInterface $document
219			*
220			* @return array
221			*/
222			private function parseLinks(Art4JsonApiDocumentInterface $document): array
223			{
224			if (!$document->has('links')) {
225			return [];
226			}
227			return $document->get('links')->asArray(true);
228			}
229
230			/**
231			* @param \Art4\JsonApiClient\DocumentInterface $document
232			*
233			* @return \Swis\JsonApi\Client\Errors\ErrorCollection
234			*/
235			private function parseErrors(Art4JsonApiDocumentInterface $document): ErrorCollection
236			{
237			if (!$document->has('errors')) {
238			return new ErrorCollection();
239			}
240
241			return $this->errorsParser->parse($document->get('errors'));
242			}
243
244			/**
245			* @param \Art4\JsonApiClient\DocumentInterface $document
246			*
247			* @return array
248			*/
249			private function parseMeta(Art4JsonApiDocumentInterface $document): array
250			{
251			if (!$document->has('meta')) {
252			return [];
253			}
254
255			return $document->get('meta')->asArray(true);
256			}
257
258			/**
259			* @param \Swis\JsonApi\Client\Interfaces\DocumentInterface $document
260			*
261			* @return string
262			*/
263			public function serialize(DocumentInterface $document): string
264			{
265			}
266			}
267

swisnl / json-api-client

Pull Request — master (#22)

Parser::getJsonApiDocumentRelationShips() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like