vendor/api-platform/core/src/Core/Metadata/Extractor/XmlExtractor.php line 102

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the API Platform project.
  5.  *
  6.  * (c) Kévin Dunglas <dunglas@gmail.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. declare(strict_types=1);
  14. namespace ApiPlatform\Core\Metadata\Extractor;
  16. use ApiPlatform\Exception\InvalidArgumentException;
  17. use ApiPlatform\Metadata\Extractor\AbstractResourceExtractor;
  18. use ApiPlatform\Metadata\Extractor\PropertyExtractorInterface;
  19. use ApiPlatform\Metadata\Extractor\XmlPropertyExtractor;
  20. use ApiPlatform\Metadata\Extractor\XmlResourceExtractor;
  21. use Symfony\Component\Config\Util\XmlUtils;
  23. /**
  24.  * Extracts an array of metadata from a list of XML files.
  25.  *
  26.  * @author Kévin Dunglas <dunglas@gmail.com>
  27.  * @author Antoine Bluchet <soyuka@gmail.com>
  28.  * @author Baptiste Meyer <baptiste.meyer@gmail.com>
  29.  * @author Vincent Chalamon <vincentchalamon@gmail.com>
  30.  *
  31.  * @deprecated since 2.7, to remove in 3.0 (replaced by ApiPlatform\Metadata\Extractor\XmlExtractor)
  32.  */
  33. final class XmlExtractor extends AbstractResourceExtractor implements PropertyExtractorInterface
  34. {
  35.     public const RESOURCE_SCHEMA = __DIR__.'/../schema/metadata.xsd';
  37.     private $properties;
  39.     /**
  40.      * {@inheritdoc}
  41.      */
  42.     public function getProperties(): array
  43.     {
  44.         if (null !== $this->properties) {
  45.             return $this->properties;
  46.         }
  48.         $this->properties = [];
  49.         foreach ($this->paths as $path) {
  50.             $this->extractPath($path);
  51.         }
  53.         return $this->properties;
  54.     }
  56.     /**
  57.      * {@inheritdoc}
  58.      */
  59.     protected function extractPath(string $path)
  60.     {
  61.         try {
  62.             /** @var \SimpleXMLElement $xml */
  63.             $xml = simplexml_import_dom(XmlUtils::loadFile($path, self::RESOURCE_SCHEMA));
  64.         } catch (\InvalidArgumentException $e) {
  65.             // Test if this is a new resource
  66.             try {
  67.                 $xml = XmlUtils::loadFile($path, XmlResourceExtractor::SCHEMA);
  69.                 return;
  70.             } catch (\InvalidArgumentException $newResourceException) {
  71.                 try {
  72.                     $xml = XmlUtils::loadFile($path, XmlPropertyExtractor::SCHEMA);
  74.                     return;
  75.                 } catch (\InvalidArgumentException $newPropertyException) {
  76.                     throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
  77.                 }
  78.             }
  79.         }
  81.         foreach ($xml->resource as $resource) {
  82.             $resourceClass = $this->resolve((string) $resource['class']);
  84.             $this->resources[$resourceClass] = [
  85.                 'shortName' => $this->phpizeAttribute($resource, 'shortName', 'string'),
  86.                 'description' => $this->phpizeAttribute($resource, 'description', 'string'),
  87.                 'iri' => $this->phpizeAttribute($resource, 'iri', 'string'),
  88.                 'itemOperations' => $this->extractOperations($resource, 'itemOperation'),
  89.                 'collectionOperations' => $this->extractOperations($resource, 'collectionOperation'),
  90.                 'subresourceOperations' => $this->extractOperations($resource, 'subresourceOperation'),
  91.                 'graphql' => $this->extractOperations($resource, 'operation'),
  92.                 'attributes' => $this->extractAttributes($resource, 'attribute') ?: null,
  93.                 'properties' => $this->extractProperties($resource) ?: null,
  94.             ];
  95.             $this->properties[$resourceClass] = $this->resources[$resourceClass]['properties'];
  96.         }
  97.     }
  99.     /**
  100.      * Returns the array containing configured operations. Returns NULL if there is no operation configuration.
  101.      */
  102.     private function extractOperations(\SimpleXMLElement $resource, string $operationType): ?array
  103.     {
  104.         $graphql = 'operation' === $operationType;
  105.         if (!$graphql && $legacyOperations = $this->extractAttributes($resource, $operationType)) {
  106.             @trigger_error(
  107.                 sprintf('Configuring "%1$s" tags without using a parent "%1$ss" tag is deprecated since API Platform 2.1 and will not be possible anymore in API Platform 3', $operationType),
  108.                 \E_USER_DEPRECATED
  109.             );
  111.             return $legacyOperations;
  112.         }
  114.         $operationsParent = $graphql ? 'graphql' : "{$operationType}s";
  115.         if (!isset($resource->{$operationsParent})) {
  116.             return null;
  117.         }
  119.         return $this->extractAttributes($resource->{$operationsParent}, $operationType, true);
  120.     }
  122.     /**
  123.      * Recursively transforms an attribute structure into an associative array.
  124.      */
  125.     private function extractAttributes(\SimpleXMLElement $resource, string $elementName, bool $topLevel = false): array
  126.     {
  127.         $attributes = [];
  128.         foreach ($resource->{$elementName} as $attribute) {
  129.             $value = isset($attribute->attribute[0]) ? $this->extractAttributes($attribute, 'attribute') : $this->phpizeContent($attribute);
  130.             // allow empty operations definition, like <collectionOperation name="post" />
  131.             if ($topLevel && '' === $value) {
  132.                 $value = [];
  133.             }
  134.             if (isset($attribute['name'])) {
  135.                 $attributes[(string) $attribute['name']] = $value;
  136.             } else {
  137.                 $attributes[] = $value;
  138.             }
  139.         }
  141.         return $attributes;
  142.     }
  144.     /**
  145.      * Gets metadata of a property.
  146.      */
  147.     private function extractProperties(\SimpleXMLElement $resource): array
  148.     {
  149.         $properties = [];
  150.         foreach ($resource->property as $property) {
  151.             $properties[(string) $property['name']] = [
  152.                 'description' => $this->phpizeAttribute($property, 'description', 'string'),
  153.                 'readable' => $this->phpizeAttribute($property, 'readable', 'bool'),
  154.                 'writable' => $this->phpizeAttribute($property, 'writable', 'bool'),
  155.                 'readableLink' => $this->phpizeAttribute($property, 'readableLink', 'bool'),
  156.                 'writableLink' => $this->phpizeAttribute($property, 'writableLink', 'bool'),
  157.                 'required' => $this->phpizeAttribute($property, 'required', 'bool'),
  158.                 'identifier' => $this->phpizeAttribute($property, 'identifier', 'bool'),
  159.                 'iri' => $this->phpizeAttribute($property, 'iri', 'string'),
  160.                 'attributes' => $this->extractAttributes($property, 'attribute'),
  161.                 'subresource' => $property->subresource ? [
  162.                     'collection' => $this->phpizeAttribute($property->subresource, 'collection', 'bool'),
  163.                     'resourceClass' => $this->resolve($this->phpizeAttribute($property->subresource, 'resourceClass', 'string')),
  164.                     'maxDepth' => $this->phpizeAttribute($property->subresource, 'maxDepth', 'integer'),
  165.                 ] : null,
  166.             ];
  167.         }
  169.         return $properties;
  170.     }
  172.     /**
  173.      * Transforms an XML attribute's value in a PHP value.
  174.      *
  175.      * @return string|int|bool|null
  176.      */
  177.     private function phpizeAttribute(\SimpleXMLElement $array, string $key, string $type)
  178.     {
  179.         if (!isset($array[$key])) {
  180.             return null;
  181.         }
  183.         switch ($type) {
  184.             case 'string':
  185.                 return (string) $array[$key];
  186.             case 'integer':
  187.                 return (int) $array[$key];
  188.             case 'bool':
  189.                 return (bool) XmlUtils::phpize($array[$key]);
  190.         }
  192.         return null;
  193.     }
  195.     /**
  196.      * Transforms an XML element's content in a PHP value.
  197.      */
  198.     private function phpizeContent(\SimpleXMLElement $array)
  199.     {
  200.         $type = $array['type'] ?? null;
  201.         $value = (string) $array;
  203.         switch ($type) {
  204.             case 'string':
  205.                 return $value;
  206.             case 'constant':
  207.                 return \constant($value);
  208.             default:
  209.                 return XmlUtils::phpize($value);
  210.         }
  211.     }
  212. }