vendor/friendsofsymfony/rest-bundle/Routing/Loader/RestXmlCollectionLoader.php line 14

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the FOSRestBundle package.
  5.  *
  6.  * (c) FriendsOfSymfony <http://friendsofsymfony.github.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 FOS\RestBundle\Routing\Loader;
  14. @trigger_error(sprintf('The %s\RestXmlCollectionLoader class is deprecated since FOSRestBundle 2.8.', __NAMESPACE__), E_USER_DEPRECATED);
  16. use FOS\RestBundle\Routing\RestRouteCollection;
  17. use Symfony\Component\Config\FileLocatorInterface;
  18. use Symfony\Component\Config\Util\XmlUtils;
  19. use Symfony\Component\Routing\Loader\XmlFileLoader;
  20. use Symfony\Component\Routing\RouteCollection;
  22. /**
  23.  * RestXmlCollectionLoader XML file collections loader.
  24.  *
  25.  * @author Donald Tyler <[email protected]>
  26.  *
  27.  * @deprecated since 2.8
  28.  */
  29. class RestXmlCollectionLoader extends XmlFileLoader
  30. {
  31.     protected $collectionParents = [];
  32.     private $processor;
  33.     private $includeFormat;
  34.     private $formats;
  35.     private $defaultFormat;
  37.     /**
  38.      * @param string[] $formats
  39.      */
  40.     public function __construct(
  41.         FileLocatorInterface $locator,
  42.         RestRouteProcessor $processor,
  43.         bool $includeFormat = true,
  44.         array $formats = [],
  45.         string $defaultFormat = null
  46.     ) {
  47.         parent::__construct($locator);
  49.         $this->processor = $processor;
  50.         $this->includeFormat = $includeFormat;
  51.         $this->formats = $formats;
  52.         $this->defaultFormat = $defaultFormat;
  53.     }
  55.     /**
  56.      * {@inheritdoc}
  57.      */
  58.     protected function parseNode(RouteCollection $collection, \DOMElement $node, $path, $file)
  59.     {
  60.         switch ($node->tagName) {
  61.             case 'route':
  62.                 $this->parseRoute($collection, $node, $path);
  64.                 break;
  65.             case 'import':
  66.                 $name = (string) $node->getAttribute('id');
  67.                 $resource = (string) $node->getAttribute('resource');
  68.                 $prefix = (string) $node->getAttribute('prefix');
  69.                 $namePrefix = (string) $node->getAttribute('name-prefix');
  70.                 $parent = (string) $node->getAttribute('parent');
  71.                 $type = (string) $node->getAttribute('type');
  72.                 $host = isset($config['host']) ? $config['host'] : null;
  73.                 $currentDir = dirname($path);
  75.                 $parents = [];
  76.                 if (!empty($parent)) {
  77.                     if (!isset($this->collectionParents[$parent])) {
  78.                         throw new \InvalidArgumentException(sprintf('Cannot find parent resource with name %s', $parent));
  79.                     }
  81.                     $parents = $this->collectionParents[$parent];
  82.                 }
  84.                 $imported = $this->processor->importResource($this, $resource, $parents, $prefix, $namePrefix, $type, $currentDir);
  86.                 if (!empty($name) && $imported instanceof RestRouteCollection) {
  87.                     $parents[] = (!empty($prefix) ? $prefix.'/' : '').$imported->getSingularName();
  88.                     $prefix = null;
  90.                     $this->collectionParents[$name] = $parents;
  91.                 }
  93.                 if (!empty($host)) {
  94.                     $imported->setHost($host);
  95.                 }
  97.                 $imported->addPrefix((string) $prefix);
  98.                 $collection->addCollection($imported);
  100.                 break;
  101.             default:
  102.                 throw new \InvalidArgumentException(sprintf('Unable to parse tag "%s"', $node->tagName));
  103.         }
  104.     }
  106.     /**
  107.      * {@inheritdoc}
  108.      */
  109.     protected function parseRoute(RouteCollection $collection, \DOMElement $node, $path)
  110.     {
  111.         if ($this->includeFormat) {
  112.             $path = $node->getAttribute('path');
  113.             // append format placeholder if not present
  114.             if (false === strpos($path, '{_format}')) {
  115.                 $node->setAttribute('path', $path.'.{_format}');
  116.             }
  118.             // set format requirement if configured globally
  119.             $requirements = $node->getElementsByTagNameNS(self::NAMESPACE_URI, 'requirement');
  120.             $format = null;
  121.             for ($i = 0; $i < $requirements->length; ++$i) {
  122.                 $item = $requirements->item($i);
  123.                 if ($item instanceof \DOMElement && $item->hasAttribute('_format')) {
  124.                     $format = $item->getAttribute('_format');
  126.                     break;
  127.                 }
  128.             }
  130.             if (null === $format && !empty($this->formats)) {
  131.                 $requirement = $node->ownerDocument->createElementNs(
  132.                     self::NAMESPACE_URI,
  133.                     'requirement',
  134.                     implode('|', array_keys($this->formats))
  135.                 );
  136.                 $requirement->setAttribute('key', '_format');
  137.                 $node->appendChild($requirement);
  138.             }
  139.         }
  141.         // set the default format if configured
  142.         if (null !== $this->defaultFormat) {
  143.             $defaultFormatNode = $node->ownerDocument->createElementNS(
  144.                 self::NAMESPACE_URI,
  145.                 'default',
  146.                 $this->defaultFormat
  147.             );
  148.             $defaultFormatNode->setAttribute('key', '_format');
  149.             $node->appendChild($defaultFormatNode);
  150.         }
  152.         $options = $this->getOptions($node);
  154.         foreach ($options as $option) {
  155.             $node->appendChild($option);
  156.         }
  158.         $length = $node->childNodes->length;
  159.         for ($i = 0; $i < $length; ++$i) {
  160.             $loopNode = $node->childNodes->item($i);
  161.             if (XML_TEXT_NODE === $loopNode->nodeType) {
  162.                 continue;
  163.             }
  165.             $newNode = $node->ownerDocument->createElementNS(
  166.                 self::NAMESPACE_URI,
  167.                 $loopNode->nodeName,
  168.                 $loopNode->nodeValue
  169.             );
  171.             foreach ($loopNode->attributes as $value) {
  172.                 $newNode->setAttribute($value->name, $value->value);
  173.             }
  175.             $node->appendChild($newNode);
  176.         }
  178.         parent::parseRoute($collection, $node, $path);
  179.     }
  181.     private function getOptions(\DOMElement $node)
  182.     {
  183.         $options = [];
  184.         foreach ($node->childNodes as $child) {
  185.             if ($child instanceof \DOMElement && 'option' === $child->tagName) {
  186.                 $option = $node->ownerDocument->createElementNs(
  187.                     self::NAMESPACE_URI,
  188.                     'option',
  189.                     $child->nodeValue
  190.                 );
  191.                 $option->setAttribute('key', $child->getAttribute('key'));
  192.                 $options[] = $option;
  193.             }
  194.         }
  196.         return $options;
  197.     }
  199.     /**
  200.      * {@inheritdoc}
  201.      */
  202.     public function supports($resource, $type = null)
  203.     {
  204.         return is_string($resource) &&
  205.             'xml' === pathinfo($resource, PATHINFO_EXTENSION) &&
  206.             'rest' === $type;
  207.     }
  209.     protected function validate(\DOMDocument $dom)
  210.     {
  211.         $restRoutinglocation = realpath(__DIR__.'/../../Resources/config/schema/routing/rest_routing-1.0.xsd');
  212.         $restRoutinglocation = rawurlencode(str_replace('\\', '/', $restRoutinglocation));
  213.         $routinglocation = realpath(__DIR__.'/../../Resources/config/schema/routing-1.0.xsd');
  214.         $routinglocation = rawurlencode(str_replace('\\', '/', $routinglocation));
  215.         $source = <<<EOF
  216. <?xml version="1.0" encoding="utf-8" ?>
  217. <xsd:schema xmlns="http://symfony.com/schema"
  218.     xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  219.     targetNamespace="http://symfony.com/schema"
  220.     elementFormDefault="qualified">
  222.     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
  223.     <xsd:import namespace="http://friendsofsymfony.github.com/schema/rest" schemaLocation="$restRoutinglocation" />
  224.     <xsd:import namespace="http://symfony.com/schema/routing" schemaLocation="$routinglocation" />
  225. </xsd:schema>
  226. EOF;
  228.         $current = libxml_use_internal_errors(true);
  229.         libxml_clear_errors();
  231.         if (!$dom->schemaValidateSource($source)) {
  232.             throw new \InvalidArgumentException(implode("\n", $this->getXmlErrors_($current)));
  233.         }
  234.         libxml_use_internal_errors($current);
  235.     }
  237.     /**
  238.      * {@inheritdoc}
  239.      *
  240.      * @internal
  241.      */
  242.     protected function loadFile($file)
  243.     {
  244.         if (class_exists(XmlUtils::class)) {
  245.             $dom = XmlUtils::loadFile($file);
  246.             $this->validate($dom);
  248.             return $dom;
  249.         }
  251.         return parent::loadFile($file);
  252.     }
  254.     /**
  255.      * Retrieves libxml errors and clears them.
  256.      *
  257.      * Note: The underscore postfix on the method name is to ensure compatibility with versions
  258.      *       before 2.0.16 while working around a bug in PHP https://bugs.php.net/bug.php?id=62956
  259.      */
  260.     private function getXmlErrors_(bool $internalErrors): array
  261.     {
  262.         $errors = [];
  263.         foreach (libxml_get_errors() as $error) {
  264.             $errors[] = sprintf(
  265.                 '[%s %s] %s (in %s - line %d, column %d)',
  266.                 LIBXML_ERR_WARNING === $error->level ? 'WARNING' : 'ERROR',
  267.                 $error->code,
  268.                 trim($error->message),
  269.                 $error->file ? $error->file : 'n/a',
  270.                 $error->line,
  271.                 $error->column
  272.             );
  273.         }
  275.         libxml_clear_errors();
  276.         libxml_use_internal_errors($internalErrors);
  278.         return $errors;
  279.     }
  280. }