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

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <[email protected]>
  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 <[email protected]>
  21.  * @author John Wards <[email protected]>
  22.  * @author Fabian Vogler <[email protected]>
  23.  * @author Kévin Dunglas <[email protected]>
  24.  * @author Dany Maillard <[email protected]>
  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.     /**
  72.      * {@inheritdoc}
  73.      */
  74.     public function encode(mixed $data, string $format, array $context = []): string
  75.     {
  76.         $encoderIgnoredNodeTypes = $context[self::ENCODER_IGNORED_NODE_TYPES] ?? $this->defaultContext[self::ENCODER_IGNORED_NODE_TYPES];
  77.         $ignorePiNode = \in_array(\XML_PI_NODE, $encoderIgnoredNodeTypes, true);
  78.         if ($data instanceof \DOMDocument) {
  79.             return $data->saveXML($ignorePiNode ? $data->documentElement : null);
  80.         }
  82.         $xmlRootNodeName = $context[self::ROOT_NODE_NAME] ?? $this->defaultContext[self::ROOT_NODE_NAME];
  84.         $dom = $this->createDomDocument($context);
  86.         if (null !== $data && !\is_scalar($data)) {
  87.             $root = $dom->createElement($xmlRootNodeName);
  88.             $dom->appendChild($root);
  89.             $this->buildXml($root, $data, $format, $context, $xmlRootNodeName);
  90.         } else {
  91.             $this->appendNode($dom, $data, $format, $context, $xmlRootNodeName);
  92.         }
  94.         return $dom->saveXML($ignorePiNode ? $dom->documentElement : null);
  95.     }
  97.     /**
  98.      * {@inheritdoc}
  99.      */
  100.     public function decode(string $data, string $format, array $context = []): mixed
  101.     {
  102.         if ('' === trim($data)) {
  103.             throw new NotEncodableValueException('Invalid XML data, it cannot be empty.');
  104.         }
  106.         $internalErrors = libxml_use_internal_errors(true);
  107.         libxml_clear_errors();
  109.         $dom = new \DOMDocument();
  110.         $dom->loadXML($data, $context[self::LOAD_OPTIONS] ?? $this->defaultContext[self::LOAD_OPTIONS]);
  112.         libxml_use_internal_errors($internalErrors);
  114.         if ($error = libxml_get_last_error()) {
  115.             libxml_clear_errors();
  117.             throw new NotEncodableValueException($error->message);
  118.         }
  120.         $rootNode = null;
  121.         $decoderIgnoredNodeTypes = $context[self::DECODER_IGNORED_NODE_TYPES] ?? $this->defaultContext[self::DECODER_IGNORED_NODE_TYPES];
  122.         foreach ($dom->childNodes as $child) {
  123.             if (\in_array($child->nodeType, $decoderIgnoredNodeTypes, true)) {
  124.                 continue;
  125.             }
  126.             if (\XML_DOCUMENT_TYPE_NODE === $child->nodeType) {
  127.                 throw new NotEncodableValueException('Document types are not allowed.');
  128.             }
  129.             if (!$rootNode) {
  130.                 $rootNode = $child;
  131.             }
  132.         }
  134.         // todo: throw an exception if the root node name is not correctly configured (bc)
  136.         if ($rootNode->hasChildNodes()) {
  137.             $xpath = new \DOMXPath($dom);
  138.             $data = [];
  139.             foreach ($xpath->query('namespace::*', $dom->documentElement) as $nsNode) {
  140.                 $data['@'.$nsNode->nodeName] = $nsNode->nodeValue;
  141.             }
  143.             unset($data['@xmlns:xml']);
  145.             if (empty($data)) {
  146.                 return $this->parseXml($rootNode, $context);
  147.             }
  149.             return array_merge($data, (array) $this->parseXml($rootNode, $context));
  150.         }
  152.         if (!$rootNode->hasAttributes()) {
  153.             return $rootNode->nodeValue;
  154.         }
  156.         $data = [];
  158.         foreach ($rootNode->attributes as $attrKey => $attr) {
  159.             $data['@'.$attrKey] = $attr->nodeValue;
  160.         }
  162.         $data['#'] = $rootNode->nodeValue;
  164.         return $data;
  165.     }
  167.     /**
  168.      * {@inheritdoc}
  169.      */
  170.     public function supportsEncoding(string $format): bool
  171.     {
  172.         return self::FORMAT === $format;
  173.     }
  175.     /**
  176.      * {@inheritdoc}
  177.      */
  178.     public function supportsDecoding(string $format): bool
  179.     {
  180.         return self::FORMAT === $format;
  181.     }
  183.     final protected function appendXMLString(\DOMNode $node, string $val): bool
  184.     {
  185.         if ('' !== $val) {
  186.             $frag = $node->ownerDocument->createDocumentFragment();
  187.             $frag->appendXML($val);
  188.             $node->appendChild($frag);
  190.             return true;
  191.         }
  193.         return false;
  194.     }
  196.     final protected function appendText(\DOMNode $node, string $val): bool
  197.     {
  198.         $nodeText = $node->ownerDocument->createTextNode($val);
  199.         $node->appendChild($nodeText);
  201.         return true;
  202.     }
  204.     final protected function appendCData(\DOMNode $node, string $val): bool
  205.     {
  206.         $nodeText = $node->ownerDocument->createCDATASection($val);
  207.         $node->appendChild($nodeText);
  209.         return true;
  210.     }
  212.     final protected function appendDocumentFragment(\DOMNode $node, \DOMDocumentFragment $fragment): bool
  213.     {
  214.         if ($fragment instanceof \DOMDocumentFragment) {
  215.             $node->appendChild($fragment);
  217.             return true;
  218.         }
  220.         return false;
  221.     }
  223.     final protected function appendComment(\DOMNode $node, string $data): bool
  224.     {
  225.         $node->appendChild($node->ownerDocument->createComment($data));
  227.         return true;
  228.     }
  230.     /**
  231.      * Checks the name is a valid xml element name.
  232.      */
  233.     final protected function isElementNameValid(string $name): bool
  234.     {
  235.         return $name &&
  236.             !str_contains($name, ' ') &&
  237.             preg_match('#^[\pL_][\pL0-9._:-]*$#ui', $name);
  238.     }
  240.     /**
  241.      * Parse the input DOMNode into an array or a string.
  242.      */
  243.     private function parseXml(\DOMNode $node, array $context = []): array|string
  244.     {
  245.         $data = $this->parseXmlAttributes($node, $context);
  247.         $value = $this->parseXmlValue($node, $context);
  249.         if (!\count($data)) {
  250.             return $value;
  251.         }
  253.         if (!\is_array($value)) {
  254.             $data['#'] = $value;
  256.             return $data;
  257.         }
  259.         if (1 === \count($value) && key($value)) {
  260.             $data[key($value)] = current($value);
  262.             return $data;
  263.         }
  265.         foreach ($value as $key => $val) {
  266.             $data[$key] = $val;
  267.         }
  269.         return $data;
  270.     }
  272.     /**
  273.      * Parse the input DOMNode attributes into an array.
  274.      */
  275.     private function parseXmlAttributes(\DOMNode $node, array $context = []): array
  276.     {
  277.         if (!$node->hasAttributes()) {
  278.             return [];
  279.         }
  281.         $data = [];
  282.         $typeCastAttributes = (bool) ($context[self::TYPE_CAST_ATTRIBUTES] ?? $this->defaultContext[self::TYPE_CAST_ATTRIBUTES]);
  284.         foreach ($node->attributes as $attr) {
  285.             if (!is_numeric($attr->nodeValue) || !$typeCastAttributes || (isset($attr->nodeValue[1]) && '0' === $attr->nodeValue[0] && '.' !== $attr->nodeValue[1])) {
  286.                 $data['@'.$attr->nodeName] = $attr->nodeValue;
  288.                 continue;
  289.             }
  291.             if (false !== $val = filter_var($attr->nodeValue, \FILTER_VALIDATE_INT)) {
  292.                 $data['@'.$attr->nodeName] = $val;
  294.                 continue;
  295.             }
  297.             $data['@'.$attr->nodeName] = (float) $attr->nodeValue;
  298.         }
  300.         return $data;
  301.     }
  303.     /**
  304.      * Parse the input DOMNode value (content and children) into an array or a string.
  305.      */
  306.     private function parseXmlValue(\DOMNode $node, array $context = []): array|string
  307.     {
  308.         if (!$node->hasChildNodes()) {
  309.             return $node->nodeValue;
  310.         }
  312.         if (1 === $node->childNodes->length && \in_array($node->firstChild->nodeType, [\XML_TEXT_NODE, \XML_CDATA_SECTION_NODE])) {
  313.             return $node->firstChild->nodeValue;
  314.         }
  316.         $value = [];
  317.         $decoderIgnoredNodeTypes = $context[self::DECODER_IGNORED_NODE_TYPES] ?? $this->defaultContext[self::DECODER_IGNORED_NODE_TYPES];
  318.         foreach ($node->childNodes as $subnode) {
  319.             if (\in_array($subnode->nodeType, $decoderIgnoredNodeTypes, true)) {
  320.                 continue;
  321.             }
  323.             $val = $this->parseXml($subnode, $context);
  325.             if ('item' === $subnode->nodeName && isset($val['@key'])) {
  326.                 $value[$val['@key']] = $val['#'] ?? $val;
  327.             } else {
  328.                 $value[$subnode->nodeName][] = $val;
  329.             }
  330.         }
  332.         $asCollection = $context[self::AS_COLLECTION] ?? $this->defaultContext[self::AS_COLLECTION];
  333.         foreach ($value as $key => $val) {
  334.             if (!$asCollection && \is_array($val) && 1 === \count($val)) {
  335.                 $value[$key] = current($val);
  336.             }
  337.         }
  339.         return $value;
  340.     }
  342.     /**
  343.      * Parse the data and convert it to DOMElements.
  344.      *
  345.      * @throws NotEncodableValueException
  346.      */
  347.     private function buildXml(\DOMNode $parentNode, mixed $data, string $format, array $context, string $xmlRootNodeName = null): bool
  348.     {
  349.         $append = true;
  350.         $removeEmptyTags = $context[self::REMOVE_EMPTY_TAGS] ?? $this->defaultContext[self::REMOVE_EMPTY_TAGS] ?? false;
  351.         $encoderIgnoredNodeTypes = $context[self::ENCODER_IGNORED_NODE_TYPES] ?? $this->defaultContext[self::ENCODER_IGNORED_NODE_TYPES];
  353.         if (\is_array($data) || ($data instanceof \Traversable && (null === $this->serializer || !$this->serializer->supportsNormalization($data, $format)))) {
  354.             foreach ($data as $key => $data) {
  355.                 // Ah this is the magic @ attribute types.
  356.                 if (str_starts_with($key, '@') && $this->isElementNameValid($attributeName = substr($key, 1))) {
  357.                     if (!\is_scalar($data)) {
  358.                         $data = $this->serializer->normalize($data, $format, $context);
  359.                     }
  360.                     if (\is_bool($data)) {
  361.                         $data = (int) $data;
  362.                     }
  363.                     $parentNode->setAttribute($attributeName, $data);
  364.                 } elseif ('#' === $key) {
  365.                     $append = $this->selectNodeType($parentNode, $data, $format, $context);
  366.                 } elseif ('#comment' === $key) {
  367.                     if (!\in_array(\XML_COMMENT_NODE, $encoderIgnoredNodeTypes, true)) {
  368.                         $append = $this->appendComment($parentNode, $data);
  369.                     }
  370.                 } elseif (\is_array($data) && false === is_numeric($key)) {
  371.                     // Is this array fully numeric keys?
  372.                     if (ctype_digit(implode('', array_keys($data)))) {
  373.                         /*
  374.                          * Create nodes to append to $parentNode based on the $key of this array
  375.                          * Produces <xml><item>0</item><item>1</item></xml>
  376.                          * From ["item" => [0,1]];.
  377.                          */
  378.                         foreach ($data as $subData) {
  379.                             $append = $this->appendNode($parentNode, $subData, $format, $context, $key);
  380.                         }
  381.                     } else {
  382.                         $append = $this->appendNode($parentNode, $data, $format, $context, $key);
  383.                     }
  384.                 } elseif (is_numeric($key) || !$this->isElementNameValid($key)) {
  385.                     $append = $this->appendNode($parentNode, $data, $format, $context, 'item', $key);
  386.                 } elseif (null !== $data || !$removeEmptyTags) {
  387.                     $append = $this->appendNode($parentNode, $data, $format, $context, $key);
  388.                 }
  389.             }
  391.             return $append;
  392.         }
  394.         if (\is_object($data)) {
  395.             if (null === $this->serializer) {
  396.                 throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));
  397.             }
  399.             $data = $this->serializer->normalize($data, $format, $context);
  400.             if (null !== $data && !\is_scalar($data)) {
  401.                 return $this->buildXml($parentNode, $data, $format, $context, $xmlRootNodeName);
  402.             }
  404.             // top level data object was normalized into a scalar
  405.             if (!$parentNode->parentNode->parentNode) {
  406.                 $root = $parentNode->parentNode;
  407.                 $root->removeChild($parentNode);
  409.                 return $this->appendNode($root, $data, $format, $context, $xmlRootNodeName);
  410.             }
  412.             return $this->appendNode($parentNode, $data, $format, $context, 'data');
  413.         }
  415.         throw new NotEncodableValueException('An unexpected value could not be serialized: '.(!\is_resource($data) ? var_export($data, true) : sprintf('%s resource', get_resource_type($data))));
  416.     }
  418.     /**
  419.      * Selects the type of node to create and appends it to the parent.
  420.      */
  421.     private function appendNode(\DOMNode $parentNode, mixed $data, string $format, array $context, string $nodeName, string $key = null): bool
  422.     {
  423.         $dom = $parentNode instanceof \DOMDocument ? $parentNode : $parentNode->ownerDocument;
  424.         $node = $dom->createElement($nodeName);
  425.         if (null !== $key) {
  426.             $node->setAttribute('key', $key);
  427.         }
  428.         $appendNode = $this->selectNodeType($node, $data, $format, $context);
  429.         // we may have decided not to append this node, either in error or if its $nodeName is not valid
  430.         if ($appendNode) {
  431.             $parentNode->appendChild($node);
  432.         }
  434.         return $appendNode;
  435.     }
  437.     /**
  438.      * Checks if a value contains any characters which would require CDATA wrapping.
  439.      */
  440.     private function needsCdataWrapping(string $val): bool
  441.     {
  442.         return preg_match('/[<>&]/', $val);
  443.     }
  445.     /**
  446.      * Tests the value being passed and decide what sort of element to create.
  447.      *
  448.      * @throws NotEncodableValueException
  449.      */
  450.     private function selectNodeType(\DOMNode $node, mixed $val, string $format, array $context): bool
  451.     {
  452.         if (\is_array($val)) {
  453.             return $this->buildXml($node, $val, $format, $context);
  454.         } elseif ($val instanceof \SimpleXMLElement) {
  455.             $child = $node->ownerDocument->importNode(dom_import_simplexml($val), true);
  456.             $node->appendChild($child);
  457.         } elseif ($val instanceof \Traversable) {
  458.             $this->buildXml($node, $val, $format, $context);
  459.         } elseif ($val instanceof \DOMNode) {
  460.             $child = $node->ownerDocument->importNode($val, true);
  461.             $node->appendChild($child);
  462.         } elseif (\is_object($val)) {
  463.             if (null === $this->serializer) {
  464.                 throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));
  465.             }
  467.             return $this->selectNodeType($node, $this->serializer->normalize($val, $format, $context), $format, $context);
  468.         } elseif (is_numeric($val)) {
  469.             return $this->appendText($node, (string) $val);
  470.         } elseif (\is_string($val) && $this->needsCdataWrapping($val)) {
  471.             return $this->appendCData($node, $val);
  472.         } elseif (\is_string($val)) {
  473.             return $this->appendText($node, $val);
  474.         } elseif (\is_bool($val)) {
  475.             return $this->appendText($node, (int) $val);
  476.         }
  478.         return true;
  479.     }
  481.     /**
  482.      * Create a DOM document, taking serializer options into account.
  483.      */
  484.     private function createDomDocument(array $context): \DOMDocument
  485.     {
  486.         $document = new \DOMDocument();
  488.         // Set an attribute on the DOM document specifying, as part of the XML declaration,
  489.         $xmlOptions = [
  490.             // nicely formats output with indentation and extra space
  491.             self::FORMAT_OUTPUT => 'formatOutput',
  492.             // the version number of the document
  493.             self::VERSION => 'xmlVersion',
  494.             // the encoding of the document
  495.             self::ENCODING => 'encoding',
  496.             // whether the document is standalone
  497.             self::STANDALONE => 'xmlStandalone',
  498.         ];
  499.         foreach ($xmlOptions as $xmlOption => $documentProperty) {
  500.             if ($contextOption = $context[$xmlOption] ?? $this->defaultContext[$xmlOption] ?? false) {
  501.                 $document->$documentProperty = $contextOption;
  502.             }
  503.         }
  505.         return $document;
  506.     }
  507. }