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

Completed

Branch — next (29fadd)

by Neomerx

created 2019-01-20 16:56 UTC

Encoder F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	791
Duplicated Lines	4.55 %

Coupling/Cohesion

Components	1
Dependencies	14

Test Coverage

Coverage

96.65%

Importance

Changes

Metric	Value
dl	36
loc	791
ccs	231
cts	239
cp	0.9665
rs	2.049
c	0
b	0
f	0
wmc	77
lcom	1
cbo	14

49 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	instance()	0	8	1
A	withUrlPrefix()	0	6	1
A	withIncludedPaths()	0	20	4
A	withFieldSets()	0	6	1
A	withEncodeOptions()	0	6	1
A	withEncodeDepth()	0	8	1
A	withLinks()	0	6	2
A	withProfile()	0	6	1
A	withMeta()	0	7	1
A	withJsonApiVersion()	0	6	1
A	withJsonApiMeta()	0	7	1
A	withRelationshipSelfLink()	10	12	1
A	withRelationshipRelatedLink()	10	12	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
A	getSchemaContainer()	0	4	1
A	getFactory()	0	4	1
A	reset()	0	17	1
A	hasLinks()	0	4	1
A	hasProfile()	0	4	1
A	getLinks()	0	4	1
A	getProfile()	0	4	1
A	hasMeta()	0	4	1
A	getMeta()	0	4	1
A	hasJsonApiVersion()	0	4	1
A	getJsonApiVersion()	0	4	1
A	hasJsonApiMeta()	0	4	1
A	getJsonApiMeta()	0	4	1
B	encodeDataToArray()	8	43	11
B	encodeIdentifiersToArray()	8	58	9
A	encodeErrorToArray()	0	17	1
A	encodeErrorsToArray()	0	21	2
A	encodeMetaToArray()	0	19	1
B	writeHeader()	0	22	6
A	writeFooter()	0	3	1
A	encodeToJson()	0	4	1
A	getUrlPrefix()	0	4	1
A	getIncludePaths()	0	4	1
A	getFieldSets()	0	4	1
A	getEncodeOptions()	0	4	1
A	getEncodeDepth()	0	4	1
A	createDocumentWriter()	0	7	1
A	createErrorWriter()	0	7	1
A	mergeIterables()	0	5	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\LinkInterface;
use Neomerx\JsonApi\Contracts\Schema\SchemaContainerInterface;
use Neomerx\JsonApi\Exceptions\InvalidArgumentException;
use Neomerx\JsonApi\Factories\Factory;

/**
 * @package Neomerx\JsonApi
 */
class Encoder implements EncoderInterface
{
    /**
     * 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;

    /**
     * @var SchemaContainerInterface
     */
    private $container;

    /**
     * @var FactoryInterface
     */
    private $factory;

    /**
     * @var string
     */
    private $urlPrefix;

    /**
     * @var array
     */
    private $includePaths;

    /**
     * @var array
     */
    private $fieldSets;

    /**
     * @var int
     */
    private $encodeOptions;

    /**
     * @var int
     */
    private $encodeDepth;

    /**
     * @var iterable
     */
    private $links;

    /**
     * @var iterable
     */
    private $profile;

    /**
     * @var bool
     */
    private $hasMeta;

    /**
     * @var mixed
     */
    private $meta;

    /**
     * @var string|null
     */
    private $jsonApiVersion;

    /**
     * @var mixed
     */
    private $jsonApiMeta;

    /**
     * @var bool
     */
    private $hasJsonApiMeta;

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

        $this->reset();
    }

    /**
     * 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 withUrlPrefix(string $prefix): EncoderInterface
    {
        $this->urlPrefix = $prefix;

        return $this;
    }

    /**
     * @inheritdoc
     */
    public function withIncludedPaths(iterable $paths): EncoderInterface
    {
        assert(
            call_user_func(
                function (array $paths): bool {
                    $pathsOk = true;
                    foreach ($paths as $path) {
                        $pathsOk = $pathsOk === true && is_string($path) === true && empty($path) === false;
                    }

                    return $pathsOk;
                },
                $paths
            )
        );

        $this->includePaths = $paths;

        return $this;
    }

    /**
     * @inheritdoc
     */
    public function withFieldSets(array $fieldSets): EncoderInterface
    {
        $this->fieldSets = $fieldSets;

        return $this;
    }

    /**
     * @inheritdoc
     */
    public function withEncodeOptions(int $options): EncoderInterface
    {
        $this->encodeOptions = $options;

        return $this;
    }

    /**
     * @inheritdoc
     */
    public function withEncodeDepth(int $depth): EncoderInterface
    {
        assert($depth > 0);

        $this->encodeDepth = $depth;

        return $this;
    }

    /**
     * @inheritdoc
     */
    public function withLinks(iterable $links): EncoderInterface
    {
        $this->links = $this->hasLinks() === true ? $this->mergeIterables($this->links, $links) : $links;
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        return $this;
    }

    /**
     * @inheritdoc
     */
    public function withProfile(iterable $links): EncoderInterface
    {
        $this->profile = $links;

        return $this;
    }

    /**
     * @inheritdoc
     */
    public function withMeta($meta): EncoderInterface
    {
        $this->meta    = $meta;
        $this->hasMeta = true;

        return $this;
    }

    /**
     * @inheritdoc
     */
    public function withJsonApiVersion(string $version = self::JSON_API_VERSION): EncoderInterface
    {
        $this->jsonApiVersion = $version;

        return $this;
    }

    /**
     * @inheritdoc
     */
    public function withJsonApiMeta($meta): EncoderInterface
    {
        $this->jsonApiMeta    = $meta;
        $this->hasJsonApiMeta = true;

        return $this;
    }

    /**
     * @inheritdoc
     */
    public function withRelationshipSelfLink($resource, string $relationshipName): EncoderInterface
    {
        $link = $this
            ->getSchemaContainer()->getSchema($resource)
            ->getRelationshipSelfLink($resource, $relationshipName);

        return $this->withLinks(
            [
                LinkInterface::SELF => $link,
            ]
        );
    }

    /**
     * @inheritdoc
     */
    public function withRelationshipRelatedLink($resource, string $relationshipName): EncoderInterface
    {
        $link = $this
            ->getSchemaContainer()->getSchema($resource)
            ->getRelationshipRelatedLink($resource, $relationshipName);

        return $this->withLinks(
            [
                LinkInterface::RELATED => $link,
            ]
        );
    }

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

        $this->reset();

        return $result;
    }

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

        $this->reset();

        return $result;
    }

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

        $this->reset();

        return $result;
    }

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

        $this->reset();

        return $result;
    }

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

        $this->reset();

        return $result;
    }

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

    /**
     * @return SchemaContainerInterface
     */
    protected function getSchemaContainer(): SchemaContainerInterface
    {
        return $this->container;
    }

    /**
     * @return FactoryInterface
     */
    protected function getFactory(): FactoryInterface
    {
        return $this->factory;
    }

    /**
     * Reset to initial state.
     */
    protected function reset(): void
    {
        $this->links          = null;
        $this->profile        = null;
        $this->hasMeta        = false;
        $this->meta           = null;
        $this->jsonApiVersion = null;
        $this->jsonApiMeta    = null;
        $this->hasJsonApiMeta = false;

        $this
            ->withUrlPrefix(static::DEFAULT_URL_PREFIX)
            ->withIncludedPaths(static::DEFAULT_INCLUDE_PATHS)
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            ->withFieldSets(static::DEFAULT_FIELD_SET_FILTERS)
            ->withEncodeOptions(static::DEFAULT_JSON_ENCODE_OPTIONS)
            ->withEncodeDepth(static::DEFAULT_JSON_ENCODE_DEPTH);
    }

    /**
     * @return bool
     */
    protected function hasLinks(): bool
    {
        return $this->links !== null;
    }

    /**
     * @return bool
     */
    protected function hasProfile(): bool
    {
        return $this->profile !== null;
    }

    /**
     * @return iterable
     */
    protected function getLinks(): iterable
    {
        return $this->links;
    }

    /**
     * @return iterable
     */
    protected function getProfile(): iterable
    {
        return $this->profile;
    }

    /**
     * @return bool
     */
    protected function hasMeta(): bool
    {
        return $this->hasMeta;
    }

    /**
     * @return mixed
     */
    public function getMeta()
    {
        return $this->meta;
    }

    /**
     * @return bool
     */
    protected function hasJsonApiVersion(): bool
    {
        return $this->jsonApiVersion !== null;
    }

    /**
     * @return string
     */
    protected function getJsonApiVersion(): string
    {
        return $this->jsonApiVersion;
    }

    /**
     * @return bool
     */
    protected function hasJsonApiMeta(): bool
    {
        return $this->hasJsonApiMeta;
    }

    /**
     * @return mixed
     */
    protected function getJsonApiMeta()
    {
        return $this->jsonApiMeta;
    }

    /**
     * @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);
                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);
                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

    {
    }

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

    /**
     * @return string
     */
    protected function getUrlPrefix(): string
    {
        return $this->urlPrefix;
    }

    /**
     * @return array
     */
    protected function getIncludePaths(): array
    {
        return $this->includePaths;
    }

    /**
     * @return array
     */
    protected function getFieldSets(): array
    {
        return $this->fieldSets;
    }

    /**
     * @return int
     */
    protected function getEncodeOptions(): int
    {
        return $this->encodeOptions;
    }

    /**
     * @return int
     */
    protected function getEncodeDepth(): int
    {
        return $this->encodeDepth;
    }

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

    /**
     * @param iterable $iterable1
     * @param iterable $iterable2
     *
     * @return iterable
     */
    private function mergeIterables(iterable $iterable1, iterable $iterable2): iterable
    {
        yield from $iterable1;
        yield from $iterable2;
    }
}


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\LinkInterface;
32			use Neomerx\JsonApi\Contracts\Schema\SchemaContainerInterface;
33			use Neomerx\JsonApi\Exceptions\InvalidArgumentException;
34			use Neomerx\JsonApi\Factories\Factory;
35
36			/**
37			* @package Neomerx\JsonApi
38			*/
39			class Encoder implements EncoderInterface
40			{
41			/**
42			* Default value.
43			*/
44			const DEFAULT_URL_PREFIX = '';
45
46			/**
47			* Default value.
48			*/
49			const DEFAULT_INCLUDE_PATHS = [];
50
51			/**
52			* Default value.
53			*/
54			const DEFAULT_FIELD_SET_FILTERS = [];
55
56			/**
57			* Default encode options.
58			*
59			* @link http://php.net/manual/en/function.json-encode.php
60			*/
61			const DEFAULT_JSON_ENCODE_OPTIONS = 0;
62
63			/**
64			* Default encode depth.
65			*
66			* @link http://php.net/manual/en/function.json-encode.php
67			*/
68			const DEFAULT_JSON_ENCODE_DEPTH = 512;
69
70			/**
71			* @var SchemaContainerInterface
72			*/
73			private $container;
74
75			/**
76			* @var FactoryInterface
77			*/
78			private $factory;
79
80			/**
81			* @var string
82			*/
83			private $urlPrefix;
84
85			/**
86			* @var array
87			*/
88			private $includePaths;
89
90			/**
91			* @var array
92			*/
93			private $fieldSets;
94
95			/**
96			* @var int
97			*/
98			private $encodeOptions;
99
100			/**
101			* @var int
102			*/
103			private $encodeDepth;
104
105			/**
106			* @var iterable
107			*/
108			private $links;
109
110			/**
111			* @var iterable
112			*/
113			private $profile;
114
115			/**
116			* @var bool
117			*/
118			private $hasMeta;
119
120			/**
121			* @var mixed
122			*/
123			private $meta;
124
125			/**
126			* @var string\|null
127			*/
128			private $jsonApiVersion;
129
130			/**
131			* @var mixed
132			*/
133			private $jsonApiMeta;
134
135			/**
136			* @var bool
137			*/
138			private $hasJsonApiMeta;
139
140			/**
141			* @param FactoryInterface $factory
142			* @param SchemaContainerInterface $container
143			*/
144	78		public function __construct(
145			FactoryInterface $factory,
146			SchemaContainerInterface $container
147			) {
148	78		$this->factory = $factory;
149	78		$this->container = $container;
150
151	78		$this->reset();
152	78		}
153
154			/**
155			* Create encoder instance.
156			*
157			* @param array $schemas Schema providers.
158			*
159			* @return EncoderInterface
160			*/
161	78		public static function instance(array $schemas = []): EncoderInterface
162			{
163	78		$factory = static::createFactory();
164	78		$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...
165	78		$encoder = $factory->createEncoder($container);
166
167	78		return $encoder;
168			}
169
170			/**
171			* @inheritdoc
172			*/
173	78		public function withUrlPrefix(string $prefix): EncoderInterface
174			{
175	78		$this->urlPrefix = $prefix;
176
177	78		return $this;
178			}
179
180			/**
181			* @inheritdoc
182			*/
183	78		public function withIncludedPaths(iterable $paths): EncoderInterface
184			{
185	78		assert(
186	78		call_user_func(
187			function (array $paths): bool {
188	78		$pathsOk = true;
189	78		foreach ($paths as $path) {
190	22		$pathsOk = $pathsOk === true && is_string($path) === true && empty($path) === false;
191			}
192
193	78		return $pathsOk;
194	78		},
195	78		$paths
196			)
197			);
198
199	78		$this->includePaths = $paths;
200
201	78		return $this;
202			}
203
204			/**
205			* @inheritdoc
206			*/
207	78		public function withFieldSets(array $fieldSets): EncoderInterface
208			{
209	78		$this->fieldSets = $fieldSets;
210
211	78		return $this;
212			}
213
214			/**
215			* @inheritdoc
216			*/
217	78		public function withEncodeOptions(int $options): EncoderInterface
218			{
219	78		$this->encodeOptions = $options;
220
221	78		return $this;
222			}
223
224			/**
225			* @inheritdoc
226			*/
227	78		public function withEncodeDepth(int $depth): EncoderInterface
228			{
229	78		assert($depth > 0);
230
231	78		$this->encodeDepth = $depth;
232
233	78		return $this;
234			}
235
236			/**
237			* @inheritdoc
238			*/
239	5		public function withLinks(iterable $links): EncoderInterface
240			{
241	5		$this->links = $this->hasLinks() === true ? $this->mergeIterables($this->links, $links) : $links;
			0 ignored issues – show Documentation introduced 2019-01-20 17:00 UTC by Report Bug Copy Issue Report `$links` 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...
242
243	5		return $this;
244			}
245
246			/**
247			* @inheritdoc
248			*/
249	1		public function withProfile(iterable $links): EncoderInterface
250			{
251	1		$this->profile = $links;
252
253	1		return $this;
254			}
255
256			/**
257			* @inheritdoc
258			*/
259	6		public function withMeta($meta): EncoderInterface
260			{
261	6		$this->meta = $meta;
262	6		$this->hasMeta = true;
263
264	6		return $this;
265			}
266
267			/**
268			* @inheritdoc
269			*/
270	2		public function withJsonApiVersion(string $version = self::JSON_API_VERSION): EncoderInterface
271			{
272	2		$this->jsonApiVersion = $version;
273
274	2		return $this;
275			}
276
277			/**
278			* @inheritdoc
279			*/
280	2		public function withJsonApiMeta($meta): EncoderInterface
281			{
282	2		$this->jsonApiMeta = $meta;
283	2		$this->hasJsonApiMeta = true;
284
285	2		return $this;
286			}
287
288			/**
289			* @inheritdoc
290			*/
291	1	View Code Duplication	public function withRelationshipSelfLink($resource, string $relationshipName): EncoderInterface
292			{
293			$link = $this
294	1		->getSchemaContainer()->getSchema($resource)
295	1		->getRelationshipSelfLink($resource, $relationshipName);
296
297	1		return $this->withLinks(
298			[
299	1		LinkInterface::SELF => $link,
300			]
301			);
302			}
303
304			/**
305			* @inheritdoc
306			*/
307	1	View Code Duplication	public function withRelationshipRelatedLink($resource, string $relationshipName): EncoderInterface
308			{
309			$link = $this
310	1		->getSchemaContainer()->getSchema($resource)
311	1		->getRelationshipRelatedLink($resource, $relationshipName);
312
313	1		return $this->withLinks(
314			[
315	1		LinkInterface::RELATED => $link,
316			]
317			);
318			}
319
320			/**
321			* @inheritdoc
322			*/
323	63		public function encodeData($data): string
324			{
325			// encode to json
326	63		$array = $this->encodeDataToArray($data);
327	60		$result = $this->encodeToJson($array);
328
329	60		$this->reset();
330
331	60		return $result;
332			}
333
334			/**
335			* @inheritdoc
336			*/
337	3		public function encodeIdentifiers($data): string
338			{
339			// encode to json
340	3		$array = $this->encodeIdentifiersToArray($data);
341	3		$result = $this->encodeToJson($array);
342
343	3		$this->reset();
344
345	3		return $result;
346			}
347
348			/**
349			* @inheritdoc
350			*/
351	3		public function encodeError(ErrorInterface $error): string
352			{
353			// encode to json
354	3		$array = $this->encodeErrorToArray($error);
355	3		$result = $this->encodeToJson($array);
356
357	3		$this->reset();
358
359	3		return $result;
360			}
361
362			/**
363			* @inheritdoc
364			*/
365	3		public function encodeErrors(iterable $errors): string
366			{
367			// encode to json
368	3		$array = $this->encodeErrorsToArray($errors);
369	3		$result = $this->encodeToJson($array);
370
371	3		$this->reset();
372
373	3		return $result;
374			}
375
376			/**
377			* @inheritdoc
378			*/
379	1		public function encodeMeta($meta): string
380			{
381			// encode to json
382	1		$array = $this->encodeMetaToArray($meta);
383	1		$result = $this->encodeToJson($array);
384
385	1		$this->reset();
386
387	1		return $result;
388			}
389
390			/**
391			* @return FactoryInterface
392			*/
393	71		protected static function createFactory(): FactoryInterface
394			{
395	71		return new Factory();
396			}
397
398			/**
399			* @return SchemaContainerInterface
400			*/
401	67		protected function getSchemaContainer(): SchemaContainerInterface
402			{
403	67		return $this->container;
404			}
405
406			/**
407			* @return FactoryInterface
408			*/
409	76		protected function getFactory(): FactoryInterface
410			{
411	76		return $this->factory;
412			}
413
414			/**
415			* Reset to initial state.
416			*/
417	78		protected function reset(): void
418			{
419	78		$this->links = null;
420	78		$this->profile = null;
421	78		$this->hasMeta = false;
422	78		$this->meta = null;
423	78		$this->jsonApiVersion = null;
424	78		$this->jsonApiMeta = null;
425	78		$this->hasJsonApiMeta = false;
426
427			$this
428	78		->withUrlPrefix(static::DEFAULT_URL_PREFIX)
429	78		->withIncludedPaths(static::DEFAULT_INCLUDE_PATHS)
			0 ignored issues – show Documentation introduced 2019-01-19 21:06 UTC by Report Bug Copy Issue Report `static::DEFAULT_INCLUDE_PATHS` is of type `array`, but the function expects a `object<Neomerx\JsonApi\C...racts\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...
430	78		->withFieldSets(static::DEFAULT_FIELD_SET_FILTERS)
431	78		->withEncodeOptions(static::DEFAULT_JSON_ENCODE_OPTIONS)
432	78		->withEncodeDepth(static::DEFAULT_JSON_ENCODE_DEPTH);
433	78		}
434
435			/**
436			* @return bool
437			*/
438	76		protected function hasLinks(): bool
439			{
440	76		return $this->links !== null;
441			}
442
443			/**
444			* @return bool
445			*/
446	76		protected function hasProfile(): bool
447			{
448	76		return $this->profile !== null;
449			}
450
451			/**
452			* @return iterable
453			*/
454	5		protected function getLinks(): iterable
455			{
456	5		return $this->links;
457			}
458
459			/**
460			* @return iterable
461			*/
462	1		protected function getProfile(): iterable
463			{
464	1		return $this->profile;
465			}
466
467			/**
468			* @return bool
469			*/
470	76		protected function hasMeta(): bool
471			{
472	76		return $this->hasMeta;
473			}
474
475			/**
476			* @return mixed
477			*/
478	6		public function getMeta()
479			{
480	6		return $this->meta;
481			}
482
483			/**
484			* @return bool
485			*/
486	76		protected function hasJsonApiVersion(): bool
487			{
488	76		return $this->jsonApiVersion !== null;
489			}
490
491			/**
492			* @return string
493			*/
494	2		protected function getJsonApiVersion(): string
495			{
496	2		return $this->jsonApiVersion;
497			}
498
499			/**
500			* @return bool
501			*/
502	76		protected function hasJsonApiMeta(): bool
503			{
504	76		return $this->hasJsonApiMeta;
505			}
506
507			/**
508			* @return mixed
509			*/
510	2		protected function getJsonApiMeta()
511			{
512	2		return $this->jsonApiMeta;
513			}
514
515			/**
516			* @param object\|iterable\|null $data Data to encode.
517			*
518			* @return array
519			*
520			* @SuppressWarnings(PHPMD.ElseExpression)
521			*/
522	64		protected function encodeDataToArray($data): array
523			{
524	64		if (is_array($data) === false && is_object($data) === false && $data !== null) {
525	1		throw new InvalidArgumentException();
526			}
527
528	63		$parser = $this->getFactory()->createParser($this->getSchemaContainer());
529	63		$writer = $this->createDocumentWriter();
530	63		$filter = $this->getFactory()->createFieldSetFilter($this->getFieldSets());
531
532			// write header
533	63		$this->writeHeader($writer);
534
535			// write body
536	63		foreach ($parser->parse($data, $this->getIncludePaths()) as $item) {
537	62		if ($item instanceof ResourceInterface) {
538	55		if ($item->getPosition()->getLevel() > ParserInterface::ROOT_LEVEL) {
539	20		if ($filter->shouldOutputRelationship($item->getPosition()) === true) {
540	20		$writer->addResourceToIncluded($item, $filter);
541			}
542			} else {
543	55		$writer->addResourceToData($item, $filter);
544			}
545	62		} elseif ($item instanceof IdentifierInterface) {
546			assert($item->getPosition()->getLevel() <= ParserInterface::ROOT_LEVEL);
547			$writer->addIdentifierToData($item);
548		View Code Duplication	} else {
549	62		assert($item instanceof DocumentDataInterface);
550	62		if ($item->isCollection() === true) {
551	20		$writer->setDataAsArray();
552	43		} elseif ($item->isNull() === true) {
553	62		$writer->setNullToData();
554			}
555			}
556			}
557
558			// write footer
559	61		$this->writeFooter($writer);
560
561	61		$array = $writer->getDocument();
562
563	61		return $array;
564			}
565
566			/**
567			* @param object\|iterable\|null $data Data to encode.
568			*
569			* @return array
570			*
571			* @SuppressWarnings(PHPMD.ElseExpression)
572			*/
573	4		protected function encodeIdentifiersToArray($data): array
574			{
575	4		$parser = $this->getFactory()->createParser($this->getSchemaContainer());
576	4		$writer = $this->createDocumentWriter();
577	4		$filter = $this->getFactory()->createFieldSetFilter($this->getFieldSets());
578
579			// write header
580	4		$this->writeHeader($writer);
581
582			// write body
583	4		$includePaths = $this->getIncludePaths();
584	4		$expectIncluded = empty($includePaths) === false;
585
586			// https://github.com/neomerx/json-api/issues/218
587			//
588			// if we expect included resources we have to include top level resources in `included` as well
589			// Spec:
590			//
591			// GET /articles/1/relationships/comments?include=comments.author HTTP/1.1
592			// Accept: application/vnd.api+json
593			//
594			// In this case, the primary data would be a collection of resource identifier objects that
595			// represent linkage to comments for an article, while the full comments and comment authors
596			// would be returned as included data.
597
598	4		foreach ($parser->parse($data, $includePaths) as $item) {
599	4		if ($item instanceof ResourceInterface) {
600	4		if ($item->getPosition()->getLevel() > ParserInterface::ROOT_LEVEL) {
601	1		assert($expectIncluded === true);
602	1		if ($filter->shouldOutputRelationship($item->getPosition()) === true) {
603	1		$writer->addResourceToIncluded($item, $filter);
604			}
605			} else {
606	4		$writer->addIdentifierToData($item);
607	4		if ($expectIncluded === true) {
608	4		$writer->addResourceToIncluded($item, $filter);
609			}
610			}
611	4		} elseif ($item instanceof IdentifierInterface) {
612			assert($item->getPosition()->getLevel() <= ParserInterface::ROOT_LEVEL);
613			$writer->addIdentifierToData($item);
614		View Code Duplication	} else {
615	4		assert($item instanceof DocumentDataInterface);
616	4		if ($item->isCollection() === true) {
617	1		$writer->setDataAsArray();
618	3		} elseif ($item->isNull() === true) {
619	4		$writer->setNullToData();
620			}
621			}
622			}
623
624			// write footer
625	4		$this->writeFooter($writer);
626
627	4		$array = $writer->getDocument();
628
629	4		return $array;
630			}
631
632			/**
633			* @param ErrorInterface $error
634			*
635			* @return array
636			*/
637	4		protected function encodeErrorToArray(ErrorInterface $error): array
638			{
639	4		$writer = $this->createErrorWriter();
640
641			// write header
642	4		$this->writeHeader($writer);
643
644			// write body
645	4		$writer->addError($error);
646
647			// write footer
648	4		$this->writeFooter($writer);
649
650	4		$array = $writer->getDocument();
651
652	4		return $array;
653			}
654
655			/**
656			* @param iterable $errors
657			*
658			* @return array
659			*/
660	4		protected function encodeErrorsToArray(iterable $errors): array
661			{
662	4		$writer = $this->createErrorWriter();
663
664			// write header
665	4		$this->writeHeader($writer);
666
667			// write body
668	4		foreach ($errors as $error) {
669	3		assert($error instanceof ErrorInterface);
670	3		$writer->addError($error);
671			}
672
673			// write footer
674	4		$this->writeFooter($writer);
675
676			// encode to json
677	4		$array = $writer->getDocument();
678
679	4		return $array;
680			}
681
682			/**
683			* @param $meta
684			*
685			* @return array
686			*/
687	2		protected function encodeMetaToArray($meta): array
688			{
689	2		$this->withMeta($meta);
690
691	2		$writer = $this->getFactory()->createDocumentWriter();
692
693	2		$writer->setUrlPrefix($this->getUrlPrefix());
694
695			// write header
696	2		$this->writeHeader($writer);
697
698			// write footer
699	2		$this->writeFooter($writer);
700
701			// encode to json
702	2		$array = $writer->getDocument();
703
704	2		return $array;
705			}
706
707			/**
708			* @param BaseWriterInterface $writer
709			*
710			* @return void
711			*/
712	76		protected function writeHeader(BaseWriterInterface $writer): void
713			{
714	76		if ($this->hasMeta() === true) {
715	6		$writer->setMeta($this->getMeta());
716			}
717
718	76		if ($this->hasJsonApiVersion() === true) {
719	2		$writer->setJsonApiVersion($this->getJsonApiVersion());
720			}
721
722	76		if ($this->hasJsonApiMeta() === true) {
723	2		$writer->setJsonApiMeta($this->getJsonApiMeta());
724			}
725
726	76		if ($this->hasLinks() === true) {
727	5		$writer->setLinks($this->getLinks());
728			}
729
730	76		if ($this->hasProfile() === true) {
731	1		$writer->setProfile($this->getProfile());
732			}
733	76		}
734
735			/**
736			* @param BaseWriterInterface $writer
737			*
738			* @return void
739			*/
740	74		protected function writeFooter(BaseWriterInterface $writer): void
			0 ignored issues – show Unused Code introduced 2019-01-19 21:06 UTC by Report Bug Copy Issue Report The parameter `$writer` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
741			{
742	74		}
743
744			/**
745			* Encode array to JSON.
746			*
747			* @param array $document
748			*
749			* @return string
750			*/
751	70		protected function encodeToJson(array $document): string
752			{
753	70		return json_encode($document, $this->getEncodeOptions(), $this->getEncodeDepth());
754			}
755
756			/**
757			* @return string
758			*/
759	76		protected function getUrlPrefix(): string
760			{
761	76		return $this->urlPrefix;
762			}
763
764			/**
765			* @return array
766			*/
767	67		protected function getIncludePaths(): array
768			{
769	67		return $this->includePaths;
770			}
771
772			/**
773			* @return array
774			*/
775	67		protected function getFieldSets(): array
776			{
777	67		return $this->fieldSets;
778			}
779
780			/**
781			* @return int
782			*/
783	70		protected function getEncodeOptions(): int
784			{
785	70		return $this->encodeOptions;
786			}
787
788			/**
789			* @return int
790			*/
791	70		protected function getEncodeDepth(): int
792			{
793	70		return $this->encodeDepth;
794			}
795
796			/**
797			* @return DocumentWriterInterface
798			*/
799	67		private function createDocumentWriter(): DocumentWriterInterface
800			{
801	67		$writer = $this->getFactory()->createDocumentWriter();
802	67		$writer->setUrlPrefix($this->getUrlPrefix());
803
804	67		return $writer;
805			}
806
807			/**
808			* @return ErrorWriterInterface
809			*/
810	7		private function createErrorWriter(): ErrorWriterInterface
811			{
812	7		$writer = $this->getFactory()->createErrorWriter();
813	7		$writer->setUrlPrefix($this->getUrlPrefix());
814
815	7		return $writer;
816			}
817
818			/**
819			* @param iterable $iterable1
820			* @param iterable $iterable2
821			*
822			* @return iterable
823			*/
824			private function mergeIterables(iterable $iterable1, iterable $iterable2): iterable
825			{
826			yield from $iterable1;
827			yield from $iterable2;
828			}
829			}
830

neomerx / json-api