Fxmlrpc\Serialization\Serializer\XmlWriterSerializer

Complexity

Total Complexity

30

Size/Duplication

Total Lines	182
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	enableExtension()	0	4	1
A	disableExtension()	0	4	1
A	isExtensionEnabled()	0	4	2
F	serialize()	0	136	25

<?php

namespace Fxmlrpc\Serialization\Serializer;

use Fxmlrpc\Serialization\Exception\InvalidTypeException;
use Fxmlrpc\Serialization\ExtensionSupport;
use Fxmlrpc\Serialization\Serializer;
use Fxmlrpc\Serialization\Value\Base64;

/**
 * Serializer creates XML from native PHP types using XML Writer extension.
 *
 * @author Lars Strojny <lstrojny@php.net>
 */
final class XmlWriterSerializer implements Serializer, ExtensionSupport
{
    /**
     * @var \XMLWriter
     */
    private $writer;

    /**
     * @var array
     */
    private $extensions = [];

    public function __construct()
    {
        $this->writer = new \XMLWriter();
        $this->writer->openMemory();
    }

    /**
     * {@inheritdoc}
     */
    public function enableExtension($extension)
    {
        $this->extensions[$extension] = true;
    }

    /**
     * {@inheritdoc}
     */
    public function disableExtension($extension)
    {
        $this->extensions[$extension] = false;
    }

    /**
     * {@inheritdoc}
     */
    public function isExtensionEnabled($extension)
    {
        return isset($this->extensions[$extension]) ? $this->extensions[$extension] : true;
    }

    /**
     * {@inheritdoc}
     */
    public function serialize($methodName, array $params = [])
    {
        $writer = $this->writer;

        $writer->startDocument('1.0', 'UTF-8');
        $writer->startElement('methodCall');
        $writer->writeElement('methodName', $methodName);
        $writer->startElement('params');

        $endNode = static function () use ($writer) {
            $writer->endElement();
        };
        $valueNode = static function () use ($writer) {
            $writer->startElement('value');
        };
        $paramNode = static function () use ($writer) {
            $writer->startElement('param');
        };

        $toBeVisited = [];
        foreach (array_reverse($params) as $param) {
            $toBeVisited[] = $endNode;
            $toBeVisited[] = $param;
            $toBeVisited[] = $paramNode;
        }

        $nilTagName = $this->isExtensionEnabled(ExtensionSupport::EXTENSION_NIL) ? 'nil' : 'string';

        while ($toBeVisited) {

The expression $toBeVisited of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $node = array_pop($toBeVisited);
            $type = gettype($node);

            if ($type === 'string') {
                $writer->startElement('value');
                $writer->writeElement('string', $node);
                $writer->endElement();
            } elseif ($type === 'integer') {
                $writer->startElement('value');
                $writer->writeElement('int', $node);
                $writer->endElement();
            } elseif ($type === 'double') {
                if (!isset($precision)) {
                    $precision = ini_get('precision');
                }

                $writer->startElement('value');
                $writer->writeElement('double', $node);
                $writer->endElement();
            } elseif ($type === 'boolean') {
                $writer->startElement('value');
                $writer->writeElement('boolean', $node ? '1' : '0');
                $writer->endElement();
            } elseif ($type === 'NULL') {
                $writer->startElement('value');
                $writer->writeElement($nilTagName);
                $writer->endElement();
            } elseif ($type === 'array') {
                /* Find out if it is a struct or an array */
                $smallestIndex = 0;
                foreach ($node as $smallestIndex => &$child) {
                    break;
                }
                $isStruct = !is_int($smallestIndex);
                if (!$isStruct) {
                    $length = count($node) + $smallestIndex;
                    for ($index = $smallestIndex; $index < $length; ++$index) {
                        if (!isset($node[$index])) {
                            $isStruct = true;
                            break;
                        }
                    }
                }

                if (!$isStruct) {
                    $toBeVisited[] = $endNode;
                    $toBeVisited[] = $endNode;
                    $toBeVisited[] = $endNode;
                    foreach (array_reverse($node) as $value) {
                        $toBeVisited[] = $value;
                    }
                    $toBeVisited[] = static function () use ($writer) {
                        $writer->startElement('array');
                        $writer->startElement('data');
                    };
                    $toBeVisited[] = $valueNode;
                } else {
                    struct:
                    $toBeVisited[] = $endNode;
                    $toBeVisited[] = $endNode;
                    foreach (array_reverse($node, true) as $key => $value) {
                        $toBeVisited[] = $endNode;
                        $toBeVisited[] = $value;
                        $toBeVisited[] = static function () use ($writer, $key) {
                            $writer->writeElement('name', $key);
                        };
                        $toBeVisited[] = static function () use ($writer) {
                            $writer->startElement('member');
                        };
                    }
                    $toBeVisited[] = static function () use ($writer) {
                        $writer->startElement('struct');
                    };
                    $toBeVisited[] = $valueNode;
                }
            } elseif ($type === 'object') {
                if ($node instanceof \Closure) {
                    $node();
                } elseif ($node instanceof \DateTime) {
                    $writer->startElement('value');
                    $writer->writeElement('dateTime.iso8601', $node->format('Ymd\TH:i:s'));
                    $writer->endElement();
                } elseif ($node instanceof Base64) {
                    $writer->startElement('value');
                    $writer->writeElement('base64', $node->getEncoded()."\n");
                    $writer->endElement();
                } else {
                    $node = get_object_vars($node);
                    goto struct;
                }
            } elseif ($type === 'resource') {
                throw new InvalidTypeException($node);
            }
        }

        $writer->endElement();
        $writer->endElement();

        $xml = $writer->flush(true);

        // NativeSerializer does not inject a newline after the declaration
        if ($xml[38] === "\n") {
            $xml = substr($xml, 0, 38).substr($xml, 39);
        }

        return $xml;
    }
}