Chubbyphp\Serialization\Encoder\XmlTypeEncoder

Complexity

Total Complexity

31

Size/Duplication

Total Lines	215
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	encode()	0	14	1
A	createMetadataNode()	0	8	2
A	dataToArrayNode()	0	29	4
A	getType()	0	11	3
A	getContentType()	0	3	1
A	dataToNodes()	0	18	6
A	getMetaPrefix()	0	3	1
A	__construct()	0	3	1
A	getValueAsString()	0	20	6
A	dataToScalarNode()	0	25	6

<?php

declare(strict_types=1);

namespace Chubbyphp\Serialization\Encoder;

use Doctrine\Common\Inflector\Inflector;

/**
 * @deprecated use JsonxTypeEncoder instead
 */
final class XmlTypeEncoder implements TypeEncoderInterface
{
    /**
     * @var bool
     */
    private $prettyPrint;

    /**
     * @param bool $prettyPrint
     */
    public function __construct(bool $prettyPrint = false)
    {
        $this->prettyPrint = $prettyPrint;
    }

    /**
     * @return string
     */
    public function getContentType(): string
    {
        return 'application/xml';
    }

    /**
     * @param array $data
     *
     * @return string
     */
    public function encode(array $data): string
    {
        $document = new \DOMDocument('1.0', 'UTF-8');
        $document->formatOutput = $this->prettyPrint;

        $listNode = $this->createMetadataNode($document, $data['_type'] ?? null);

        unset($data['_type']);

        $document->appendChild($listNode);

        $this->dataToNodes($document, $listNode, $data);

        return trim($document->saveXML($document, LIBXML_NOEMPTYTAG));
    }

    /**
     * @param \DOMDocument $document
     * @param string|null  $type
     *
     * @return \DOMNode
     */
    private function createMetadataNode(\DOMDocument $document, string $type = null): \DOMNode
    {
        $node = $document->createElement('object');
        if (null !== $type) {
            $node->setAttribute('type', $type);
        }

        return $node;
    }

    /**
     * @param string $name
     *
     * @return string
     */
    private function getMetaPrefix(string $name)
    {
        return 'meta-'.$name;
    }

    /**
     * @param \DOMDocument $document
     * @param \DOMNode     $listNode
     * @param array        $data
     */
    private function dataToNodes(\DOMDocument $document, \DOMNode $listNode, array $data): void
    {
        foreach ($data as $key => $value) {
            if (is_string($key) && '_' === $key[0]) {
                $key = $this->getMetaPrefix(substr($key, 1));
            }

            if (is_array($value)) {
                $childNode = $this->dataToArrayNode($document, $listNode, $key, $value);
            } else {
                $childNode = $this->dataToScalarNode($document, $listNode, $key, $value);
            }

            if (is_int($key)) {
                $childNode->setAttribute('key', (string) $key);
            }

            $listNode->appendChild($childNode);
        }
    }

    /**
     * @param \DOMDocument $document
     * @param \DOMNode     $listNode
     * @param string|int   $key
     * @param array        $value
     *
     * @return \DOMElement|\DOMNode
     */
    private function dataToArrayNode(\DOMDocument $document, \DOMNode $listNode, $key, array $value)
    {
        if (!isset($value['_type'])) {
            $childNode = $document->createElement(is_int($key) ? Inflector::singularize($listNode->nodeName) : $key);
            $this->dataToNodes($document, $childNode, $value);

            return $childNode;
        }

        if (is_int($key)) {
            $childNode = $this->createMetadataNode($document, $value['_type']);

            unset($value['_type']);

            $this->dataToNodes($document, $childNode, $value);

            return $childNode;
        }

        $subChildNode = $this->createMetadataNode($document, $value['_type']);

        unset($value['_type']);

        $childNode = $document->createElement($key);
        $childNode->appendChild($subChildNode);

        $this->dataToNodes($document, $subChildNode, $value);

        return $childNode;
    }

    /**
     * @param \DOMDocument               $document
     * @param \DOMNode                   $listNode
     * @param string|int                 $key
     * @param string|bool|float|int|null $value
     *
     * @return \DOMNode
     */
    private function dataToScalarNode(\DOMDocument $document, \DOMNode $listNode, $key, $value): \DOMNode
    {
        $stringKey = is_int($key) ? Inflector::singularize($listNode->nodeName) : $key;

        if (is_string($value)) {
            if (false !== strpos($value, '<') || false !== strpos($value, '&')) {
                $childNode = $document->createElement($stringKey);
                $childNode->appendChild($document->createCDATASection($value));
            } else {
                $childNode = $document->createElement($stringKey, $value);
            }

            $childNode->setAttribute('type', 'string');

            return $childNode;
        }

        if (null === $value) {
            return $document->createElement($stringKey);
        }

        $childNode = $document->createElement($stringKey, $this->getValueAsString($value));
        $childNode->setAttribute('type', $this->getType($value));

        return $childNode;
    }

    /**
     * @param bool|float|int $value
     *
     * @throws \InvalidArgumentException
     *
     * @return string
     */
    private function getValueAsString($value): string
    {
        if (is_bool($value)) {
            return $value ? 'true' : 'false';
        }

        if (is_float($value)) {
            $value = (string) $value;
            if (false === strpos($value, '.')) {
                $value .= '.0';
            }

            return $value;
        }

        if (is_int($value)) {

The condition is_int($value) is always true.

            return (string) $value;
        }

        throw new \InvalidArgumentException(sprintf('Unsupported data type: %s', gettype($value)));
    }

    /**
     * @param bool|float|int|string $value
     *
     * @return string
     */
    private function getType($value): string
    {
        if (is_bool($value)) {
            return 'boolean';
        }

        if (is_float($value)) {
            return 'float';
        }

        return 'integer';
    }
}