Ivory\Serializer\Visitor\Xml\XmlDeserializationVisitor

Complexity

Total Complexity

24

Size/Duplication

Total Lines	166
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

96.77%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	decode()	0	16	2
A	doVisitArray()	0	13	2
B	doVisitObjectProperty()	0	22	6
B	visitArrayEntry()	0	31	6
B	visitNode()	0	16	5
A	isCollection()	0	4	2

<?php

/*
 * This file is part of the Ivory Serializer package.
 *
 * (c) Eric GELOEN <geloen.eric@gmail.com>
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source code.
 */

namespace Ivory\Serializer\Visitor\Xml;

use Ivory\Serializer\Context\ContextInterface;
use Ivory\Serializer\Instantiator\InstantiatorInterface;
use Ivory\Serializer\Mapping\PropertyMetadataInterface;
use Ivory\Serializer\Mapping\TypeMetadataInterface;
use Ivory\Serializer\Mutator\MutatorInterface;
use Ivory\Serializer\Type\Type;
use Ivory\Serializer\Visitor\AbstractDeserializationVisitor;

/**
 * @author GeLo <geloen.eric@gmail.com>
 */
class XmlDeserializationVisitor extends AbstractDeserializationVisitor
{
    /**
     * @var string
     */
    private $entry;

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

    /**
     * @param InstantiatorInterface $instantiator
     * @param MutatorInterface      $mutator
     * @param string                $entry
     * @param string                $entryAttribute
     */
    public function __construct(
        InstantiatorInterface $instantiator,
        MutatorInterface $mutator,
        $entry = 'entry',
        $entryAttribute = 'key'
    ) {
        parent::__construct($instantiator, $mutator);

        $this->entry = $entry;
        $this->entryAttribute = $entryAttribute;
    }

    /**
     * {@inheritdoc}
     */
    protected function decode($data)
    {
        $internalErrors = libxml_use_internal_errors(true);
        $disableEntityLoader = libxml_disable_entity_loader(true);

        $document = simplexml_load_string($data);

        libxml_use_internal_errors($internalErrors);
        libxml_disable_entity_loader($disableEntityLoader);

        if ($document === false) {
            throw new \InvalidArgumentException(libxml_get_last_error());
        }

        return $document;
    }

    /**
     * {@inheritdoc}
     */
    protected function doVisitArray($data, TypeMetadataInterface $type, ContextInterface $context)
    {
        $this->result = [];

        $entry = $this->entry;
        $entryAttribute = $this->entryAttribute;

        foreach ($data as $key => $value) {
            $this->visitArrayEntry($key, $value, $entry, $entryAttribute, $type, $context);
        }

        return $this->result;
    }

    /**
     * {@inheritdoc}
     */
    protected function doVisitObjectProperty(
        $data,
        $name,
        PropertyMetadataInterface $property,
        ContextInterface $context
    ) {
        if ($property->isXmlValue()) {
            $data = [$name => (string) $data];
        } elseif ($data instanceof \SimpleXMLElement) {
            $data = iterator_to_array($property->isXmlAttribute() ? $data->attributes() : $data->children());
        }

        if (!isset($data[$name])) {
            return false;
        }

        if ($data[$name] instanceof \SimpleXMLElement) {
            $data[$name] = $this->visitNode($data[$name], $property->getType());
        }

        return parent::doVisitObjectProperty($data, $name, $property, $context);
    }

    /**
     * @param mixed                 $key
     * @param \SimpleXMLElement     $data
     * @param string                $entry
     * @param string                $entryAttribute
     * @param TypeMetadataInterface $type
     * @param ContextInterface      $context
     */
    private function visitArrayEntry(
        $key,
        \SimpleXMLElement $data,
        $entry,
        $entryAttribute,
        TypeMetadataInterface $type,
        ContextInterface $context
    ) {
        $result = $this->navigator->navigate(
            $this->visitNode($data, $valueType = $type->getOption('value')),
            $context,
            $valueType
        );

        if ($result === null && $context->isNullIgnored()) {
            return;
        }

        if ($key === $entry) {
            $attributes = $data->attributes();
            $key = isset($attributes[$entryAttribute]) ? $this->visitNode($attributes[$entryAttribute]) : null;
        }

        $key = $this->navigator->navigate($key, $context, $type->getOption('key'));

        if ($key === null) {
            $this->result[] = $result;
        } else {
            $this->result[$key] = $result;
        }
    }

    /**
     * @param \SimpleXMLElement          $data
     * @param TypeMetadataInterface|null $type
     *
     * @return mixed
     */
    private function visitNode(\SimpleXMLElement $data, TypeMetadataInterface $type = null)
    {
        if ($data->count()) {
            return $this->isCollection($type) ? $data : iterator_to_array($data);
        }

        $data = (string) $data;

        if (!empty($data)) {
            return $data;
        }

        if ($this->isCollection($type)) {
            return [];
        }
    }

    /**
     * @param TypeMetadataInterface|null $type
     *
     * @return bool
     */
    private function isCollection(TypeMetadataInterface $type = null)
    {
        return $type !== null && $type->getName() === Type::ARRAY_;
    }
}