IdentifierAndResource::hasIdentifierMeta() - 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
IdentifierAndResource::hasIdentifierMeta() A

↳ Parent: IdentifierAndResource
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\Parser;

/**
 * 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 IteratorAggregate;
use Neomerx\JsonApi\Contracts\Factories\FactoryInterface;
use Neomerx\JsonApi\Contracts\Parser\IdentifierInterface as ParserIdentifierInterface;
use Neomerx\JsonApi\Contracts\Parser\ParserInterface;
use Neomerx\JsonApi\Contracts\Parser\PositionInterface;
use Neomerx\JsonApi\Contracts\Parser\RelationshipDataInterface;
use Neomerx\JsonApi\Contracts\Parser\ResourceInterface;
use Neomerx\JsonApi\Contracts\Schema\IdentifierInterface as SchemaIdentifierInterface;
use Neomerx\JsonApi\Contracts\Schema\LinkInterface;
use Neomerx\JsonApi\Contracts\Schema\SchemaContainerInterface;
use Neomerx\JsonApi\Contracts\Schema\SchemaInterface;
use Neomerx\JsonApi\Exceptions\InvalidArgumentException;
use Neomerx\JsonApi\Exceptions\LogicException;
use Traversable;
use function Neomerx\JsonApi\I18n\format as _;

/**
 * @package Neomerx\JsonApi
 */
class IdentifierAndResource implements ResourceInterface
{
    /** @var string */
    public const MSG_NO_SCHEMA_FOUND = 'No Schema found for resource `%s` at path `%s`.';

    /** @var string */
    public const MSG_INVALID_OPERATION = 'Invalid operation.';

    /**
     * @var PositionInterface
     */
    private $position;

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

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

    /**
     * @var SchemaInterface
     */
    private $schema;

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

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

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

    /**
     * @var null|array
     */
    private $links = null;

    /**
     * @var null|array
     */
    private $relationshipsCache = null;

    /**
     * @param PositionInterface        $position
     * @param FactoryInterface         $factory
     * @param SchemaContainerInterface $container
     * @param mixed                    $data
     */
    public function __construct(
        PositionInterface $position,
        FactoryInterface $factory,
        SchemaContainerInterface $container,
        $data
    ) {
        $schema = $container->getSchema($data);
        $this
            ->setPosition($position)
            ->setFactory($factory)
            ->setSchemaContainer($container)
            ->setSchema($schema)
            ->setData($data);
    }

    /**
     * @inheritdoc
     */
    public function getPosition(): PositionInterface
    {
        return $this->position;
    }

    /**
     * @inheritdoc
     */
    public function getId(): ?string
    {
        return $this->index;
    }

    /**
     * @inheritdoc
     */
    public function getType(): string
    {
        return $this->type;
    }

    /**
     * @inheritdoc
     */
    public function hasIdentifierMeta(): bool
    {
        return $this->getSchema()->hasIdentifierMeta($this->getData());
    }

    /**
     * @inheritdoc
     */
    public function getIdentifierMeta()
    {
        return $this->getSchema()->getIdentifierMeta($this->getData());
    }

    /**
     * @inheritdoc
     */
    public function getAttributes(): iterable
    {
        return $this->getSchema()->getAttributes($this->getData());
    }

    /**
     * @inheritdoc
     */
    public function getRelationships(): iterable
    {
        if ($this->relationshipsCache !== null) {
            yield from $this->relationshipsCache;

            return;
        }

        $this->relationshipsCache = [];

        $currentType    = $this->getType();
        $currentPath    = $this->getPosition()->getPath();
        $nextLevel      = $this->getPosition()->getLevel() + 1;
        $nextPathPrefix = empty($currentPath) === true ? '' : $currentPath . PositionInterface::PATH_SEPARATOR;
        foreach ($this->getSchema()->getRelationships($this->getData()) as $name => $description) {
            assert(
                is_string($name) === true && empty($name) === false,
                "Relationship names for type `" . $currentType . '` should be non-empty strings.'
            );
            assert(
                is_array($description) === true && empty($description) === false,
                "Relationship `$name` for type `" . $currentType . '` should be a non-empty array.'
            );

            $hasData = array_key_exists(SchemaInterface::RELATIONSHIP_DATA, $description);
            // either no data or data should be array/object/null
            assert(
                $hasData === false ||
                (
                    is_array($data = $description[SchemaInterface::RELATIONSHIP_DATA]) === true ||
                    is_object($data) === true ||
                    $data === null
                )
            );

            $hasMeta = array_key_exists(SchemaInterface::RELATIONSHIP_META, $description);

            $addSelfLink    = $description[SchemaInterface::RELATIONSHIP_LINKS_SELF] ??
                $this->getSchema()->isAddSelfLinkInRelationshipByDefault();
            $addRelatedLink = $description[SchemaInterface::RELATIONSHIP_LINKS_RELATED] ??
                $this->getSchema()->isAddRelatedLinkInRelationshipByDefault();
            assert(is_bool($addSelfLink) === true || $addSelfLink instanceof LinkInterface);
            assert(is_bool($addRelatedLink) === true || $addRelatedLink instanceof LinkInterface);

            $schemaLinks = array_key_exists(SchemaInterface::RELATIONSHIP_LINKS, $description) === true ?
                $description[SchemaInterface::RELATIONSHIP_LINKS] : [];
            assert(is_array($schemaLinks));

            // if `self` or `related` link was given as LinkInterface merge it with the other links
            if (is_bool($addSelfLink) === false) {
                $extraSchemaLinks[LinkInterface::SELF] = $addSelfLink;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
                $addSelfLink                           = false;
            }
            if (is_bool($addRelatedLink) === false) {
                $extraSchemaLinks[LinkInterface::RELATED] = $addRelatedLink;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
                $addRelatedLink                           = false;
            }
            if (isset($extraSchemaLinks) === true) {
                // IDE do not understand it's defined without he line below
                assert(isset($extraSchemaLinks));
                $schemaLinks = array_merge($extraSchemaLinks, $schemaLinks);
                unset($extraSchemaLinks);
            }
            assert(is_bool($addSelfLink) === true && is_bool($addRelatedLink) === true);

            $hasLinks = $addSelfLink === true || $addRelatedLink === true || empty($schemaLinks) === false;
            assert(
                $hasData || $hasMeta || $hasLinks,
                "Relationship `$name` for type `" . $currentType .
                '` MUST contain at least one of the following: links, data or meta.'
            );

            $nextPosition = $this->getFactory()->createPosition(
                $nextLevel,
                $nextPathPrefix . $name,
                $currentType,
                $name
            );

            $relationshipData = $hasData === true ? $this->parseData(
                $nextPosition,
                $description[SchemaInterface::RELATIONSHIP_DATA]
            ) : null;

            $relationship = $this->getFactory()->createRelationship(
                $nextPosition,
                $hasData,
                $relationshipData,
                $hasLinks,
                $hasLinks === true ? $this->parseLinks($name, $schemaLinks, $addSelfLink, $addRelatedLink) : null,
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                $hasMeta,
                $hasMeta === true ? $description[SchemaInterface::RELATIONSHIP_META] : null
            );

            $this->relationshipsCache[$name] = $relationship;

            yield $name => $relationship;
        }
    }

    /**
     * @inheritdoc
     */
    public function hasLinks(): bool
    {
        $this->cacheLinks();

        return empty($this->links) === false;
    }

    /**
     * @inheritdoc
     */
    public function getLinks(): iterable
    {
        $this->cacheLinks();

        return $this->links;

    }

    /**
     * @inheritdoc
     */
    public function hasResourceMeta(): bool
    {
        return $this->getSchema()->hasResourceMeta($this->getData());
    }

    /**
     * @inheritdoc
     */
    public function getResourceMeta()
    {
        return $this->getSchema()->getResourceMeta($this->getData());
    }

    /**
     * @inheritdoc
     */
    protected function setPosition(PositionInterface $position): self
    {
        assert($position->getLevel() >= ParserInterface::ROOT_LEVEL);

        $this->position = $position;

        return $this;
    }

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

    /**
     * @param FactoryInterface $factory
     *
     * @return self
     */
    protected function setFactory(FactoryInterface $factory): self
    {
        $this->factory = $factory;

        return $this;
    }

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

    /**
     * @param SchemaContainerInterface $container
     *
     * @return self
     */
    protected function setSchemaContainer(SchemaContainerInterface $container): self
    {
        $this->schemaContainer = $container;

        return $this;
    }

    /**
     * @return SchemaInterface
     */
    protected function getSchema(): SchemaInterface
    {
        return $this->schema;
    }

    /**
     * @param SchemaInterface $schema
     *
     * @return self
     */
    protected function setSchema(SchemaInterface $schema): self
    {
        $this->schema = $schema;

        return $this;
    }

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

    /**
     * @param mixed $data
     *
     * @return self
     */
    protected function setData($data): self
    {
        $this->data  = $data;
        $this->index = $this->getSchema()->getId($data);
        $this->type  = $this->getSchema()->getType();

        return $this;
    }

    /**
     * Read and parse links from schema.
     */
    private function cacheLinks(): void
    {
        if ($this->links === null) {
            $this->links = [];
            foreach ($this->getSchema()->getLinks($this->getData()) as $name => $link) {
                assert(is_string($name) === true && empty($name) === false);
                assert($link instanceof LinkInterface);
                $this->links[$name] = $link;
            }
        }
    }

    /**
     * @param PositionInterface $position
     * @param mixed             $data
     *
     * @return RelationshipDataInterface
     */
    private function parseData(
        PositionInterface $position,
        $data
    ): RelationshipDataInterface {
        // support if data is callable (e.g. a closure used to postpone actual data reading)
        if (is_callable($data) === true) {
            $data = call_user_func($data);
        }

        if ($this->getSchemaContainer()->hasSchema($data) === true) {
            return $this->createRelationshipDataIsResource($position, $data);
        } elseif ($data instanceof SchemaIdentifierInterface) {
            return $this->createRelationshipDataIsIdentifier($position, $data);
        } elseif (is_array($data) === true) {
            return $this->createRelationshipDataIsCollection($position, $data);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        } elseif ($data instanceof Traversable) {
            return $this->createRelationshipDataIsCollection(
                $position,
                $data instanceof IteratorAggregate ? $data->getIterator() : $data
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            );
        } elseif ($data === null) {
            return $this->createRelationshipDataIsNull();
        }

        throw new InvalidArgumentException(
            _(static::MSG_NO_SCHEMA_FOUND, get_class($data), $position->getPath())
        );
    }

    /**
     * @param string   $relationshipName
     * @param iterable $schemaLinks
     * @param bool     $addSelfLink
     * @param bool     $addRelatedLink
     *
     * @return iterable
     */
    private function parseLinks(
        string $relationshipName,
        iterable $schemaLinks,
        bool $addSelfLink,
        bool $addRelatedLink
    ): iterable {
        $gotSelf    = false;
        $gotRelated = false;

        foreach ($schemaLinks as $name => $link) {
            assert($link instanceof LinkInterface);
            if ($name === LinkInterface::SELF) {
                assert($gotSelf === false);
                $gotSelf     = true;
                $addSelfLink = false;
            } elseif ($name === LinkInterface::RELATED) {
                assert($gotRelated === false);
                $gotRelated     = true;
                $addRelatedLink = false;
            }

            yield $name => $link;
        }

        if ($addSelfLink === true) {
            $link = $this->getSchema()->getRelationshipSelfLink($this->getData(), $relationshipName);
            yield LinkInterface::SELF => $link;
            $gotSelf = true;
        }
        if ($addRelatedLink === true) {
            $link = $this->getSchema()->getRelationshipRelatedLink($this->getData(), $relationshipName);
            yield LinkInterface::RELATED => $link;
            $gotRelated = true;
        }

        // spec: check links has at least one of the following: self or related
        assert($gotSelf || $gotRelated);
    }

    /**
     * @param PositionInterface $position
     * @param mixed             $resource
     *
     * @return RelationshipDataInterface
     */
    private function createRelationshipDataIsResource(
        PositionInterface $position,
        $resource
    ): RelationshipDataInterface {
        $factory         = $this->getFactory();
        $schemaContainer = $this->getSchemaContainer();

        return new class (
            $position,
            $factory,
            $schemaContainer,
            $resource
        ) extends BaseRelationshipData implements RelationshipDataInterface
        {
            /**
             * @var mixed
             */
            private $resource;

            /**
             * @var null|ResourceInterface
             */
            private $parsedResource = null;

            /**
             * @param PositionInterface        $position
             * @param FactoryInterface         $factory
             * @param SchemaContainerInterface $schemaContainer
             * @param mixed                    $resource
             */
            public function __construct(
                PositionInterface $position,
                FactoryInterface $factory,
                SchemaContainerInterface $schemaContainer,
                $resource
            ) {
                parent::__construct($position, $factory, $schemaContainer);

                $this->resource = $resource;
            }

            /**
             * @inheritdoc
             */
            public function isCollection(): bool
            {
                return false;
            }

            /**
             * @inheritdoc
             */
            public function isNull(): bool
            {
                return false;
            }

            /**
             * @inheritdoc
             */
            public function isResource(): bool
            {
                return true;
            }

            /**
             * @inheritdoc
             */
            public function isIdentifier(): bool
            {
                return false;
            }

            /**
             * @inheritdoc
             */
            public function getIdentifier(): ParserIdentifierInterface
            {
                throw new LogicException(_(IdentifierAndResource::MSG_INVALID_OPERATION));
            }

            /**
             * @inheritdoc
             */
            public function getIdentifiers(): iterable
            {
                throw new LogicException(_(IdentifierAndResource::MSG_INVALID_OPERATION));
            }

            /**
             * @inheritdoc
             */
            public function getResource(): ResourceInterface
            {
                if ($this->parsedResource === null) {
                    $this->parsedResource = $this->createParsedResource($this->resource);
                }

                return $this->parsedResource;
            }

            /**
             * @inheritdoc
             */
            public function getResources(): iterable
            {
                throw new LogicException(_(IdentifierAndResource::MSG_INVALID_OPERATION));
            }
        };
    }

    /**
     * @param PositionInterface         $position
     * @param SchemaIdentifierInterface $identifier
     *
     * @return RelationshipDataInterface
     */
    private function createRelationshipDataIsIdentifier(
        PositionInterface $position,
        SchemaIdentifierInterface $identifier
    ): RelationshipDataInterface {
        $factory         = $this->getFactory();
        $schemaContainer = $this->getSchemaContainer();

        return new class (
            $position,
            $factory,
            $schemaContainer,
            $identifier
        ) extends BaseRelationshipData implements RelationshipDataInterface
        {
            /**
             * @var mixed
             */
            private $identifier;

            /**
             * @var null|ParserIdentifierInterface
             */
            private $parsedIdentifier = null;

            /**
             * @param PositionInterface         $position
             * @param FactoryInterface          $factory
             * @param SchemaContainerInterface  $schemaContainer
             * @param SchemaIdentifierInterface $identifier
             */
            public function __construct(
                PositionInterface $position,
                FactoryInterface $factory,
                SchemaContainerInterface $schemaContainer,
                SchemaIdentifierInterface $identifier
            ) {
                parent::__construct($position, $factory, $schemaContainer);

                $this->identifier = $identifier;
            }

            /**
             * @inheritdoc
             */
            public function isCollection(): bool
            {
                return false;
            }

            /**
             * @inheritdoc
             */
            public function isNull(): bool
            {
                return false;
            }

            /**
             * @inheritdoc
             */
            public function isResource(): bool
            {
                return false;
            }

            /**
             * @inheritdoc
             */
            public function isIdentifier(): bool
            {
                return true;
            }

            /**
             * @inheritdoc
             */
            public function getIdentifier(): ParserIdentifierInterface
            {
                if ($this->parsedIdentifier === null) {
                    $this->parsedIdentifier = $this->createParsedIdentifier($this->identifier);
                }

                return $this->parsedIdentifier;
            }

            /**
             * @inheritdoc
             */
            public function getIdentifiers(): iterable
            {
                throw new LogicException(_(IdentifierAndResource::MSG_INVALID_OPERATION));
            }

            /**
             * @inheritdoc
             */
            public function getResource(): ResourceInterface
            {
                throw new LogicException(_(IdentifierAndResource::MSG_INVALID_OPERATION));
            }

            /**
             * @inheritdoc
             */
            public function getResources(): iterable
            {
                throw new LogicException(_(IdentifierAndResource::MSG_INVALID_OPERATION));
            }
        };
    }

    /**
     * @param PositionInterface $position
     * @param iterable          $resources
     *
     * @return RelationshipDataInterface
     */
    private function createRelationshipDataIsCollection(
        PositionInterface $position,
        iterable $resources
    ): RelationshipDataInterface {
        $factory         = $this->getFactory();
        $schemaContainer = $this->getSchemaContainer();

        return new class (
            $position,
            $factory,
            $schemaContainer,
            $resources
        ) extends BaseRelationshipData implements RelationshipDataInterface
        {
            /**
             * @var iterable
             */
            private $resources;

            /**
             * @var iterable
             */
            private $parsedResources = null;

            /**
             * @param PositionInterface        $position
             * @param FactoryInterface         $factory
             * @param SchemaContainerInterface $schemaContainer
             * @param iterable                 $resources
             */
            public function __construct(
                PositionInterface $position,
                FactoryInterface $factory,
                SchemaContainerInterface $schemaContainer,
                iterable $resources
            ) {
                parent::__construct($position, $factory, $schemaContainer);

                $this->resources = $resources;
            }

            /**
             * @inheritdoc
             */
            public function isCollection(): bool
            {
                return true;
            }

            /**
             * @inheritdoc
             */
            public function isNull(): bool
            {
                return false;
            }

            /**
             * @inheritdoc
             */
            public function isResource(): bool
            {
                return false;
            }

            /**
             * @inheritdoc
             */
            public function isIdentifier(): bool
            {
                return false;
            }

            /**
             * @inheritdoc
             */
            public function getIdentifier(): ParserIdentifierInterface
            {
                throw new LogicException(_(IdentifierAndResource::MSG_INVALID_OPERATION));
            }

            /**
             * @inheritdoc
             */
            public function getIdentifiers(): iterable
            {
                return $this->getResources();
            }

            /**
             * @inheritdoc
             */
            public function getResource(): ResourceInterface
            {
                throw new LogicException(_(IdentifierAndResource::MSG_INVALID_OPERATION));
            }

            /**
             * @inheritdoc
             */
            public function getResources(): iterable
            {
                if ($this->parsedResources === null) {
                    foreach ($this->resources as $resource) {
                        $parsedResource          = $this->createParsedResource($resource);
                        $this->parsedResources[] = $parsedResource;

                        yield $parsedResource;
                    }

                    return;
                }

                yield from $this->parsedResources;
            }
        };
    }

    /**
     * @return RelationshipDataInterface
     */
    private function createRelationshipDataIsNull(): RelationshipDataInterface
    {
        return new class() implements RelationshipDataInterface
        {
            /**
             * @inheritdoc
             */
            public function isCollection(): bool
            {
                return false;
            }

            /**
             * @inheritdoc
             */
            public function isNull(): bool
            {
                return true;
            }

            /**
             * @inheritdoc
             */
            public function isResource(): bool
            {
                return false;
            }

            /**
             * @inheritdoc
             */
            public function isIdentifier(): bool
            {
                return false;
            }

            /**
             * @inheritdoc
             */
            public function getIdentifier(): ParserIdentifierInterface
            {
                throw new LogicException(_(IdentifierAndResource::MSG_INVALID_OPERATION));
            }

            /**
             * @inheritdoc
             */
            public function getIdentifiers(): iterable
            {
                throw new LogicException(_(IdentifierAndResource::MSG_INVALID_OPERATION));
            }

            /**
             * @inheritdoc
             */
            public function getResource(): ResourceInterface
            {
                throw new LogicException(_(IdentifierAndResource::MSG_INVALID_OPERATION));
            }

            /**
             * @inheritdoc
             */
            public function getResources(): iterable
            {
                throw new LogicException(_(IdentifierAndResource::MSG_INVALID_OPERATION));
            }
        };
    }
}

neomerx / json-api

Branch — next (29fadd)

IdentifierAndResource::hasIdentifierMeta() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like
