Validator.php in Plug 7

Namespace

Symfony\Component\Validator

File

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

<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <[e-mail]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace Symfony\Component\Validator;

use Symfony\Component\Translation\TranslatorInterface;
use Symfony\Component\Validator\Constraints\Valid;
use Symfony\Component\Validator\Exception\ValidatorException;

/**
 * Default implementation of {@link ValidatorInterface}.
 *
 * @author Fabien Potencier <[e-mail]>
 * @author Bernhard Schussek <[e-mail]>
 *
 * @deprecated Deprecated since version 2.5, to be removed in Symfony 3.0.
 *             Use {@link Validator\RecursiveValidator} instead.
 */
class Validator implements ValidatorInterface, Mapping\Factory\MetadataFactoryInterface {

  /**
   * @var MetadataFactoryInterface
   */
  private $metadataFactory;

  /**
   * @var ConstraintValidatorFactoryInterface
   */
  private $validatorFactory;

  /**
   * @var TranslatorInterface
   */
  private $translator;

  /**
   * @var null|string
   */
  private $translationDomain;

  /**
   * @var array
   */
  private $objectInitializers;
  public function __construct(MetadataFactoryInterface $metadataFactory, ConstraintValidatorFactoryInterface $validatorFactory, TranslatorInterface $translator, $translationDomain = 'validators', array $objectInitializers = array()) {
    $this->metadataFactory = $metadataFactory;
    $this->validatorFactory = $validatorFactory;
    $this->translator = $translator;
    $this->translationDomain = $translationDomain;
    $this->objectInitializers = $objectInitializers;
  }

  /**
   * {@inheritdoc}
   */
  public function getMetadataFactory() {
    return $this->metadataFactory;
  }

  /**
   * {@inheritdoc}
   */
  public function getMetadataFor($value) {
    return $this->metadataFactory
      ->getMetadataFor($value);
  }

  /**
   * {@inheritdoc}
   */
  public function hasMetadataFor($value) {
    return $this->metadataFactory
      ->hasMetadataFor($value);
  }

  /**
   * {@inheritdoc}
   */
  public function validate($value, $groups = null, $traverse = false, $deep = false) {
    $visitor = $this
      ->createVisitor($value);
    foreach ($this
      ->resolveGroups($groups) as $group) {
      $visitor
        ->validate($value, $group, '', $traverse, $deep);
    }
    return $visitor
      ->getViolations();
  }

  /**
   * {@inheritdoc}
   *
   * @throws ValidatorException If the metadata for the value does not support properties.
   */
  public function validateProperty($containingValue, $property, $groups = null) {
    $visitor = $this
      ->createVisitor($containingValue);
    $metadata = $this->metadataFactory
      ->getMetadataFor($containingValue);
    if (!$metadata instanceof PropertyMetadataContainerInterface) {
      $valueAsString = is_scalar($containingValue) ? '"' . $containingValue . '"' : 'the value of type ' . gettype($containingValue);
      throw new ValidatorException(sprintf('The metadata for %s does not support properties.', $valueAsString));
    }
    foreach ($this
      ->resolveGroups($groups) as $group) {
      if (!$metadata
        ->hasPropertyMetadata($property)) {
        continue;
      }
      foreach ($metadata
        ->getPropertyMetadata($property) as $propMeta) {
        $propMeta
          ->accept($visitor, $propMeta
          ->getPropertyValue($containingValue), $group, $property);
      }
    }
    return $visitor
      ->getViolations();
  }

  /**
   * {@inheritdoc}
   *
   * @throws ValidatorException If the metadata for the value does not support properties.
   */
  public function validatePropertyValue($containingValue, $property, $value, $groups = null) {
    $visitor = $this
      ->createVisitor(is_object($containingValue) ? $containingValue : $value);
    $metadata = $this->metadataFactory
      ->getMetadataFor($containingValue);
    if (!$metadata instanceof PropertyMetadataContainerInterface) {
      $valueAsString = is_scalar($containingValue) ? '"' . $containingValue . '"' : 'the value of type ' . gettype($containingValue);
      throw new ValidatorException(sprintf('The metadata for ' . $valueAsString . ' does not support properties.'));
    }

    // If $containingValue is passed as class name, take $value as root
    // and start the traversal with an empty property path
    $propertyPath = is_object($containingValue) ? $property : '';
    foreach ($this
      ->resolveGroups($groups) as $group) {
      if (!$metadata
        ->hasPropertyMetadata($property)) {
        continue;
      }
      foreach ($metadata
        ->getPropertyMetadata($property) as $propMeta) {
        $propMeta
          ->accept($visitor, $value, $group, $propertyPath);
      }
    }
    return $visitor
      ->getViolations();
  }

  /**
   * {@inheritdoc}
   */
  public function validateValue($value, $constraints, $groups = null) {
    $context = new ExecutionContext($this
      ->createVisitor($value), $this->translator, $this->translationDomain);
    $constraints = is_array($constraints) ? $constraints : array(
      $constraints,
    );
    foreach ($constraints as $constraint) {
      if ($constraint instanceof Valid) {

        // Why can't the Valid constraint be executed directly?
        //
        // It cannot be executed like regular other constraints, because regular
        // constraints are only executed *if they belong to the validated group*.
        // The Valid constraint, on the other hand, is always executed and propagates
        // the group to the cascaded object. The propagated group depends on
        //
        //  * Whether a group sequence is currently being executed. Then the default
        //    group is propagated.
        //
        //  * Otherwise the validated group is propagated.
        throw new ValidatorException(sprintf('The constraint %s cannot be validated. Use the method validate() instead.', get_class($constraint)));
      }
      $context
        ->validateValue($value, $constraint, '', $groups);
    }
    return $context
      ->getViolations();
  }

  /**
   * @param mixed $root
   *
   * @return ValidationVisitor
   */
  private function createVisitor($root) {
    return new ValidationVisitor($root, $this->metadataFactory, $this->validatorFactory, $this->translator, $this->translationDomain, $this->objectInitializers);
  }

  /**
   * @param null|string|string[] $groups
   *
   * @return string[]
   */
  private function resolveGroups($groups) {
    return $groups ? (array) $groups : array(
      Constraint::DEFAULT_GROUP,
    );
  }

}

Classes

Name	Description
Validator Deprecated	Default implementation of {@link ValidatorInterface}.