Encoder::getProfile() - Code Metrics - Inspection of "#82 Add test coverage. Refactoring." - neomerx/json-api - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — next (8f844e)

by Neomerx

created 2019-01-25 10:55 UTC

Encoder::getProfile() A

↳ Parent: Encoder

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

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

    {
    }

    /**
     * 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	81		public function __construct(
145			FactoryInterface $factory,
146			SchemaContainerInterface $container
147			) {
148	81		$this->factory = $factory;
149	81		$this->container = $container;
150
151	81		$this->reset();
152	81		}
153
154			/**
155			* Create encoder instance.
156			*
157			* @param array $schemas Schema providers.
158			*
159			* @return EncoderInterface
160			*/
161	81		public static function instance(array $schemas = []): EncoderInterface
162			{
163	81		$factory = static::createFactory();
164	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...
165	81		$encoder = $factory->createEncoder($container);
166
167	81		return $encoder;
168			}
169
170			/**
171			* @inheritdoc
172			*/
173	81		public function withUrlPrefix(string $prefix): EncoderInterface
174			{
175	81		$this->urlPrefix = $prefix;
176
177	81		return $this;
178			}
179
180			/**
181			* @inheritdoc
182			*/
183	81		public function withIncludedPaths(iterable $paths): EncoderInterface
184			{
185	81		assert(
186	81		call_user_func(
187			function (array $paths): bool {
188	81		$pathsOk = true;
189	81		foreach ($paths as $path) {
190	22		$pathsOk = $pathsOk === true && is_string($path) === true && empty($path) === false;
191			}
192
193	81		return $pathsOk;
194	81		},
195	81		$paths
196			)
197			);
198
199	81		$this->includePaths = $paths;
200
201	81		return $this;
202			}
203
204			/**
205			* @inheritdoc
206			*/
207	81		public function withFieldSets(array $fieldSets): EncoderInterface
208			{
209	81		$this->fieldSets = $fieldSets;
210
211	81		return $this;
212			}
213
214			/**
215			* @inheritdoc
216			*/
217	81		public function withEncodeOptions(int $options): EncoderInterface
218			{
219	81		$this->encodeOptions = $options;
220
221	81		return $this;
222			}
223
224			/**
225			* @inheritdoc
226			*/
227	81		public function withEncodeDepth(int $depth): EncoderInterface
228			{
229	81		assert($depth > 0);
230
231	81		$this->encodeDepth = $depth;
232
233	81		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	64		public function encodeData($data): string
324			{
325			// encode to json
326	64		$array = $this->encodeDataToArray($data);
327	61		$result = $this->encodeToJson($array);
328
329	61		$this->reset();
330
331	61		return $result;
332			}
333
334			/**
335			* @inheritdoc
336			*/
337	5		public function encodeIdentifiers($data): string
338			{
339			// encode to json
340	5		$array = $this->encodeIdentifiersToArray($data);
341	5		$result = $this->encodeToJson($array);
342
343	5		$this->reset();
344
345	5		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	74		protected static function createFactory(): FactoryInterface
394			{
395	74		return new Factory();
396			}
397
398			/**
399			* @return SchemaContainerInterface
400			*/
401	70		protected function getSchemaContainer(): SchemaContainerInterface
402			{
403	70		return $this->container;
404			}
405
406			/**
407			* @return FactoryInterface
408			*/
409	79		protected function getFactory(): FactoryInterface
410			{
411	79		return $this->factory;
412			}
413
414			/**
415			* Reset to initial state.
416			*/
417	81		protected function reset(): void
418			{
419	81		$this->links = null;
420	81		$this->profile = null;
421	81		$this->hasMeta = false;
422	81		$this->meta = null;
423	81		$this->jsonApiVersion = null;
424	81		$this->jsonApiMeta = null;
425	81		$this->hasJsonApiMeta = false;
426
427			$this
428	81		->withUrlPrefix(static::DEFAULT_URL_PREFIX)
429	81		->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	81		->withFieldSets(static::DEFAULT_FIELD_SET_FILTERS)
431	81		->withEncodeOptions(static::DEFAULT_JSON_ENCODE_OPTIONS)
432	81		->withEncodeDepth(static::DEFAULT_JSON_ENCODE_DEPTH);
433	81		}
434
435			/**
436			* @return bool
437			*/
438	79		protected function hasLinks(): bool
439			{
440	79		return $this->links !== null;
441			}
442
443			/**
444			* @return bool
445			*/
446	79		protected function hasProfile(): bool
447			{
448	79		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	79		protected function hasMeta(): bool
471			{
472	79		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	79		protected function hasJsonApiVersion(): bool
487			{
488	79		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	79		protected function hasJsonApiMeta(): bool
503			{
504	79		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	65		protected function encodeDataToArray($data): array
523			{
524	65		if (is_array($data) === false && is_object($data) === false && $data !== null) {
525	1		throw new InvalidArgumentException();
526			}
527
528	64		$parser = $this->getFactory()->createParser($this->getSchemaContainer());
529	64		$writer = $this->createDocumentWriter();
530	64		$filter = $this->getFactory()->createFieldSetFilter($this->getFieldSets());
531
532			// write header
533	64		$this->writeHeader($writer);
534
535			// write body
536	64		foreach ($parser->parse($data, $this->getIncludePaths()) as $item) {
537	63		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	63		} elseif ($item instanceof IdentifierInterface) {
546	1		assert($item->getPosition()->getLevel() <= ParserInterface::ROOT_LEVEL);
547	1		$writer->addIdentifierToData($item);
548		View Code Duplication	} else {
549	63		assert($item instanceof DocumentDataInterface);
550	63		assert($item->getPosition()->getLevel() === 0);
551	63		if ($item->isCollection() === true) {
552	21		$writer->setDataAsArray();
553	44		} elseif ($item->isNull() === true) {
554	63		$writer->setNullToData();
555			}
556			}
557			}
558
559			// write footer
560	62		$this->writeFooter($writer);
561
562	62		$array = $writer->getDocument();
563
564	62		return $array;
565			}
566
567			/**
568			* @param object\|iterable\|null $data Data to encode.
569			*
570			* @return array
571			*
572			* @SuppressWarnings(PHPMD.ElseExpression)
573			*/
574	6		protected function encodeIdentifiersToArray($data): array
575			{
576	6		$parser = $this->getFactory()->createParser($this->getSchemaContainer());
577	6		$writer = $this->createDocumentWriter();
578	6		$filter = $this->getFactory()->createFieldSetFilter($this->getFieldSets());
579
580			// write header
581	6		$this->writeHeader($writer);
582
583			// write body
584	6		$includePaths = $this->getIncludePaths();
585	6		$expectIncluded = empty($includePaths) === false;
586
587			// https://github.com/neomerx/json-api/issues/218
588			//
589			// if we expect included resources we have to include top level resources in `included` as well
590			// Spec:
591			//
592			// GET /articles/1/relationships/comments?include=comments.author HTTP/1.1
593			// Accept: application/vnd.api+json
594			//
595			// In this case, the primary data would be a collection of resource identifier objects that
596			// represent linkage to comments for an article, while the full comments and comment authors
597			// would be returned as included data.
598
599	6		foreach ($parser->parse($data, $includePaths) as $item) {
600	6		if ($item instanceof ResourceInterface) {
601	4		if ($item->getPosition()->getLevel() > ParserInterface::ROOT_LEVEL) {
602	1		assert($expectIncluded === true);
603	1		if ($filter->shouldOutputRelationship($item->getPosition()) === true) {
604	1		$writer->addResourceToIncluded($item, $filter);
605			}
606			} else {
607	4		$writer->addIdentifierToData($item);
608	4		if ($expectIncluded === true) {
609	4		$writer->addResourceToIncluded($item, $filter);
610			}
611			}
612	6		} elseif ($item instanceof IdentifierInterface) {
613	1		assert($item->getPosition()->getLevel() <= ParserInterface::ROOT_LEVEL);
614	1		$writer->addIdentifierToData($item);
615		View Code Duplication	} else {
616	6		assert($item instanceof DocumentDataInterface);
617	6		assert($item->getPosition()->getLevel() === 0);
618	6		if ($item->isCollection() === true) {
619	2		$writer->setDataAsArray();
620	5		} elseif ($item->isNull() === true) {
621	6		$writer->setNullToData();
622			}
623			}
624			}
625
626			// write footer
627	6		$this->writeFooter($writer);
628
629	6		$array = $writer->getDocument();
630
631	6		return $array;
632			}
633
634			/**
635			* @param ErrorInterface $error
636			*
637			* @return array
638			*/
639	4		protected function encodeErrorToArray(ErrorInterface $error): array
640			{
641	4		$writer = $this->createErrorWriter();
642
643			// write header
644	4		$this->writeHeader($writer);
645
646			// write body
647	4		$writer->addError($error);
648
649			// write footer
650	4		$this->writeFooter($writer);
651
652	4		$array = $writer->getDocument();
653
654	4		return $array;
655			}
656
657			/**
658			* @param iterable $errors
659			*
660			* @return array
661			*/
662	4		protected function encodeErrorsToArray(iterable $errors): array
663			{
664	4		$writer = $this->createErrorWriter();
665
666			// write header
667	4		$this->writeHeader($writer);
668
669			// write body
670	4		foreach ($errors as $error) {
671	3		assert($error instanceof ErrorInterface);
672	3		$writer->addError($error);
673			}
674
675			// write footer
676	4		$this->writeFooter($writer);
677
678			// encode to json
679	4		$array = $writer->getDocument();
680
681	4		return $array;
682			}
683
684			/**
685			* @param $meta
686			*
687			* @return array
688			*/
689	2		protected function encodeMetaToArray($meta): array
690			{
691	2		$this->withMeta($meta);
692
693	2		$writer = $this->getFactory()->createDocumentWriter();
694
695	2		$writer->setUrlPrefix($this->getUrlPrefix());
696
697			// write header
698	2		$this->writeHeader($writer);
699
700			// write footer
701	2		$this->writeFooter($writer);
702
703			// encode to json
704	2		$array = $writer->getDocument();
705
706	2		return $array;
707			}
708
709			/**
710			* @param BaseWriterInterface $writer
711			*
712			* @return void
713			*/
714	79		protected function writeHeader(BaseWriterInterface $writer): void
715			{
716	79		if ($this->hasMeta() === true) {
717	6		$writer->setMeta($this->getMeta());
718			}
719
720	79		if ($this->hasJsonApiVersion() === true) {
721	2		$writer->setJsonApiVersion($this->getJsonApiVersion());
722			}
723
724	79		if ($this->hasJsonApiMeta() === true) {
725	2		$writer->setJsonApiMeta($this->getJsonApiMeta());
726			}
727
728	79		if ($this->hasLinks() === true) {
729	5		$writer->setLinks($this->getLinks());
730			}
731
732	79		if ($this->hasProfile() === true) {
733	1		$writer->setProfile($this->getProfile());
734			}
735	79		}
736
737			/**
738			* @param BaseWriterInterface $writer
739			*
740			* @return void
741			*/
742	77		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...
743			{
744	77		}
745
746			/**
747			* Encode array to JSON.
748			*
749			* @param array $document
750			*
751			* @return string
752			*/
753	73		protected function encodeToJson(array $document): string
754			{
755	73		return json_encode($document, $this->getEncodeOptions(), $this->getEncodeDepth());
756			}
757
758			/**
759			* @return string
760			*/
761	79		protected function getUrlPrefix(): string
762			{
763	79		return $this->urlPrefix;
764			}
765
766			/**
767			* @return array
768			*/
769	70		protected function getIncludePaths(): array
770			{
771	70		return $this->includePaths;
772			}
773
774			/**
775			* @return array
776			*/
777	70		protected function getFieldSets(): array
778			{
779	70		return $this->fieldSets;
780			}
781
782			/**
783			* @return int
784			*/
785	73		protected function getEncodeOptions(): int
786			{
787	73		return $this->encodeOptions;
788			}
789
790			/**
791			* @return int
792			*/
793	73		protected function getEncodeDepth(): int
794			{
795	73		return $this->encodeDepth;
796			}
797
798			/**
799			* @return DocumentWriterInterface
800			*/
801	70		private function createDocumentWriter(): DocumentWriterInterface
802			{
803	70		$writer = $this->getFactory()->createDocumentWriter();
804	70		$writer->setUrlPrefix($this->getUrlPrefix());
805
806	70		return $writer;
807			}
808
809			/**
810			* @return ErrorWriterInterface
811			*/
812	7		private function createErrorWriter(): ErrorWriterInterface
813			{
814	7		$writer = $this->getFactory()->createErrorWriter();
815	7		$writer->setUrlPrefix($this->getUrlPrefix());
816
817	7		return $writer;
818			}
819
820			/**
821			* @param iterable $iterable1
822			* @param iterable $iterable2
823			*
824			* @return iterable
825			*/
826	1		private function mergeIterables(iterable $iterable1, iterable $iterable2): iterable
827			{
828	1		yield from $iterable1;
829	1		yield from $iterable2;
830	1		}
831			}
832

neomerx / json-api

Branch — next (8f844e)

Encoder::getProfile() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like