POData\ObjectModel\CynicDeserialiser::processLinkSingleton()

Complexity

Conditions	18
Paths	80

Size

Total Lines	74
Code Lines	52

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

<?php
    protected function processLinkSingleton(ODataLink &$link, ResourceSet $sourceSet, $source, $hasUrl, $hasPayload)
    {
        /** @var ODataEntry|null $result */
        $result = $link->getExpandedResult() ? $link->getExpandedResult()->getEntry() : null;
        assert(
            null === $result || $result instanceof ODataEntry,
            (null === $result ? 'null' : get_class($result))
        );

        if ($hasUrl) {
            $urlBitz      = explode('/', $link->getUrl());
            $rawPredicate = $urlBitz[count($urlBitz) - 1];
            $rawPredicate = explode('(', $rawPredicate);
            $setName      = $rawPredicate[0];
            $rawPredicate = trim($rawPredicate[count($rawPredicate) - 1], ')');
            $targSet      = $this->getMetaProvider()->resolveResourceSet($setName);
            assert(null !== $targSet, get_class($targSet));
            $type = $targSet->getResourceType();
        } else {
            $type = $this->getMetaProvider()->resolveResourceType($result->type->getTerm());
        }

        // if link result has already been processed, bail out
        if (null !== $result || null !== $link->getUrl()) {

The condition null !== $link->getUrl() is always true.

            $isUrlKey = $link->getUrl() instanceof KeyDescriptor;
            $isIdKey  = $result instanceof ODataEntry &&
                $result->id instanceof KeyDescriptor;
            if ($isUrlKey || $isIdKey) {
                if ($isIdKey) {
                }
                return;
            }
        }
        assert(null === $result || !$result->id instanceof KeyDescriptor);
        assert(null === $link->getUrl() || is_string($link->getUrl()));

        assert($type instanceof ResourceEntityType, get_class($type));
        $propName = $link->getTitle();

        /** @var KeyDescriptor|null $keyDesc */
        $keyDesc = null;

        if ($hasUrl) {
            assert(isset($rawPredicate));
            KeyDescriptor::tryParseKeysFromKeyPredicate($rawPredicate, $keyDesc);

The variable $rawPredicate does not seem to be defined for all execution paths leading up to this point.

            $keyDesc->validate($rawPredicate, $type);
            assert(null !== $keyDesc, 'Key description must not be null');
        }

        // hooking up to existing resource
        if ($hasUrl && !$hasPayload) {
            assert(isset($targSet));
            assert(isset($keyDesc));
            $target = $this->getWrapper()->getResourceFromResourceSet($targSet, $keyDesc);

The variable $targSet does not seem to be defined for all execution paths leading up to this point.

            assert(isset($target));
            $this->getWrapper()->hookSingleModel($sourceSet, $source, $targSet, $target, $propName);
            return;
        }
        // creating new resource
        if (!$hasUrl && $hasPayload) {
            list($targSet, $target) = $this->processEntryContent($result);
            assert(isset($target));
            $key        = $this->generateKeyDescriptor($type, $result->propertyContent);
            $link->setUrl($key->generateRelativeUri($targSet));
            $result->id = $key;

It seems like $key can also be of type POData\UriProcessor\ResourcePathProcessor\SegmentParser\KeyDescriptor. However, the property $id is declared as type null|string. Maybe add an additional type check?

            $this->getWrapper()->hookSingleModel($sourceSet, $source, $targSet, $target, $propName);
            return;
        }
        // updating existing resource and connecting to it
        list($targSet, $target) = $this->processEntryContent($result);
        assert(isset($target));
        $result->id = $keyDesc;
        $this->getWrapper()->hookSingleModel($sourceSet, $source, $targSet, $target, $propName);
        return;
    }