vendor/symfony/serializer/Encoder/XmlEncoder.php line 71

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Serializer\Encoder;
  14. use Symfony\Component\Serializer\Exception\BadMethodCallException;
  15. use Symfony\Component\Serializer\Exception\NotEncodableValueException;
  16. use Symfony\Component\Serializer\SerializerAwareInterface;
  17. use Symfony\Component\Serializer\SerializerAwareTrait;
  19. /**
  20.  * @author Jordi Boggiano <j.boggiano@seld.be>
  21.  * @author John Wards <jwards@whiteoctober.co.uk>
  22.  * @author Fabian Vogler <fabian@equivalence.ch>
  23.  * @author Kévin Dunglas <dunglas@gmail.com>
  24.  * @author Dany Maillard <danymaillard93b@gmail.com>
  25.  */
  26. class XmlEncoder implements EncoderInterface, DecoderInterface, NormalizationAwareInterface, SerializerAwareInterface
  27. {
  28.     use SerializerAwareTrait;
  30.     public const FORMAT = 'xml';
  32.     public const AS_COLLECTION = 'as_collection';
  34.     /**
  35.      * An array of ignored XML node types while decoding, each one of the DOM Predefined XML_* constants.
  36.      */
  37.     public const DECODER_IGNORED_NODE_TYPES = 'decoder_ignored_node_types';
  39.     /**
  40.      * An array of ignored XML node types while encoding, each one of the DOM Predefined XML_* constants.
  41.      */
  42.     public const ENCODER_IGNORED_NODE_TYPES = 'encoder_ignored_node_types';
  43.     public const ENCODING = 'xml_encoding';
  44.     public const FORMAT_OUTPUT = 'xml_format_output';
  46.     /**
  47.      * A bit field of LIBXML_* constants.
  48.      */
  49.     public const LOAD_OPTIONS = 'load_options';
  50.     public const REMOVE_EMPTY_TAGS = 'remove_empty_tags';
  51.     public const ROOT_NODE_NAME = 'xml_root_node_name';
  52.     public const STANDALONE = 'xml_standalone';
  53.     public const TYPE_CAST_ATTRIBUTES = 'xml_type_cast_attributes';
  54.     public const VERSION = 'xml_version';
  56.     private $defaultContext = [
  57.         self::AS_COLLECTION => false,
  58.         self::DECODER_IGNORED_NODE_TYPES => [\XML_PI_NODE, \XML_COMMENT_NODE],
  59.         self::ENCODER_IGNORED_NODE_TYPES => [],
  60.         self::LOAD_OPTIONS => \LIBXML_NONET | \LIBXML_NOBLANKS,
  61.         self::REMOVE_EMPTY_TAGS => false,
  62.         self::ROOT_NODE_NAME => 'response',
  63.         self::TYPE_CAST_ATTRIBUTES => true,
  64.     ];
  66.     public function __construct(array $defaultContext = [])
  67.     {
  68.         $this->defaultContext = array_merge($this->defaultContext, $defaultContext);
  69.     }
  71.     public function encode(mixed $data, string $format, array $context = []): string
  72.     {
  73.         $encoderIgnoredNodeTypes = $context[self::ENCODER_IGNORED_NODE_TYPES] ?? $this->defaultContext[self::ENCODER_IGNORED_NODE_TYPES];
  74.         $ignorePiNode = \in_array(\XML_PI_NODE, $encoderIgnoredNodeTypes, true);
  75.         if ($data instanceof \DOMDocument) {
  76.             return $data->saveXML($ignorePiNode ? $data->documentElement : null);
  77.         }
  79.         $xmlRootNodeName = $context[self::ROOT_NODE_NAME] ?? $this->defaultContext[self::ROOT_NODE_NAME];
  81.         $dom = $this->createDomDocument($context);
  83.         if (null !== $data && !\is_scalar($data)) {
  84.             $root = $dom->createElement($xmlRootNodeName);
  85.             $dom->appendChild($root);
  86.             $this->buildXml($root, $data, $format, $context, $xmlRootNodeName);
  87.         } else {
  88.             $this->appendNode($dom, $data, $format, $context, $xmlRootNodeName);
  89.         }
  91.         return $dom->saveXML($ignorePiNode ? $dom->documentElement : null);
  92.     }
  94.     public function decode(string $data, string $format, array $context = []): mixed
  95.     {
  96.         if ('' === trim($data)) {
  97.             throw new NotEncodableValueException('Invalid XML data, it cannot be empty.');
  98.         }
  100.         $internalErrors = libxml_use_internal_errors(true);
  101.         libxml_clear_errors();
  103.         $dom = new \DOMDocument();
  104.         $dom->loadXML($data, $context[self::LOAD_OPTIONS] ?? $this->defaultContext[self::LOAD_OPTIONS]);
  106.         libxml_use_internal_errors($internalErrors);
  108.         if ($error = libxml_get_last_error()) {
  109.             libxml_clear_errors();
  111.             throw new NotEncodableValueException($error->message);
  112.         }
  114.         $rootNode = null;
  115.         $decoderIgnoredNodeTypes = $context[self::DECODER_IGNORED_NODE_TYPES] ?? $this->defaultContext[self::DECODER_IGNORED_NODE_TYPES];
  116.         foreach ($dom->childNodes as $child) {
  117.             if (\in_array($child->nodeType, $decoderIgnoredNodeTypes, true)) {
  118.                 continue;
  119.             }
  120.             if (\XML_DOCUMENT_TYPE_NODE === $child->nodeType) {
  121.                 throw new NotEncodableValueException('Document types are not allowed.');
  122.             }
  123.             if (!$rootNode) {
  124.                 $rootNode = $child;
  125.             }
  126.         }
  128.         // todo: throw an exception if the root node name is not correctly configured (bc)
  130.         if ($rootNode->hasChildNodes()) {
  131.             $xpath = new \DOMXPath($dom);
  132.             $data = [];
  133.             foreach ($xpath->query('namespace::*', $dom->documentElement) as $nsNode) {
  134.                 $data['@'.$nsNode->nodeName] = $nsNode->nodeValue;
  135.             }
  137.             unset($data['@xmlns:xml']);
  139.             if (empty($data)) {
  140.                 return $this->parseXml($rootNode, $context);
  141.             }
  143.             return array_merge($data, (array) $this->parseXml($rootNode, $context));
  144.         }
  146.         if (!$rootNode->hasAttributes()) {
  147.             return $rootNode->nodeValue;
  148.         }
  150.         $data = [];
  152.         foreach ($rootNode->attributes as $attrKey => $attr) {
  153.             $data['@'.$attrKey] = $attr->nodeValue;
  154.         }
  156.         $data['#'] = $rootNode->nodeValue;
  158.         return $data;
  159.     }
  161.     public function supportsEncoding(string $format): bool
  162.     {
  163.         return self::FORMAT === $format;
  164.     }
  166.     public function supportsDecoding(string $format): bool
  167.     {
  168.         return self::FORMAT === $format;
  169.     }
  171.     final protected function appendXMLString(\DOMNode $node, string $val): bool
  172.     {
  173.         if ('' !== $val) {
  174.             $frag = $node->ownerDocument->createDocumentFragment();
  175.             $frag->appendXML($val);
  176.             $node->appendChild($frag);
  178.             return true;
  179.         }
  181.         return false;
  182.     }
  184.     final protected function appendText(\DOMNode $node, string $val): bool
  185.     {
  186.         $nodeText = $node->ownerDocument->createTextNode($val);
  187.         $node->appendChild($nodeText);
  189.         return true;
  190.     }
  192.     final protected function appendCData(\DOMNode $node, string $val): bool
  193.     {
  194.         $nodeText = $node->ownerDocument->createCDATASection($val);
  195.         $node->appendChild($nodeText);
  197.         return true;
  198.     }
  200.     final protected function appendDocumentFragment(\DOMNode $node, \DOMDocumentFragment $fragment): bool
  201.     {
  202.         if ($fragment instanceof \DOMDocumentFragment) {
  203.             $node->appendChild($fragment);
  205.             return true;
  206.         }
  208.         return false;
  209.     }
  211.     final protected function appendComment(\DOMNode $node, string $data): bool
  212.     {
  213.         $node->appendChild($node->ownerDocument->createComment($data));
  215.         return true;
  216.     }
  218.     /**
  219.      * Checks the name is a valid xml element name.
  220.      */
  221.     final protected function isElementNameValid(string $name): bool
  222.     {
  223.         return $name &&
  224.             !str_contains($name, ' ') &&
  225.             preg_match('#^[\pL_][\pL0-9._:-]*$#ui', $name);
  226.     }
  228.     /**
  229.      * Parse the input DOMNode into an array or a string.
  230.      */
  231.     private function parseXml(\DOMNode $node, array $context = []): array|string
  232.     {
  233.         $data = $this->parseXmlAttributes($node, $context);
  235.         $value = $this->parseXmlValue($node, $context);
  237.         if (!\count($data)) {
  238.             return $value;
  239.         }
  241.         if (!\is_array($value)) {
  242.             $data['#'] = $value;
  244.             return $data;
  245.         }
  247.         if (1 === \count($value) && key($value)) {
  248.             $data[key($value)] = current($value);
  250.             return $data;
  251.         }
  253.         foreach ($value as $key => $val) {
  254.             $data[$key] = $val;
  255.         }
  257.         return $data;
  258.     }
  260.     /**
  261.      * Parse the input DOMNode attributes into an array.
  262.      */
  263.     private function parseXmlAttributes(\DOMNode $node, array $context = []): array
  264.     {
  265.         if (!$node->hasAttributes()) {
  266.             return [];
  267.         }
  269.         $data = [];
  270.         $typeCastAttributes = (bool) ($context[self::TYPE_CAST_ATTRIBUTES] ?? $this->defaultContext[self::TYPE_CAST_ATTRIBUTES]);
  272.         foreach ($node->attributes as $attr) {
  273.             if (!is_numeric($attr->nodeValue) || !$typeCastAttributes || (isset($attr->nodeValue[1]) && '0' === $attr->nodeValue[0] && '.' !== $attr->nodeValue[1])) {
  274.                 $data['@'.$attr->nodeName] = $attr->nodeValue;
  276.                 continue;
  277.             }
  279.             if (false !== $val = filter_var($attr->nodeValue, \FILTER_VALIDATE_INT)) {
  280.                 $data['@'.$attr->nodeName] = $val;
  282.                 continue;
  283.             }
  285.             $data['@'.$attr->nodeName] = (float) $attr->nodeValue;
  286.         }
  288.         return $data;
  289.     }
  291.     /**
  292.      * Parse the input DOMNode value (content and children) into an array or a string.
  293.      */
  294.     private function parseXmlValue(\DOMNode $node, array $context = []): array|string
  295.     {
  296.         if (!$node->hasChildNodes()) {
  297.             return $node->nodeValue;
  298.         }
  300.         if (1 === $node->childNodes->length && \in_array($node->firstChild->nodeType, [\XML_TEXT_NODE, \XML_CDATA_SECTION_NODE])) {
  301.             return $node->firstChild->nodeValue;
  302.         }
  304.         $value = [];
  305.         $decoderIgnoredNodeTypes = $context[self::DECODER_IGNORED_NODE_TYPES] ?? $this->defaultContext[self::DECODER_IGNORED_NODE_TYPES];
  306.         foreach ($node->childNodes as $subnode) {
  307.             if (\in_array($subnode->nodeType, $decoderIgnoredNodeTypes, true)) {
  308.                 continue;
  309.             }
  311.             $val = $this->parseXml($subnode, $context);
  313.             if ('item' === $subnode->nodeName && isset($val['@key'])) {
  314.                 $value[$val['@key']] = $val['#'] ?? $val;
  315.             } else {
  316.                 $value[$subnode->nodeName][] = $val;
  317.             }
  318.         }
  320.         $asCollection = $context[self::AS_COLLECTION] ?? $this->defaultContext[self::AS_COLLECTION];
  321.         foreach ($value as $key => $val) {
  322.             if (!$asCollection && \is_array($val) && 1 === \count($val)) {
  323.                 $value[$key] = current($val);
  324.             }
  325.         }
  327.         return $value;
  328.     }
  330.     /**
  331.      * Parse the data and convert it to DOMElements.
  332.      *
  333.      * @throws NotEncodableValueException
  334.      */
  335.     private function buildXml(\DOMNode $parentNode, mixed $data, string $format, array $context, string $xmlRootNodeName = null): bool
  336.     {
  337.         $append = true;
  338.         $removeEmptyTags = $context[self::REMOVE_EMPTY_TAGS] ?? $this->defaultContext[self::REMOVE_EMPTY_TAGS] ?? false;
  339.         $encoderIgnoredNodeTypes = $context[self::ENCODER_IGNORED_NODE_TYPES] ?? $this->defaultContext[self::ENCODER_IGNORED_NODE_TYPES];
  341.         if (\is_array($data) || ($data instanceof \Traversable && (null === $this->serializer || !$this->serializer->supportsNormalization($data, $format)))) {
  342.             foreach ($data as $key => $data) {
  343.                 // Ah this is the magic @ attribute types.
  344.                 if (str_starts_with($key, '@') && $this->isElementNameValid($attributeName = substr($key, 1))) {
  345.                     if (!\is_scalar($data)) {
  346.                         $data = $this->serializer->normalize($data, $format, $context);
  347.                     }
  348.                     if (\is_bool($data)) {
  349.                         $data = (int) $data;
  350.                     }
  351.                     $parentNode->setAttribute($attributeName, $data);
  352.                 } elseif ('#' === $key) {
  353.                     $append = $this->selectNodeType($parentNode, $data, $format, $context);
  354.                 } elseif ('#comment' === $key) {
  355.                     if (!\in_array(\XML_COMMENT_NODE, $encoderIgnoredNodeTypes, true)) {
  356.                         $append = $this->appendComment($parentNode, $data);
  357.                     }
  358.                 } elseif (\is_array($data) && false === is_numeric($key)) {
  359.                     // Is this array fully numeric keys?
  360.                     if (ctype_digit(implode('', array_keys($data)))) {
  361.                         /*
  362.                          * Create nodes to append to $parentNode based on the $key of this array
  363.                          * Produces <xml><item>0</item><item>1</item></xml>
  364.                          * From ["item" => [0,1]];.
  365.                          */
  366.                         foreach ($data as $subData) {
  367.                             $append = $this->appendNode($parentNode, $subData, $format, $context, $key);
  368.                         }
  369.                     } else {
  370.                         $append = $this->appendNode($parentNode, $data, $format, $context, $key);
  371.                     }
  372.                 } elseif (is_numeric($key) || !$this->isElementNameValid($key)) {
  373.                     $append = $this->appendNode($parentNode, $data, $format, $context, 'item', $key);
  374.                 } elseif (null !== $data || !$removeEmptyTags) {
  375.                     $append = $this->appendNode($parentNode, $data, $format, $context, $key);
  376.                 }
  377.             }
  379.             return $append;
  380.         }
  382.         if (\is_object($data)) {
  383.             if (null === $this->serializer) {
  384.                 throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));
  385.             }
  387.             $data = $this->serializer->normalize($data, $format, $context);
  388.             if (null !== $data && !\is_scalar($data)) {
  389.                 return $this->buildXml($parentNode, $data, $format, $context, $xmlRootNodeName);
  390.             }
  392.             // top level data object was normalized into a scalar
  393.             if (!$parentNode->parentNode->parentNode) {
  394.                 $root = $parentNode->parentNode;
  395.                 $root->removeChild($parentNode);
  397.                 return $this->appendNode($root, $data, $format, $context, $xmlRootNodeName);
  398.             }
  400.             return $this->appendNode($parentNode, $data, $format, $context, 'data');
  401.         }
  403.         throw new NotEncodableValueException('An unexpected value could not be serialized: '.(!\is_resource($data) ? var_export($data, true) : sprintf('%s resource', get_resource_type($data))));
  404.     }
  406.     /**
  407.      * Selects the type of node to create and appends it to the parent.
  408.      */
  409.     private function appendNode(\DOMNode $parentNode, mixed $data, string $format, array $context, string $nodeName, string $key = null): bool
  410.     {
  411.         $dom = $parentNode instanceof \DOMDocument ? $parentNode : $parentNode->ownerDocument;
  412.         $node = $dom->createElement($nodeName);
  413.         if (null !== $key) {
  414.             $node->setAttribute('key', $key);
  415.         }
  416.         $appendNode = $this->selectNodeType($node, $data, $format, $context);
  417.         // we may have decided not to append this node, either in error or if its $nodeName is not valid
  418.         if ($appendNode) {
  419.             $parentNode->appendChild($node);
  420.         }
  422.         return $appendNode;
  423.     }
  425.     /**
  426.      * Checks if a value contains any characters which would require CDATA wrapping.
  427.      */
  428.     private function needsCdataWrapping(string $val): bool
  429.     {
  430.         return preg_match('/[<>&]/', $val);
  431.     }
  433.     /**
  434.      * Tests the value being passed and decide what sort of element to create.
  435.      *
  436.      * @throws NotEncodableValueException
  437.      */
  438.     private function selectNodeType(\DOMNode $node, mixed $val, string $format, array $context): bool
  439.     {
  440.         if (\is_array($val)) {
  441.             return $this->buildXml($node, $val, $format, $context);
  442.         } elseif ($val instanceof \SimpleXMLElement) {
  443.             $child = $node->ownerDocument->importNode(dom_import_simplexml($val), true);
  444.             $node->appendChild($child);
  445.         } elseif ($val instanceof \Traversable) {
  446.             $this->buildXml($node, $val, $format, $context);
  447.         } elseif ($val instanceof \DOMNode) {
  448.             $child = $node->ownerDocument->importNode($val, true);
  449.             $node->appendChild($child);
  450.         } elseif (\is_object($val)) {
  451.             if (null === $this->serializer) {
  452.                 throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));
  453.             }
  455.             return $this->selectNodeType($node, $this->serializer->normalize($val, $format, $context), $format, $context);
  456.         } elseif (is_numeric($val)) {
  457.             return $this->appendText($node, (string) $val);
  458.         } elseif (\is_string($val) && $this->needsCdataWrapping($val)) {
  459.             return $this->appendCData($node, $val);
  460.         } elseif (\is_string($val)) {
  461.             return $this->appendText($node, $val);
  462.         } elseif (\is_bool($val)) {
  463.             return $this->appendText($node, (int) $val);
  464.         }
  466.         return true;
  467.     }
  469.     /**
  470.      * Create a DOM document, taking serializer options into account.
  471.      */
  472.     private function createDomDocument(array $context): \DOMDocument
  473.     {
  474.         $document = new \DOMDocument();
  476.         // Set an attribute on the DOM document specifying, as part of the XML declaration,
  477.         $xmlOptions = [
  478.             // nicely formats output with indentation and extra space
  479.             self::FORMAT_OUTPUT => 'formatOutput',
  480.             // the version number of the document
  481.             self::VERSION => 'xmlVersion',
  482.             // the encoding of the document
  483.             self::ENCODING => 'encoding',
  484.             // whether the document is standalone
  485.             self::STANDALONE => 'xmlStandalone',
  486.         ];
  487.         foreach ($xmlOptions as $xmlOption => $documentProperty) {
  488.             if ($contextOption = $context[$xmlOption] ?? $this->defaultContext[$xmlOption] ?? false) {
  489.                 $document->$documentProperty = $contextOption;
  490.             }
  491.         }
  493.         return $document;
  494.     }
  495. }