JMS\Serializer\XmlSerializationVisitor::visitProperty()

Complexity

Conditions	29
Paths	29

Size

Total Lines	115
Code Lines	65

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	54
CRAP Score	29.1223

Importance

Changes	1
Bugs	0	Features	0

<?php
    public function visitProperty(PropertyMetadata $metadata, $v): void
    {
        if ($metadata->xmlAttribute) {
            $this->setCurrentMetadata($metadata);
            $node = $this->navigator->accept($v, $metadata->type);

It seems like $metadata->type can also be of type JMS\Serializer\Metadata\TypeArray; however, parameter $type of JMS\Serializer\GraphNavigatorInterface::accept() does only seem to accept array|null, maybe add an additional type check?

            $this->revertCurrentMetadata();

            if (!$node instanceof \DOMCharacterData) {
                throw new RuntimeException(sprintf('Unsupported value for XML attribute for %s. Expected character data, but got %s.', $metadata->name, json_encode($v)));
            }

            $this->setAttributeOnNode($this->currentNode, $metadata->serializedName, $node->nodeValue, $metadata->xmlNamespace);

It seems like $metadata->serializedName can also be of type null; however, parameter $name of JMS\Serializer\XmlSerializationVisitor::setAttributeOnNode() does only seem to accept string, maybe add an additional type check?

It seems like $this->currentNode can also be of type null; however, parameter $node of JMS\Serializer\XmlSerializationVisitor::setAttributeOnNode() does only seem to accept DOMElement, maybe add an additional type check?

            return;
        }

        if (
            ($metadata->xmlValue && $this->currentNode->childNodes->length > 0)
            || (!$metadata->xmlValue && $this->hasValue)
        ) {
            throw new RuntimeException(sprintf('If you make use of @XmlValue, all other properties in the class must have the @XmlAttribute annotation. Invalid usage detected in class %s.', $metadata->class));
        }

        if ($metadata->xmlValue) {
            $this->hasValue = true;

            $this->setCurrentMetadata($metadata);
            $node = $this->navigator->accept($v, $metadata->type);
            $this->revertCurrentMetadata();

            if (!$node instanceof \DOMCharacterData) {
                throw new RuntimeException(sprintf('Unsupported value for property %s::$%s. Expected character data, but got %s.', $metadata->class, $metadata->name, \is_object($node) ? \get_class($node) : \gettype($node)));
            }

            $this->currentNode->appendChild($node);

The method appendChild() does not exist on null.

            return;
        }

        if ($metadata->xmlAttributeMap) {
            if (!\is_array($v)) {
                throw new RuntimeException(sprintf('Unsupported value type for XML attribute map. Expected array but got %s.', \gettype($v)));
            }

            foreach ($v as $key => $value) {
                $this->setCurrentMetadata($metadata);
                $node = $this->navigator->accept($value, null);
                $this->revertCurrentMetadata();

                if (!$node instanceof \DOMCharacterData) {
                    throw new RuntimeException(sprintf('Unsupported value for a XML attribute map value. Expected character data, but got %s.', json_encode($v)));
                }

                $this->setAttributeOnNode($this->currentNode, $key, $node->nodeValue, $metadata->xmlNamespace);
            }

            return;
        }

        if (false !== strpos($metadata->serializedName, '/@') && $this->trySerializePropertyAsAttributeOnSiblingElement($metadata, $v)) {

It seems like $metadata->serializedName can also be of type null; however, parameter $haystack of strpos() does only seem to accept string, maybe add an additional type check?

            return;
        }

        if (0 === strpos($metadata->serializedName, '@')) {
            [$attributeValue, $processedNode] = $this->processValueForXmlAttribute($v, $metadata->type, $metadata);

It seems like $metadata->type can also be of type JMS\Serializer\Metadata\TypeArray; however, parameter $valueType of JMS\Serializer\XmlSerializationVisitor::processValueForXmlAttribute() does only seem to accept array|null, maybe add an additional type check?

            if (null === $v && null === $processedNode) {
                return;
            }

            $attributeName = substr($metadata->serializedName, 1);

It seems like $metadata->serializedName can also be of type null; however, parameter $string of substr() does only seem to accept string, maybe add an additional type check?

            if ($this->currentNode instanceof \DOMElement) {
                $this->setAttributeOnNode($this->currentNode, $attributeName, $attributeValue, $metadata->xmlNamespace);
            } else {
                throw new RuntimeException('Cannot set attribute on a non-element node.');
            }

            return;
        }

        if ($addEnclosingElement = !$this->isInLineCollection($metadata) && !$metadata->inline) {

Consider adding parentheses for clarity. Current Interpretation: $addEnclosingElement = (! $this->isInLineCollection($metadata) && ! $metadata->inline), Probably Intended Meaning: ($addEnclosingElement = ! $this->isInLineCollection($metadata)) && ! $metadata->inline

            $namespace = $metadata->xmlNamespace ?? $this->getClassDefaultNamespace($this->objectMetadataStack->top());

            $element = $this->createElement($metadata->serializedName, $namespace);

It seems like $metadata->serializedName can also be of type null; however, parameter $tagName of JMS\Serializer\XmlSerializationVisitor::createElement() does only seem to accept string, maybe add an additional type check?

            $this->currentNode->appendChild($element);
            $this->setCurrentNode($element);
        }

        $this->setCurrentMetadata($metadata);

        try {
            if (null !== $node = $this->navigator->accept($v, $metadata->type)) {
                $this->currentNode->appendChild($node);
            }
        } catch (NotAcceptableException $e) {
            $this->currentNode->parentNode->removeChild($this->currentNode);

It seems like $this->currentNode can also be of type null; however, parameter $child of DOMNode::removeChild() does only seem to accept DOMNode, maybe add an additional type check?

            $this->revertCurrentMetadata();
            $this->revertCurrentNode();
            $this->hasValue = false;

            return;
        }

        $this->revertCurrentMetadata();

        if ($addEnclosingElement) {
            $this->revertCurrentNode();

            if ($this->isElementEmpty($element) && (null === $v || $this->isSkippableCollection($metadata) || $this->isSkippableEmptyObject($node, $metadata))) {
                $this->currentNode->removeChild($element);
            }
        }

        $this->hasValue = false;
    }