Deprecated: Constant E_STRICT is deprecated in /home/normanv/www/annuairepro/vendor/symfony/error-handler/ErrorHandler.php on line 58

Deprecated: Constant E_STRICT is deprecated in /home/normanv/www/annuairepro/vendor/symfony/error-handler/ErrorHandler.php on line 76
Symfony Profiler

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

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($data, string $format, array $context = [])
  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 = [])
  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.         if (\LIBXML_VERSION < 20900) {
  108.             $disableEntities = libxml_disable_entity_loader(true);
  109.         }
  110.         libxml_clear_errors();
  112.         $dom = new \DOMDocument();
  113.         $dom->loadXML($data, $context[self::LOAD_OPTIONS] ?? $this->defaultContext[self::LOAD_OPTIONS]);
  115.         libxml_use_internal_errors($internalErrors);
  116.         if (\LIBXML_VERSION < 20900) {
  117.             libxml_disable_entity_loader($disableEntities);
  118.         }
  120.         if ($error = libxml_get_last_error()) {
  121.             libxml_clear_errors();
  123.             throw new NotEncodableValueException($error->message);
  124.         }
  126.         $rootNode = null;
  127.         $decoderIgnoredNodeTypes = $context[self::DECODER_IGNORED_NODE_TYPES] ?? $this->defaultContext[self::DECODER_IGNORED_NODE_TYPES];
  128.         foreach ($dom->childNodes as $child) {
  129.             if (\in_array($child->nodeType, $decoderIgnoredNodeTypes, true)) {
  130.                 continue;
  131.             }
  132.             if (\XML_DOCUMENT_TYPE_NODE === $child->nodeType) {
  133.                 throw new NotEncodableValueException('Document types are not allowed.');
  134.             }
  135.             if (!$rootNode) {
  136.                 $rootNode = $child;
  137.             }
  138.         }
  140.         // todo: throw an exception if the root node name is not correctly configured (bc)
  142.         if ($rootNode->hasChildNodes()) {
  143.             $xpath = new \DOMXPath($dom);
  144.             $data = [];
  145.             foreach ($xpath->query('namespace::*', $dom->documentElement) as $nsNode) {
  146.                 $data['@'.$nsNode->nodeName] = $nsNode->nodeValue;
  147.             }
  149.             unset($data['@xmlns:xml']);
  151.             if (empty($data)) {
  152.                 return $this->parseXml($rootNode, $context);
  153.             }
  155.             return array_merge($data, (array) $this->parseXml($rootNode, $context));
  156.         }
  158.         if (!$rootNode->hasAttributes()) {
  159.             return $rootNode->nodeValue;
  160.         }
  162.         return array_merge($this->parseXmlAttributes($rootNode, $context), ['#' => $rootNode->nodeValue]);
  163.     }
  165.     /**
  166.      * {@inheritdoc}
  167.      */
  168.     public function supportsEncoding(string $format)
  169.     {
  170.         return self::FORMAT === $format;
  171.     }
  173.     /**
  174.      * {@inheritdoc}
  175.      */
  176.     public function supportsDecoding(string $format)
  177.     {
  178.         return self::FORMAT === $format;
  179.     }
  181.     final protected function appendXMLString(\DOMNode $node, string $val): bool
  182.     {
  183.         if ('' !== $val) {
  184.             $frag = $node->ownerDocument->createDocumentFragment();
  185.             $frag->appendXML($val);
  186.             $node->appendChild($frag);
  188.             return true;
  189.         }
  191.         return false;
  192.     }
  194.     final protected function appendText(\DOMNode $node, string $val): bool
  195.     {
  196.         $nodeText = $node->ownerDocument->createTextNode($val);
  197.         $node->appendChild($nodeText);
  199.         return true;
  200.     }
  202.     final protected function appendCData(\DOMNode $node, string $val): bool
  203.     {
  204.         $nodeText = $node->ownerDocument->createCDATASection($val);
  205.         $node->appendChild($nodeText);
  207.         return true;
  208.     }
  210.     /**
  211.      * @param \DOMDocumentFragment $fragment
  212.      */
  213.     final protected function appendDocumentFragment(\DOMNode $node, $fragment): bool
  214.     {
  215.         if ($fragment instanceof \DOMDocumentFragment) {
  216.             $node->appendChild($fragment);
  218.             return true;
  219.         }
  221.         return false;
  222.     }
  224.     final protected function appendComment(\DOMNode $node, string $data): bool
  225.     {
  226.         $node->appendChild($node->ownerDocument->createComment($data));
  228.         return true;
  229.     }
  231.     /**
  232.      * Checks the name is a valid xml element name.
  233.      */
  234.     final protected function isElementNameValid(string $name): bool
  235.     {
  236.         return $name &&
  237.             !str_contains($name, ' ') &&
  238.             preg_match('#^[\pL_][\pL0-9._:-]*$#ui', $name);
  239.     }
  241.     /**
  242.      * Parse the input DOMNode into an array or a string.
  243.      *
  244.      * @return array|string
  245.      */
  246.     private function parseXml(\DOMNode $node, array $context = [])
  247.     {
  248.         $data = $this->parseXmlAttributes($node, $context);
  250.         $value = $this->parseXmlValue($node, $context);
  252.         if (!\count($data)) {
  253.             return $value;
  254.         }
  256.         if (!\is_array($value)) {
  257.             $data['#'] = $value;
  259.             return $data;
  260.         }
  262.         if (1 === \count($value) && key($value)) {
  263.             $data[key($value)] = current($value);
  265.             return $data;
  266.         }
  268.         foreach ($value as $key => $val) {
  269.             $data[$key] = $val;
  270.         }
  272.         return $data;
  273.     }
  275.     /**
  276.      * Parse the input DOMNode attributes into an array.
  277.      */
  278.     private function parseXmlAttributes(\DOMNode $node, array $context = []): array
  279.     {
  280.         if (!$node->hasAttributes()) {
  281.             return [];
  282.         }
  284.         $data = [];
  285.         $typeCastAttributes = (bool) ($context[self::TYPE_CAST_ATTRIBUTES] ?? $this->defaultContext[self::TYPE_CAST_ATTRIBUTES]);
  287.         foreach ($node->attributes as $attr) {
  288.             if (!is_numeric($attr->nodeValue) || !$typeCastAttributes || (isset($attr->nodeValue[1]) && '0' === $attr->nodeValue[0] && '.' !== $attr->nodeValue[1])) {
  289.                 $data['@'.$attr->nodeName] = $attr->nodeValue;
  291.                 continue;
  292.             }
  294.             if (false !== $val = filter_var($attr->nodeValue, \FILTER_VALIDATE_INT)) {
  295.                 $data['@'.$attr->nodeName] = $val;
  297.                 continue;
  298.             }
  300.             $data['@'.$attr->nodeName] = (float) $attr->nodeValue;
  301.         }
  303.         return $data;
  304.     }
  306.     /**
  307.      * Parse the input DOMNode value (content and children) into an array or a string.
  308.      *
  309.      * @return array|string
  310.      */
  311.     private function parseXmlValue(\DOMNode $node, array $context = [])
  312.     {
  313.         if (!$node->hasChildNodes()) {
  314.             return $node->nodeValue;
  315.         }
  317.         if (1 === $node->childNodes->length && \in_array($node->firstChild->nodeType, [\XML_TEXT_NODE, \XML_CDATA_SECTION_NODE])) {
  318.             return $node->firstChild->nodeValue;
  319.         }
  321.         $value = [];
  322.         $decoderIgnoredNodeTypes = $context[self::DECODER_IGNORED_NODE_TYPES] ?? $this->defaultContext[self::DECODER_IGNORED_NODE_TYPES];
  323.         foreach ($node->childNodes as $subnode) {
  324.             if (\in_array($subnode->nodeType, $decoderIgnoredNodeTypes, true)) {
  325.                 continue;
  326.             }
  328.             $val = $this->parseXml($subnode, $context);
  330.             if ('item' === $subnode->nodeName && isset($val['@key'])) {
  331.                 $value[$val['@key']] = $val['#'] ?? $val;
  332.             } else {
  333.                 $value[$subnode->nodeName][] = $val;
  334.             }
  335.         }
  337.         $asCollection = $context[self::AS_COLLECTION] ?? $this->defaultContext[self::AS_COLLECTION];
  338.         foreach ($value as $key => $val) {
  339.             if (!$asCollection && \is_array($val) && 1 === \count($val)) {
  340.                 $value[$key] = current($val);
  341.             }
  342.         }
  344.         return $value;
  345.     }
  347.     /**
  348.      * Parse the data and convert it to DOMElements.
  349.      *
  350.      * @param array|object $data
  351.      *
  352.      * @throws NotEncodableValueException
  353.      */
  354.     private function buildXml(\DOMNode $parentNode, $data, string $format, array $context, string $xmlRootNodeName = null): bool
  355.     {
  356.         $append = true;
  357.         $removeEmptyTags = $context[self::REMOVE_EMPTY_TAGS] ?? $this->defaultContext[self::REMOVE_EMPTY_TAGS] ?? false;
  358.         $encoderIgnoredNodeTypes = $context[self::ENCODER_IGNORED_NODE_TYPES] ?? $this->defaultContext[self::ENCODER_IGNORED_NODE_TYPES];
  360.         if (\is_array($data) || ($data instanceof \Traversable && (null === $this->serializer || !$this->serializer->supportsNormalization($data, $format)))) {
  361.             foreach ($data as $key => $data) {
  362.                 // Ah this is the magic @ attribute types.
  363.                 if (str_starts_with($key, '@') && $this->isElementNameValid($attributeName = substr($key, 1))) {
  364.                     if (!\is_scalar($data)) {
  365.                         $data = $this->serializer->normalize($data, $format, $context);
  366.                     }
  367.                     if (\is_bool($data)) {
  368.                         $data = (int) $data;
  369.                     }
  370.                     $parentNode->setAttribute($attributeName, $data);
  371.                 } elseif ('#' === $key) {
  372.                     $append = $this->selectNodeType($parentNode, $data, $format, $context);
  373.                 } elseif ('#comment' === $key) {
  374.                     if (!\in_array(\XML_COMMENT_NODE, $encoderIgnoredNodeTypes, true)) {
  375.                         $append = $this->appendComment($parentNode, $data);
  376.                     }
  377.                 } elseif (\is_array($data) && false === is_numeric($key)) {
  378.                     // Is this array fully numeric keys?
  379.                     if (ctype_digit(implode('', array_keys($data)))) {
  380.                         /*
  381.                          * Create nodes to append to $parentNode based on the $key of this array
  382.                          * Produces <xml><item>0</item><item>1</item></xml>
  383.                          * From ["item" => [0,1]];.
  384.                          */
  385.                         foreach ($data as $subData) {
  386.                             $append = $this->appendNode($parentNode, $subData, $format, $context, $key);
  387.                         }
  388.                     } else {
  389.                         $append = $this->appendNode($parentNode, $data, $format, $context, $key);
  390.                     }
  391.                 } elseif (is_numeric($key) || !$this->isElementNameValid($key)) {
  392.                     $append = $this->appendNode($parentNode, $data, $format, $context, 'item', $key);
  393.                 } elseif (null !== $data || !$removeEmptyTags) {
  394.                     $append = $this->appendNode($parentNode, $data, $format, $context, $key);
  395.                 }
  396.             }
  398.             return $append;
  399.         }
  401.         if (\is_object($data)) {
  402.             if (null === $this->serializer) {
  403.                 throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));
  404.             }
  406.             $data = $this->serializer->normalize($data, $format, $context);
  407.             if (null !== $data && !\is_scalar($data)) {
  408.                 return $this->buildXml($parentNode, $data, $format, $context, $xmlRootNodeName);
  409.             }
  411.             // top level data object was normalized into a scalar
  412.             if (!$parentNode->parentNode->parentNode) {
  413.                 $root = $parentNode->parentNode;
  414.                 $root->removeChild($parentNode);
  416.                 return $this->appendNode($root, $data, $format, $context, $xmlRootNodeName);
  417.             }
  419.             return $this->appendNode($parentNode, $data, $format, $context, 'data');
  420.         }
  422.         throw new NotEncodableValueException('An unexpected value could not be serialized: '.(!\is_resource($data) ? var_export($data, true) : sprintf('%s resource', get_resource_type($data))));
  423.     }
  425.     /**
  426.      * Selects the type of node to create and appends it to the parent.
  427.      *
  428.      * @param array|object $data
  429.      */
  430.     private function appendNode(\DOMNode $parentNode, $data, string $format, array $context, string $nodeName, string $key = null): bool
  431.     {
  432.         $dom = $parentNode instanceof \DOMDocument ? $parentNode : $parentNode->ownerDocument;
  433.         $node = $dom->createElement($nodeName);
  434.         if (null !== $key) {
  435.             $node->setAttribute('key', $key);
  436.         }
  437.         $appendNode = $this->selectNodeType($node, $data, $format, $context);
  438.         // we may have decided not to append this node, either in error or if its $nodeName is not valid
  439.         if ($appendNode) {
  440.             $parentNode->appendChild($node);
  441.         }
  443.         return $appendNode;
  444.     }
  446.     /**
  447.      * Checks if a value contains any characters which would require CDATA wrapping.
  448.      */
  449.     private function needsCdataWrapping(string $val): bool
  450.     {
  451.         return preg_match('/[<>&]/', $val);
  452.     }
  454.     /**
  455.      * Tests the value being passed and decide what sort of element to create.
  456.      *
  457.      * @throws NotEncodableValueException
  458.      */
  459.     private function selectNodeType(\DOMNode $node, $val, string $format, array $context): bool
  460.     {
  461.         if (\is_array($val)) {
  462.             return $this->buildXml($node, $val, $format, $context);
  463.         } elseif ($val instanceof \SimpleXMLElement) {
  464.             $child = $node->ownerDocument->importNode(dom_import_simplexml($val), true);
  465.             $node->appendChild($child);
  466.         } elseif ($val instanceof \Traversable) {
  467.             $this->buildXml($node, $val, $format, $context);
  468.         } elseif ($val instanceof \DOMNode) {
  469.             $child = $node->ownerDocument->importNode($val, true);
  470.             $node->appendChild($child);
  471.         } elseif (\is_object($val)) {
  472.             if (null === $this->serializer) {
  473.                 throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));
  474.             }
  476.             return $this->selectNodeType($node, $this->serializer->normalize($val, $format, $context), $format, $context);
  477.         } elseif (is_numeric($val)) {
  478.             return $this->appendText($node, (string) $val);
  479.         } elseif (\is_string($val) && $this->needsCdataWrapping($val)) {
  480.             return $this->appendCData($node, $val);
  481.         } elseif (\is_string($val)) {
  482.             return $this->appendText($node, $val);
  483.         } elseif (\is_bool($val)) {
  484.             return $this->appendText($node, (int) $val);
  485.         }
  487.         return true;
  488.     }
  490.     /**
  491.      * Create a DOM document, taking serializer options into account.
  492.      */
  493.     private function createDomDocument(array $context): \DOMDocument
  494.     {
  495.         $document = new \DOMDocument();
  497.         // Set an attribute on the DOM document specifying, as part of the XML declaration,
  498.         $xmlOptions = [
  499.             // nicely formats output with indentation and extra space
  500.             self::FORMAT_OUTPUT => 'formatOutput',
  501.             // the version number of the document
  502.             self::VERSION => 'xmlVersion',
  503.             // the encoding of the document
  504.             self::ENCODING => 'encoding',
  505.             // whether the document is standalone
  506.             self::STANDALONE => 'xmlStandalone',
  507.         ];
  508.         foreach ($xmlOptions as $xmlOption => $documentProperty) {
  509.             if ($contextOption = $context[$xmlOption] ?? $this->defaultContext[$xmlOption] ?? false) {
  510.                 $document->$documentProperty = $contextOption;
  511.             }
  512.         }
  514.         return $document;
  515.     }
  516. }