Encoder - Code Metrics - Inspection of "#82 Work with scrutinizer issues. Refactoring." - neomerx/json-api - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — next (d66390)

by Neomerx

created 2019-01-25 14:45 UTC

Encoder B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	418
Duplicated Lines	4.31 %

Coupling/Cohesion

Components	1
Dependencies	13

Test Coverage

Coverage

100%

Importance

Changes

Metric	Value
dl	18
loc	418
ccs	144
cts	144
cp	1
rs	8.96
c	0
b	0
f	0
wmc	43
lcom	1
cbo	13

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	instance()	0	8	1
A	encodeData()	0	10	1
A	encodeIdentifiers()	0	10	1
A	encodeError()	0	10	1
A	encodeErrors()	0	10	1
A	encodeMeta()	0	10	1
A	createFactory()	0	4	1
B	encodeDataToArray()	9	44	11
B	encodeIdentifiersToArray()	9	59	9
A	encodeErrorToArray()	0	17	1
A	encodeErrorsToArray()	0	21	2
A	encodeMetaToArray()	0	19	1
B	writeHeader()	0	22	6
A	writeFooter()	0	4	1
A	encodeToJson()	0	4	1
A	createDocumentWriter()	0	7	1
A	createErrorWriter()	0	7	1
A	resetPropertiesToDefaults()	0	10	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 Encoder 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 Encoder, and based on these observations, apply Extract Interface, too.

<?php declare(strict_types=1);

namespace Neomerx\JsonApi\Encoder;

/**
 * Copyright 2015-2019 [email protected]
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use Neomerx\JsonApi\Contracts\Encoder\EncoderInterface;
use Neomerx\JsonApi\Contracts\Factories\FactoryInterface;
use Neomerx\JsonApi\Contracts\Parser\DocumentDataInterface;
use Neomerx\JsonApi\Contracts\Parser\IdentifierInterface;
use Neomerx\JsonApi\Contracts\Parser\ParserInterface;
use Neomerx\JsonApi\Contracts\Parser\ResourceInterface;
use Neomerx\JsonApi\Contracts\Representation\BaseWriterInterface;
use Neomerx\JsonApi\Contracts\Representation\DocumentWriterInterface;
use Neomerx\JsonApi\Contracts\Representation\ErrorWriterInterface;
use Neomerx\JsonApi\Contracts\Schema\ErrorInterface;
use Neomerx\JsonApi\Contracts\Schema\SchemaContainerInterface;
use Neomerx\JsonApi\Exceptions\InvalidArgumentException;
use Neomerx\JsonApi\Factories\Factory;

/**
 * @package Neomerx\JsonApi
 */
class Encoder implements EncoderInterface
{
    use EncoderPropertiesTrait;

    /**
     * Default value.
     */
    const DEFAULT_URL_PREFIX = '';

    /**
     * Default value.
     */
    const DEFAULT_INCLUDE_PATHS = [];

    /**
     * Default value.
     */
    const DEFAULT_FIELD_SET_FILTERS = [];

    /**
     * Default encode options.
     *
     * @link http://php.net/manual/en/function.json-encode.php
     */
    const DEFAULT_JSON_ENCODE_OPTIONS = 0;

    /**
     * Default encode depth.
     *
     * @link http://php.net/manual/en/function.json-encode.php
     */
    const DEFAULT_JSON_ENCODE_DEPTH = 512;

    /**
     * @param FactoryInterface         $factory
     * @param SchemaContainerInterface $container
     */
    public function __construct(
        FactoryInterface $factory,
        SchemaContainerInterface $container
    ) {
        $this->setFactory($factory)->setContainer($container)->resetPropertiesToDefaults();
    }

    /**
     * Create encoder instance.
     *
     * @param array $schemas Schema providers.
     *
     * @return EncoderInterface
     */
    public static function instance(array $schemas = []): EncoderInterface
    {
        $factory   = static::createFactory();
        $container = $factory->createSchemaContainer($schemas);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $encoder   = $factory->createEncoder($container);

        return $encoder;
    }

    /**
     * @inheritdoc
     */
    public function encodeData($data): string
    {
        // encode to json
        $array  = $this->encodeDataToArray($data);
        $result = $this->encodeToJson($array);

        $this->resetPropertiesToDefaults();

        return $result;
    }

    /**
     * @inheritdoc
     */
    public function encodeIdentifiers($data): string
    {
        // encode to json
        $array  = $this->encodeIdentifiersToArray($data);
        $result = $this->encodeToJson($array);

        $this->resetPropertiesToDefaults();

        return $result;
    }

    /**
     * @inheritdoc
     */
    public function encodeError(ErrorInterface $error): string
    {
        // encode to json
        $array  = $this->encodeErrorToArray($error);
        $result = $this->encodeToJson($array);

        $this->resetPropertiesToDefaults();

        return $result;
    }

    /**
     * @inheritdoc
     */
    public function encodeErrors(iterable $errors): string
    {
        // encode to json
        $array  = $this->encodeErrorsToArray($errors);
        $result = $this->encodeToJson($array);

        $this->resetPropertiesToDefaults();

        return $result;
    }

    /**
     * @inheritdoc
     */
    public function encodeMeta($meta): string
    {
        // encode to json
        $array  = $this->encodeMetaToArray($meta);
        $result = $this->encodeToJson($array);

        $this->resetPropertiesToDefaults();

        return $result;
    }

    /**
     * @return FactoryInterface
     */
    protected static function createFactory(): FactoryInterface
    {
        return new Factory();
    }

    /**
     * @param object|iterable|null $data Data to encode.
     *
     * @return array
     *
     * @SuppressWarnings(PHPMD.ElseExpression)
     */
    protected function encodeDataToArray($data): array
    {
        if (is_array($data) === false && is_object($data) === false && $data !== null) {
            throw new InvalidArgumentException();
        }

        $parser = $this->getFactory()->createParser($this->getSchemaContainer());
        $writer = $this->createDocumentWriter();
        $filter = $this->getFactory()->createFieldSetFilter($this->getFieldSets());

        // write header
        $this->writeHeader($writer);

        // write body
        foreach ($parser->parse($data, $this->getIncludePaths()) as $item) {
            if ($item instanceof ResourceInterface) {
                if ($item->getPosition()->getLevel() > ParserInterface::ROOT_LEVEL) {
                    if ($filter->shouldOutputRelationship($item->getPosition()) === true) {
                        $writer->addResourceToIncluded($item, $filter);
                    }
                } else {
                    $writer->addResourceToData($item, $filter);
                }
            } elseif ($item instanceof IdentifierInterface) {
                assert($item->getPosition()->getLevel() <= ParserInterface::ROOT_LEVEL);
                $writer->addIdentifierToData($item);
            } else {
                assert($item instanceof DocumentDataInterface);
                assert($item->getPosition()->getLevel() === 0);
                if ($item->isCollection() === true) {
                    $writer->setDataAsArray();
                } elseif ($item->isNull() === true) {
                    $writer->setNullToData();
                }
            }
        }

        // write footer
        $this->writeFooter($writer);

        $array = $writer->getDocument();

        return $array;
    }

    /**
     * @param object|iterable|null $data Data to encode.
     *
     * @return array
     *
     * @SuppressWarnings(PHPMD.ElseExpression)
     */
    protected function encodeIdentifiersToArray($data): array
    {
        $parser = $this->getFactory()->createParser($this->getSchemaContainer());
        $writer = $this->createDocumentWriter();
        $filter = $this->getFactory()->createFieldSetFilter($this->getFieldSets());

        // write header
        $this->writeHeader($writer);

        // write body
        $includePaths   = $this->getIncludePaths();
        $expectIncluded = empty($includePaths) === false;

        // https://github.com/neomerx/json-api/issues/218
        //
        // if we expect included resources we have to include top level resources in `included` as well
        // Spec:
        //
        // GET /articles/1/relationships/comments?include=comments.author HTTP/1.1
        // Accept: application/vnd.api+json
        //
        // In this case, the primary data would be a collection of resource identifier objects that
        // represent linkage to comments for an article, while the full comments and comment authors
        // would be returned as included data.

        foreach ($parser->parse($data, $includePaths) as $item) {
            if ($item instanceof ResourceInterface) {
                if ($item->getPosition()->getLevel() > ParserInterface::ROOT_LEVEL) {
                    assert($expectIncluded === true);
                    if ($filter->shouldOutputRelationship($item->getPosition()) === true) {
                        $writer->addResourceToIncluded($item, $filter);
                    }
                } else {
                    $writer->addIdentifierToData($item);
                    if ($expectIncluded === true) {
                        $writer->addResourceToIncluded($item, $filter);
                    }
                }
            } elseif ($item instanceof IdentifierInterface) {
                assert($item->getPosition()->getLevel() <= ParserInterface::ROOT_LEVEL);
                $writer->addIdentifierToData($item);
            } else {
                assert($item instanceof DocumentDataInterface);
                assert($item->getPosition()->getLevel() === 0);
                if ($item->isCollection() === true) {
                    $writer->setDataAsArray();
                } elseif ($item->isNull() === true) {
                    $writer->setNullToData();
                }
            }
        }

        // write footer
        $this->writeFooter($writer);

        $array = $writer->getDocument();

        return $array;
    }

    /**
     * @param ErrorInterface $error
     *
     * @return array
     */
    protected function encodeErrorToArray(ErrorInterface $error): array
    {
        $writer = $this->createErrorWriter();

        // write header
        $this->writeHeader($writer);

        // write body
        $writer->addError($error);

        // write footer
        $this->writeFooter($writer);

        $array = $writer->getDocument();

        return $array;
    }

    /**
     * @param iterable $errors
     *
     * @return array
     */
    protected function encodeErrorsToArray(iterable $errors): array
    {
        $writer = $this->createErrorWriter();

        // write header
        $this->writeHeader($writer);

        // write body
        foreach ($errors as $error) {
            assert($error instanceof ErrorInterface);
            $writer->addError($error);
        }

        // write footer
        $this->writeFooter($writer);

        // encode to json
        $array = $writer->getDocument();

        return $array;
    }

    /**
     * @param $meta
     *
     * @return array
     */
    protected function encodeMetaToArray($meta): array
    {
        $this->withMeta($meta);

        $writer = $this->getFactory()->createDocumentWriter();

        $writer->setUrlPrefix($this->getUrlPrefix());

        // write header
        $this->writeHeader($writer);

        // write footer
        $this->writeFooter($writer);

        // encode to json
        $array = $writer->getDocument();

        return $array;
    }

    /**
     * @param BaseWriterInterface $writer
     *
     * @return void
     */
    protected function writeHeader(BaseWriterInterface $writer): void
    {
        if ($this->hasMeta() === true) {
            $writer->setMeta($this->getMeta());
        }

        if ($this->hasJsonApiVersion() === true) {
            $writer->setJsonApiVersion($this->getJsonApiVersion());
        }

        if ($this->hasJsonApiMeta() === true) {
            $writer->setJsonApiMeta($this->getJsonApiMeta());
        }

        if ($this->hasLinks() === true) {
            $writer->setLinks($this->getLinks());
        }

        if ($this->hasProfile() === true) {
            $writer->setProfile($this->getProfile());
        }
    }

    /**
     * @param BaseWriterInterface $writer
     *
     * @return void
     */
    protected function writeFooter(BaseWriterInterface $writer): void
    {
        assert($writer !== null);
    }

    /**
     * Encode array to JSON.
     *
     * @param array $document
     *
     * @return string
     */
    protected function encodeToJson(array $document): string
    {
        return json_encode($document, $this->getEncodeOptions(), $this->getEncodeDepth());
    }

    /**
     * @return DocumentWriterInterface
     */
    private function createDocumentWriter(): DocumentWriterInterface
    {
        $writer = $this->getFactory()->createDocumentWriter();
        $writer->setUrlPrefix($this->getUrlPrefix());

        return $writer;
    }

    /**
     * @return ErrorWriterInterface
     */
    private function createErrorWriter(): ErrorWriterInterface
    {
        $writer = $this->getFactory()->createErrorWriter();
        $writer->setUrlPrefix($this->getUrlPrefix());

        return $writer;
    }

    /**
     * @return self
     */
    private function resetPropertiesToDefaults(): self
    {
        return $this->reset(
            static::DEFAULT_URL_PREFIX,
            static::DEFAULT_INCLUDE_PATHS,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            static::DEFAULT_FIELD_SET_FILTERS,
            static::DEFAULT_JSON_ENCODE_OPTIONS,
            static::DEFAULT_JSON_ENCODE_DEPTH
        );
    }
}


1			<?php declare(strict_types=1);
2
3			namespace Neomerx\JsonApi\Encoder;
4
5			/**
6			* Copyright 2015-2019 [email protected]
7			*
8			* Licensed under the Apache License, Version 2.0 (the "License");
9			* you may not use this file except in compliance with the License.
10			* You may obtain a copy of the License at
11			*
12			* http://www.apache.org/licenses/LICENSE-2.0
13			*
14			* Unless required by applicable law or agreed to in writing, software
15			* distributed under the License is distributed on an "AS IS" BASIS,
16			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17			* See the License for the specific language governing permissions and
18			* limitations under the License.
19			*/
20
21			use Neomerx\JsonApi\Contracts\Encoder\EncoderInterface;
22			use Neomerx\JsonApi\Contracts\Factories\FactoryInterface;
23			use Neomerx\JsonApi\Contracts\Parser\DocumentDataInterface;
24			use Neomerx\JsonApi\Contracts\Parser\IdentifierInterface;
25			use Neomerx\JsonApi\Contracts\Parser\ParserInterface;
26			use Neomerx\JsonApi\Contracts\Parser\ResourceInterface;
27			use Neomerx\JsonApi\Contracts\Representation\BaseWriterInterface;
28			use Neomerx\JsonApi\Contracts\Representation\DocumentWriterInterface;
29			use Neomerx\JsonApi\Contracts\Representation\ErrorWriterInterface;
30			use Neomerx\JsonApi\Contracts\Schema\ErrorInterface;
31			use Neomerx\JsonApi\Contracts\Schema\SchemaContainerInterface;
32			use Neomerx\JsonApi\Exceptions\InvalidArgumentException;
33			use Neomerx\JsonApi\Factories\Factory;
34
35			/**
36			* @package Neomerx\JsonApi
37			*/
38			class Encoder implements EncoderInterface
39			{
40			use EncoderPropertiesTrait;
41
42			/**
43			* Default value.
44			*/
45			const DEFAULT_URL_PREFIX = '';
46
47			/**
48			* Default value.
49			*/
50			const DEFAULT_INCLUDE_PATHS = [];
51
52			/**
53			* Default value.
54			*/
55			const DEFAULT_FIELD_SET_FILTERS = [];
56
57			/**
58			* Default encode options.
59			*
60			* @link http://php.net/manual/en/function.json-encode.php
61			*/
62			const DEFAULT_JSON_ENCODE_OPTIONS = 0;
63
64			/**
65			* Default encode depth.
66			*
67			* @link http://php.net/manual/en/function.json-encode.php
68			*/
69			const DEFAULT_JSON_ENCODE_DEPTH = 512;
70
71			/**
72			* @param FactoryInterface $factory
73			* @param SchemaContainerInterface $container
74			*/
75	81		public function __construct(
76			FactoryInterface $factory,
77			SchemaContainerInterface $container
78			) {
79	81		$this->setFactory($factory)->setContainer($container)->resetPropertiesToDefaults();
80	81		}
81
82			/**
83			* Create encoder instance.
84			*
85			* @param array $schemas Schema providers.
86			*
87			* @return EncoderInterface
88			*/
89	81		public static function instance(array $schemas = []): EncoderInterface
90			{
91	81		$factory = static::createFactory();
92	81		$container = $factory->createSchemaContainer($schemas);
			0 ignored issues – show Documentation introduced 2019-01-19 21:06 UTC by Report Bug Copy Issue Report `$schemas` is of type `array`, but the function expects a `object<Neomerx\JsonApi\C...cts\Factories\iterable>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
93	81		$encoder = $factory->createEncoder($container);
94
95	81		return $encoder;
96			}
97
98			/**
99			* @inheritdoc
100			*/
101	64		public function encodeData($data): string
102			{
103			// encode to json
104	64		$array = $this->encodeDataToArray($data);
105	61		$result = $this->encodeToJson($array);
106
107	61		$this->resetPropertiesToDefaults();
108
109	61		return $result;
110			}
111
112			/**
113			* @inheritdoc
114			*/
115	5		public function encodeIdentifiers($data): string
116			{
117			// encode to json
118	5		$array = $this->encodeIdentifiersToArray($data);
119	5		$result = $this->encodeToJson($array);
120
121	5		$this->resetPropertiesToDefaults();
122
123	5		return $result;
124			}
125
126			/**
127			* @inheritdoc
128			*/
129	3		public function encodeError(ErrorInterface $error): string
130			{
131			// encode to json
132	3		$array = $this->encodeErrorToArray($error);
133	3		$result = $this->encodeToJson($array);
134
135	3		$this->resetPropertiesToDefaults();
136
137	3		return $result;
138			}
139
140			/**
141			* @inheritdoc
142			*/
143	3		public function encodeErrors(iterable $errors): string
144			{
145			// encode to json
146	3		$array = $this->encodeErrorsToArray($errors);
147	3		$result = $this->encodeToJson($array);
148
149	3		$this->resetPropertiesToDefaults();
150
151	3		return $result;
152			}
153
154			/**
155			* @inheritdoc
156			*/
157	1		public function encodeMeta($meta): string
158			{
159			// encode to json
160	1		$array = $this->encodeMetaToArray($meta);
161	1		$result = $this->encodeToJson($array);
162
163	1		$this->resetPropertiesToDefaults();
164
165	1		return $result;
166			}
167
168			/**
169			* @return FactoryInterface
170			*/
171	74		protected static function createFactory(): FactoryInterface
172			{
173	74		return new Factory();
174			}
175
176			/**
177			* @param object\|iterable\|null $data Data to encode.
178			*
179			* @return array
180			*
181			* @SuppressWarnings(PHPMD.ElseExpression)
182			*/
183	65		protected function encodeDataToArray($data): array
184			{
185	65		if (is_array($data) === false && is_object($data) === false && $data !== null) {
186	1		throw new InvalidArgumentException();
187			}
188
189	64		$parser = $this->getFactory()->createParser($this->getSchemaContainer());
190	64		$writer = $this->createDocumentWriter();
191	64		$filter = $this->getFactory()->createFieldSetFilter($this->getFieldSets());
192
193			// write header
194	64		$this->writeHeader($writer);
195
196			// write body
197	64		foreach ($parser->parse($data, $this->getIncludePaths()) as $item) {
198	63		if ($item instanceof ResourceInterface) {
199	55		if ($item->getPosition()->getLevel() > ParserInterface::ROOT_LEVEL) {
200	20		if ($filter->shouldOutputRelationship($item->getPosition()) === true) {
201	20		$writer->addResourceToIncluded($item, $filter);
202			}
203			} else {
204	55		$writer->addResourceToData($item, $filter);
205			}
206	63		} elseif ($item instanceof IdentifierInterface) {
207	1		assert($item->getPosition()->getLevel() <= ParserInterface::ROOT_LEVEL);
208	1		$writer->addIdentifierToData($item);
209		View Code Duplication	} else {
210	63		assert($item instanceof DocumentDataInterface);
211	63		assert($item->getPosition()->getLevel() === 0);
212	63		if ($item->isCollection() === true) {
213	21		$writer->setDataAsArray();
214	44		} elseif ($item->isNull() === true) {
215	63		$writer->setNullToData();
216			}
217			}
218			}
219
220			// write footer
221	62		$this->writeFooter($writer);
222
223	62		$array = $writer->getDocument();
224
225	62		return $array;
226			}
227
228			/**
229			* @param object\|iterable\|null $data Data to encode.
230			*
231			* @return array
232			*
233			* @SuppressWarnings(PHPMD.ElseExpression)
234			*/
235	6		protected function encodeIdentifiersToArray($data): array
236			{
237	6		$parser = $this->getFactory()->createParser($this->getSchemaContainer());
238	6		$writer = $this->createDocumentWriter();
239	6		$filter = $this->getFactory()->createFieldSetFilter($this->getFieldSets());
240
241			// write header
242	6		$this->writeHeader($writer);
243
244			// write body
245	6		$includePaths = $this->getIncludePaths();
246	6		$expectIncluded = empty($includePaths) === false;
247
248			// https://github.com/neomerx/json-api/issues/218
249			//
250			// if we expect included resources we have to include top level resources in `included` as well
251			// Spec:
252			//
253			// GET /articles/1/relationships/comments?include=comments.author HTTP/1.1
254			// Accept: application/vnd.api+json
255			//
256			// In this case, the primary data would be a collection of resource identifier objects that
257			// represent linkage to comments for an article, while the full comments and comment authors
258			// would be returned as included data.
259
260	6		foreach ($parser->parse($data, $includePaths) as $item) {
261	6		if ($item instanceof ResourceInterface) {
262	4		if ($item->getPosition()->getLevel() > ParserInterface::ROOT_LEVEL) {
263	1		assert($expectIncluded === true);
264	1		if ($filter->shouldOutputRelationship($item->getPosition()) === true) {
265	1		$writer->addResourceToIncluded($item, $filter);
266			}
267			} else {
268	4		$writer->addIdentifierToData($item);
269	4		if ($expectIncluded === true) {
270	4		$writer->addResourceToIncluded($item, $filter);
271			}
272			}
273	6		} elseif ($item instanceof IdentifierInterface) {
274	1		assert($item->getPosition()->getLevel() <= ParserInterface::ROOT_LEVEL);
275	1		$writer->addIdentifierToData($item);
276		View Code Duplication	} else {
277	6		assert($item instanceof DocumentDataInterface);
278	6		assert($item->getPosition()->getLevel() === 0);
279	6		if ($item->isCollection() === true) {
280	2		$writer->setDataAsArray();
281	5		} elseif ($item->isNull() === true) {
282	6		$writer->setNullToData();
283			}
284			}
285			}
286
287			// write footer
288	6		$this->writeFooter($writer);
289
290	6		$array = $writer->getDocument();
291
292	6		return $array;
293			}
294
295			/**
296			* @param ErrorInterface $error
297			*
298			* @return array
299			*/
300	4		protected function encodeErrorToArray(ErrorInterface $error): array
301			{
302	4		$writer = $this->createErrorWriter();
303
304			// write header
305	4		$this->writeHeader($writer);
306
307			// write body
308	4		$writer->addError($error);
309
310			// write footer
311	4		$this->writeFooter($writer);
312
313	4		$array = $writer->getDocument();
314
315	4		return $array;
316			}
317
318			/**
319			* @param iterable $errors
320			*
321			* @return array
322			*/
323	4		protected function encodeErrorsToArray(iterable $errors): array
324			{
325	4		$writer = $this->createErrorWriter();
326
327			// write header
328	4		$this->writeHeader($writer);
329
330			// write body
331	4		foreach ($errors as $error) {
332	3		assert($error instanceof ErrorInterface);
333	3		$writer->addError($error);
334			}
335
336			// write footer
337	4		$this->writeFooter($writer);
338
339			// encode to json
340	4		$array = $writer->getDocument();
341
342	4		return $array;
343			}
344
345			/**
346			* @param $meta
347			*
348			* @return array
349			*/
350	2		protected function encodeMetaToArray($meta): array
351			{
352	2		$this->withMeta($meta);
353
354	2		$writer = $this->getFactory()->createDocumentWriter();
355
356	2		$writer->setUrlPrefix($this->getUrlPrefix());
357
358			// write header
359	2		$this->writeHeader($writer);
360
361			// write footer
362	2		$this->writeFooter($writer);
363
364			// encode to json
365	2		$array = $writer->getDocument();
366
367	2		return $array;
368			}
369
370			/**
371			* @param BaseWriterInterface $writer
372			*
373			* @return void
374			*/
375	79		protected function writeHeader(BaseWriterInterface $writer): void
376			{
377	79		if ($this->hasMeta() === true) {
378	6		$writer->setMeta($this->getMeta());
379			}
380
381	79		if ($this->hasJsonApiVersion() === true) {
382	2		$writer->setJsonApiVersion($this->getJsonApiVersion());
383			}
384
385	79		if ($this->hasJsonApiMeta() === true) {
386	2		$writer->setJsonApiMeta($this->getJsonApiMeta());
387			}
388
389	79		if ($this->hasLinks() === true) {
390	5		$writer->setLinks($this->getLinks());
391			}
392
393	79		if ($this->hasProfile() === true) {
394	1		$writer->setProfile($this->getProfile());
395			}
396	79		}
397
398			/**
399			* @param BaseWriterInterface $writer
400			*
401			* @return void
402			*/
403	77		protected function writeFooter(BaseWriterInterface $writer): void
404			{
405	77		assert($writer !== null);
406	77		}
407
408			/**
409			* Encode array to JSON.
410			*
411			* @param array $document
412			*
413			* @return string
414			*/
415	73		protected function encodeToJson(array $document): string
416			{
417	73		return json_encode($document, $this->getEncodeOptions(), $this->getEncodeDepth());
418			}
419
420			/**
421			* @return DocumentWriterInterface
422			*/
423	70		private function createDocumentWriter(): DocumentWriterInterface
424			{
425	70		$writer = $this->getFactory()->createDocumentWriter();
426	70		$writer->setUrlPrefix($this->getUrlPrefix());
427
428	70		return $writer;
429			}
430
431			/**
432			* @return ErrorWriterInterface
433			*/
434	7		private function createErrorWriter(): ErrorWriterInterface
435			{
436	7		$writer = $this->getFactory()->createErrorWriter();
437	7		$writer->setUrlPrefix($this->getUrlPrefix());
438
439	7		return $writer;
440			}
441
442			/**
443			* @return self
444			*/
445	81		private function resetPropertiesToDefaults(): self
446			{
447	81		return $this->reset(
448	81		static::DEFAULT_URL_PREFIX,
449	81		static::DEFAULT_INCLUDE_PATHS,
			0 ignored issues – show Documentation introduced 2019-01-25 14:47 UTC by Report Bug Copy Issue Report `static::DEFAULT_INCLUDE_PATHS` is of type `array`, but the function expects a `object<Neomerx\JsonApi\Encoder\iterable>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
450	81		static::DEFAULT_FIELD_SET_FILTERS,
451	81		static::DEFAULT_JSON_ENCODE_OPTIONS,
452	81		static::DEFAULT_JSON_ENCODE_DEPTH
453			);
454			}
455			}
456

neomerx / json-api