class XmlFileLoader in Plug 7

Loads validation metadata from an XML file.

@author Bernhard Schussek <[e-mail]>

Hierarchy

• class \Symfony\Component\Validator\Mapping\Loader\AbstractLoader implements LoaderInterface
  • class \Symfony\Component\Validator\Mapping\Loader\FileLoader
    • class \Symfony\Component\Validator\Mapping\Loader\XmlFileLoader

2 files declare their use of XmlFileLoader

ValidatorBuilder.php in lib/Symfony/validator/Symfony/Component/Validator/ValidatorBuilder.php

XmlFileLoaderTest.php in lib/Symfony/validator/Symfony/Component/Validator/Tests/Mapping/Loader/XmlFileLoaderTest.php

File

lib/Symfony/validator/Symfony/Component/Validator/Mapping/Loader/XmlFileLoader.php, line 23

Namespace

Symfony\Component\Validator\Mapping\Loader

class XmlFileLoader extends FileLoader {

  /**
   * The XML nodes of the mapping file.
   *
   * @var \SimpleXMLElement[]|null
   */
  protected $classes;

  /**
   * {@inheritdoc}
   */
  public function loadClassMetadata(ClassMetadata $metadata) {
    if (null === $this->classes) {

      // This method may throw an exception. Do not modify the class'
      // state before it completes
      $xml = $this
        ->parseFile($this->file);
      $this->classes = array();
      foreach ($xml->namespace as $namespace) {
        $this
          ->addNamespaceAlias((string) $namespace['prefix'], trim((string) $namespace));
      }
      foreach ($xml->class as $class) {
        $this->classes[(string) $class['name']] = $class;
      }
    }
    if (isset($this->classes[$metadata
      ->getClassName()])) {
      $classDescription = $this->classes[$metadata
        ->getClassName()];
      $this
        ->loadClassMetadataFromXml($metadata, $classDescription);
      return true;
    }
    return false;
  }

  /**
   * Parses a collection of "constraint" XML nodes.
   *
   * @param \SimpleXMLElement $nodes The XML nodes
   *
   * @return array The Constraint instances
   */
  protected function parseConstraints(\SimpleXMLElement $nodes) {
    $constraints = array();
    foreach ($nodes as $node) {
      if (count($node) > 0) {
        if (count($node->value) > 0) {
          $options = $this
            ->parseValues($node->value);
        }
        elseif (count($node->constraint) > 0) {
          $options = $this
            ->parseConstraints($node->constraint);
        }
        elseif (count($node->option) > 0) {
          $options = $this
            ->parseOptions($node->option);
        }
        else {
          $options = array();
        }
      }
      elseif (strlen((string) $node) > 0) {
        $options = trim($node);
      }
      else {
        $options = null;
      }
      $constraints[] = $this
        ->newConstraint((string) $node['name'], $options);
    }
    return $constraints;
  }

  /**
   * Parses a collection of "value" XML nodes.
   *
   * @param \SimpleXMLElement $nodes The XML nodes
   *
   * @return array The values
   */
  protected function parseValues(\SimpleXMLElement $nodes) {
    $values = array();
    foreach ($nodes as $node) {
      if (count($node) > 0) {
        if (count($node->value) > 0) {
          $value = $this
            ->parseValues($node->value);
        }
        elseif (count($node->constraint) > 0) {
          $value = $this
            ->parseConstraints($node->constraint);
        }
        else {
          $value = array();
        }
      }
      else {
        $value = trim($node);
      }
      if (isset($node['key'])) {
        $values[(string) $node['key']] = $value;
      }
      else {
        $values[] = $value;
      }
    }
    return $values;
  }

  /**
   * Parses a collection of "option" XML nodes.
   *
   * @param \SimpleXMLElement $nodes The XML nodes
   *
   * @return array The options
   */
  protected function parseOptions(\SimpleXMLElement $nodes) {
    $options = array();
    foreach ($nodes as $node) {
      if (count($node) > 0) {
        if (count($node->value) > 0) {
          $value = $this
            ->parseValues($node->value);
        }
        elseif (count($node->constraint) > 0) {
          $value = $this
            ->parseConstraints($node->constraint);
        }
        else {
          $value = array();
        }
      }
      else {
        $value = XmlUtils::phpize($node);
        if (is_string($value)) {
          $value = trim($value);
        }
      }
      $options[(string) $node['name']] = $value;
    }
    return $options;
  }

  /**
   * Loads the XML class descriptions from the given file.
   *
   * @param string $path The path of the XML file
   *
   * @return \SimpleXMLElement The class descriptions
   *
   * @throws MappingException If the file could not be loaded
   */
  protected function parseFile($path) {
    try {
      $dom = XmlUtils::loadFile($path, __DIR__ . '/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd');
    } catch (\Exception $e) {
      throw new MappingException($e
        ->getMessage(), $e
        ->getCode(), $e);
    }
    return simplexml_import_dom($dom);
  }

  /**
   * Loads the validation metadata from the given XML class description.
   *
   * @param ClassMetadata $metadata         The metadata to load
   * @param array         $classDescription The XML class description
   */
  private function loadClassMetadataFromXml(ClassMetadata $metadata, $classDescription) {
    foreach ($classDescription->{'group-sequence-provider'} as $_) {
      $metadata
        ->setGroupSequenceProvider(true);
    }
    foreach ($classDescription->{'group-sequence'} as $groupSequence) {
      if (count($groupSequence->value) > 0) {
        $metadata
          ->setGroupSequence($this
          ->parseValues($groupSequence[0]->value));
      }
    }
    foreach ($this
      ->parseConstraints($classDescription->constraint) as $constraint) {
      $metadata
        ->addConstraint($constraint);
    }
    foreach ($classDescription->property as $property) {
      foreach ($this
        ->parseConstraints($property->constraint) as $constraint) {
        $metadata
          ->addPropertyConstraint((string) $property['name'], $constraint);
      }
    }
    foreach ($classDescription->getter as $getter) {
      foreach ($this
        ->parseConstraints($getter->constraint) as $constraint) {
        $metadata
          ->addGetterConstraint((string) $getter['property'], $constraint);
      }
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
AbstractLoader::$namespaces	protected	property
AbstractLoader::addNamespaceAlias	protected	function	Adds a namespace alias.
AbstractLoader::DEFAULT_NAMESPACE		constant	The namespace to load constraints from by default.
AbstractLoader::newConstraint	protected	function	Creates a new constraint instance for the given constraint name.
FileLoader::$file	protected	property	The file to load.
FileLoader::__construct	public	function	Creates a new loader.
XmlFileLoader::$classes	protected	property	The XML nodes of the mapping file.
XmlFileLoader::loadClassMetadata	public	function	Loads validation metadata into a {@link ClassMetadata} instance. Overrides LoaderInterface::loadClassMetadata
XmlFileLoader::loadClassMetadataFromXml	private	function	Loads the validation metadata from the given XML class description.
XmlFileLoader::parseConstraints	protected	function	Parses a collection of "constraint" XML nodes.
XmlFileLoader::parseFile	protected	function	Loads the XML class descriptions from the given file.
XmlFileLoader::parseOptions	protected	function	Parses a collection of "option" XML nodes.
XmlFileLoader::parseValues	protected	function	Parses a collection of "value" XML nodes.