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 <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.     /**
  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.      * @param array $context
  171.      */
  172.     public function supportsEncoding(string $format /*, array $context = [] */): bool
  173.     {
  174.         return self::FORMAT === $format;
  175.     }
  177.     /**
  178.      * {@inheritdoc}
  179.      *
  180.      * @param array $context
  181.      */
  182.     public function supportsDecoding(string $format /*, array $context = [] */): bool
  183.     {
  184.         return self::FORMAT === $format;
  185.     }
  187.     final protected function appendXMLString(\DOMNode $node, string $val): bool
  188.     {
  189.         if ('' !== $val) {
  190.             $frag = $node->ownerDocument->createDocumentFragment();
  191.             $frag->appendXML($val);
  192.             $node->appendChild($frag);
  194.             return true;
  195.         }
  197.         return false;
  198.     }
  200.     final protected function appendText(\DOMNode $node, string $val): bool
  201.     {
  202.         $nodeText = $node->ownerDocument->createTextNode($val);
  203.         $node->appendChild($nodeText);
  205.         return true;
  206.     }
  208.     final protected function appendCData(\DOMNode $node, string $val): bool
  209.     {
  210.         $nodeText = $node->ownerDocument->createCDATASection($val);
  211.         $node->appendChild($nodeText);
  213.         return true;
  214.     }
  216.     final protected function appendDocumentFragment(\DOMNode $node, \DOMDocumentFragment $fragment): bool
  217.     {
  218.         if ($fragment instanceof \DOMDocumentFragment) {
  219.             $node->appendChild($fragment);
  221.             return true;
  222.         }
  224.         return false;
  225.     }
  227.     final protected function appendComment(\DOMNode $node, string $data): bool
  228.     {
  229.         $node->appendChild($node->ownerDocument->createComment($data));
  231.         return true;
  232.     }
  234.     /**
  235.      * Checks the name is a valid xml element name.
  236.      */
  237.     final protected function isElementNameValid(string $name): bool
  238.     {
  239.         return $name &&
  240.             !str_contains($name, ' ') &&
  241.             preg_match('#^[\pL_][\pL0-9._:-]*$#ui', $name);
  242.     }
  244.     /**
  245.      * Parse the input DOMNode into an array or a string.
  246.      */
  247.     private function parseXml(\DOMNode $node, array $context = []): array|string
  248.     {
  249.         $data = $this->parseXmlAttributes($node, $context);
  251.         $value = $this->parseXmlValue($node, $context);
  253.         if (!\count($data)) {
  254.             return $value;
  255.         }
  257.         if (!\is_array($value)) {
  258.             $data['#'] = $value;
  260.             return $data;
  261.         }
  263.         if (1 === \count($value) && key($value)) {
  264.             $data[key($value)] = current($value);
  266.             return $data;
  267.         }
  269.         foreach ($value as $key => $val) {
  270.             $data[$key] = $val;
  271.         }
  273.         return $data;
  274.     }
  276.     /**
  277.      * Parse the input DOMNode attributes into an array.
  278.      */
  279.     private function parseXmlAttributes(\DOMNode $node, array $context = []): array
  280.     {
  281.         if (!$node->hasAttributes()) {
  282.             return [];
  283.         }
  285.         $data = [];
  286.         $typeCastAttributes = (bool) ($context[self::TYPE_CAST_ATTRIBUTES] ?? $this->defaultContext[self::TYPE_CAST_ATTRIBUTES]);
  288.         foreach ($node->attributes as $attr) {
  289.             if (!is_numeric($attr->nodeValue) || !$typeCastAttributes || (isset($attr->nodeValue[1]) && '0' === $attr->nodeValue[0] && '.' !== $attr->nodeValue[1])) {
  290.                 $data['@'.$attr->nodeName] = $attr->nodeValue;
  292.                 continue;
  293.             }
  295.             if (false !== $val = filter_var($attr->nodeValue, \FILTER_VALIDATE_INT)) {
  296.                 $data['@'.$attr->nodeName] = $val;
  298.                 continue;
  299.             }
  301.             $data['@'.$attr->nodeName] = (float) $attr->nodeValue;
  302.         }
  304.         return $data;
  305.     }
  307.     /**
  308.      * Parse the input DOMNode value (content and children) into an array or a string.
  309.      */
  310.     private function parseXmlValue(\DOMNode $node, array $context = []): array|string
  311.     {
  312.         if (!$node->hasChildNodes()) {
  313.             return $node->nodeValue;
  314.         }
  316.         if (1 === $node->childNodes->length && \in_array($node->firstChild->nodeType, [\XML_TEXT_NODE, \XML_CDATA_SECTION_NODE])) {
  317.             return $node->firstChild->nodeValue;
  318.         }
  320.         $value = [];
  321.         $decoderIgnoredNodeTypes = $context[self::DECODER_IGNORED_NODE_TYPES] ?? $this->defaultContext[self::DECODER_IGNORED_NODE_TYPES];
  322.         foreach ($node->childNodes as $subnode) {
  323.             if (\in_array($subnode->nodeType, $decoderIgnoredNodeTypes, true)) {
  324.                 continue;
  325.             }
  327.             $val = $this->parseXml($subnode, $context);
  329.             if ('item' === $subnode->nodeName && isset($val['@key'])) {
  330.                 $value[$val['@key']] = $val['#'] ?? $val;
  331.             } else {
  332.                 $value[$subnode->nodeName][] = $val;
  333.             }
  334.         }
  336.         $asCollection = $context[self::AS_COLLECTION] ?? $this->defaultContext[self::AS_COLLECTION];
  337.         foreach ($value as $key => $val) {
  338.             if (!$asCollection && \is_array($val) && 1 === \count($val)) {
  339.                 $value[$key] = current($val);
  340.             }
  341.         }
  343.         return $value;
  344.     }
  346.     /**
  347.      * Parse the data and convert it to DOMElements.
  348.      *
  349.      * @throws NotEncodableValueException
  350.      */
  351.     private function buildXml(\DOMNode $parentNode, mixed $data, string $format, array $context, string $xmlRootNodeName = null): bool
  352.     {
  353.         $append = true;
  354.         $removeEmptyTags = $context[self::REMOVE_EMPTY_TAGS] ?? $this->defaultContext[self::REMOVE_EMPTY_TAGS] ?? false;
  355.         $encoderIgnoredNodeTypes = $context[self::ENCODER_IGNORED_NODE_TYPES] ?? $this->defaultContext[self::ENCODER_IGNORED_NODE_TYPES];
  357.         if (\is_array($data) || ($data instanceof \Traversable && (null === $this->serializer || !$this->serializer->supportsNormalization($data, $format)))) {
  358.             foreach ($data as $key => $data) {
  359.                 //Ah this is the magic @ attribute types.
  360.                 if (str_starts_with($key, '@') && $this->isElementNameValid($attributeName = substr($key, 1))) {
  361.                     if (!is_scalar($data)) {
  362.                         $data = $this->serializer->normalize($data, $format, $context);
  363.                     }
  364.                     $parentNode->setAttribute($attributeName, $data);
  365.                 } elseif ('#' === $key) {
  366.                     $append = $this->selectNodeType($parentNode, $data, $format, $context);
  367.                 } elseif ('#comment' === $key) {
  368.                     if (!\in_array(\XML_COMMENT_NODE, $encoderIgnoredNodeTypes, true)) {
  369.                         $append = $this->appendComment($parentNode, $data);
  370.                     }
  371.                 } elseif (\is_array($data) && false === is_numeric($key)) {
  372.                     // Is this array fully numeric keys?
  373.                     if (ctype_digit(implode('', array_keys($data)))) {
  374.                         /*
  375.                          * Create nodes to append to $parentNode based on the $key of this array
  376.                          * Produces <xml><item>0</item><item>1</item></xml>
  377.                          * From ["item" => [0,1]];.
  378.                          */
  379.                         foreach ($data as $subData) {
  380.                             $append = $this->appendNode($parentNode, $subData, $format, $context, $key);
  381.                         }
  382.                     } else {
  383.                         $append = $this->appendNode($parentNode, $data, $format, $context, $key);
  384.                     }
  385.                 } elseif (is_numeric($key) || !$this->isElementNameValid($key)) {
  386.                     $append = $this->appendNode($parentNode, $data, $format, $context, 'item', $key);
  387.                 } elseif (null !== $data || !$removeEmptyTags) {
  388.                     $append = $this->appendNode($parentNode, $data, $format, $context, $key);
  389.                 }
  390.             }
  392.             return $append;
  393.         }
  395.         if (\is_object($data)) {
  396.             if (null === $this->serializer) {
  397.                 throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));
  398.             }
  400.             $data = $this->serializer->normalize($data, $format, $context);
  401.             if (null !== $data && !is_scalar($data)) {
  402.                 return $this->buildXml($parentNode, $data, $format, $context, $xmlRootNodeName);
  403.             }
  405.             // top level data object was normalized into a scalar
  406.             if (!$parentNode->parentNode->parentNode) {
  407.                 $root = $parentNode->parentNode;
  408.                 $root->removeChild($parentNode);
  410.                 return $this->appendNode($root, $data, $format, $context, $xmlRootNodeName);
  411.             }
  413.             return $this->appendNode($parentNode, $data, $format, $context, 'data');
  414.         }
  416.         throw new NotEncodableValueException('An unexpected value could not be serialized: '.(!\is_resource($data) ? var_export($data, true) : sprintf('%s resource', get_resource_type($data))));
  417.     }
  419.     /**
  420.      * Selects the type of node to create and appends it to the parent.
  421.      */
  422.     private function appendNode(\DOMNode $parentNode, mixed $data, string $format, array $context, string $nodeName, string $key = null): bool
  423.     {
  424.         $dom = $parentNode instanceof \DomDocument ? $parentNode : $parentNode->ownerDocument;
  425.         $node = $dom->createElement($nodeName);
  426.         if (null !== $key) {
  427.             $node->setAttribute('key', $key);
  428.         }
  429.         $appendNode = $this->selectNodeType($node, $data, $format, $context);
  430.         // we may have decided not to append this node, either in error or if its $nodeName is not valid
  431.         if ($appendNode) {
  432.             $parentNode->appendChild($node);
  433.         }
  435.         return $appendNode;
  436.     }
  438.     /**
  439.      * Checks if a value contains any characters which would require CDATA wrapping.
  440.      */
  441.     private function needsCdataWrapping(string $val): bool
  442.     {
  443.         return preg_match('/[<>&]/', $val);
  444.     }
  446.     /**
  447.      * Tests the value being passed and decide what sort of element to create.
  448.      *
  449.      * @throws NotEncodableValueException
  450.      */
  451.     private function selectNodeType(\DOMNode $node, mixed $val, string $format, array $context): bool
  452.     {
  453.         if (\is_array($val)) {
  454.             return $this->buildXml($node, $val, $format, $context);
  455.         } elseif ($val instanceof \SimpleXMLElement) {
  456.             $child = $node->ownerDocument->importNode(dom_import_simplexml($val), true);
  457.             $node->appendChild($child);
  458.         } elseif ($val instanceof \Traversable) {
  459.             $this->buildXml($node, $val, $format, $context);
  460.         } elseif ($val instanceof \DOMNode) {
  461.             $child = $node->ownerDocument->importNode($val, true);
  462.             $node->appendChild($child);
  463.         } elseif (\is_object($val)) {
  464.             if (null === $this->serializer) {
  465.                 throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));
  466.             }
  468.             return $this->selectNodeType($node, $this->serializer->normalize($val, $format, $context), $format, $context);
  469.         } elseif (is_numeric($val)) {
  470.             return $this->appendText($node, (string) $val);
  471.         } elseif (\is_string($val) && $this->needsCdataWrapping($val)) {
  472.             return $this->appendCData($node, $val);
  473.         } elseif (\is_string($val)) {
  474.             return $this->appendText($node, $val);
  475.         } elseif (\is_bool($val)) {
  476.             return $this->appendText($node, (int) $val);
  477.         }
  479.         return true;
  480.     }
  482.     /**
  483.      * Create a DOM document, taking serializer options into account.
  484.      */
  485.     private function createDomDocument(array $context): \DOMDocument
  486.     {
  487.         $document = new \DOMDocument();
  489.         // Set an attribute on the DOM document specifying, as part of the XML declaration,
  490.         $xmlOptions = [
  491.             // nicely formats output with indentation and extra space
  492.             self::FORMAT_OUTPUT => 'formatOutput',
  493.             // the version number of the document
  494.             self::VERSION => 'xmlVersion',
  495.             // the encoding of the document
  496.             self::ENCODING => 'encoding',
  497.             // whether the document is standalone
  498.             self::STANDALONE => 'xmlStandalone',
  499.         ];
  500.         foreach ($xmlOptions as $xmlOption => $documentProperty) {
  501.             if ($contextOption = $context[$xmlOption] ?? $this->defaultContext[$xmlOption] ?? false) {
  502.                 $document->$documentProperty = $contextOption;
  503.             }
  504.         }
  506.         return $document;
  507.     }
  508. }