symfony · tommygnr · Jun 12, 2014 · Jun 12, 2014 · Jun 12, 2014 · Jun 12, 2014
diff --git a/src/Symfony/Bundle/FrameworkBundle/DependencyInjection/FrameworkExtension.php b/src/Symfony/Bundle/FrameworkBundle/DependencyInjection/FrameworkExtension.php
@@ -741,6 +741,7 @@ private function registerValidationConfiguration(array $config, ContainerBuilder
             switch ($config['api']) {
                 case '2.4':
                     $api = Validation::API_VERSION_2_4;
+                    $container->setParameter('validator.validator_factory.class', $container->getParameter('validator.legacy_validator_factory.class'));
                     break;
                 case '2.5':
                     $api = Validation::API_VERSION_2_5;

diff --git a/src/Symfony/Bundle/FrameworkBundle/Resources/config/validator.xml b/src/Symfony/Bundle/FrameworkBundle/Resources/config/validator.xml
@@ -11,6 +11,7 @@
         <parameter key="validator.mapping.cache.apc.class">Symfony\Component\Validator\Mapping\Cache\ApcCache</parameter>
         <parameter key="validator.mapping.cache.prefix" />
         <parameter key="validator.validator_factory.class">Symfony\Bundle\FrameworkBundle\Validator\ConstraintValidatorFactory</parameter>
+        <parameter key="validator.legacy_validator_factory.class">Symfony\Bundle\FrameworkBundle\Validator\LegacyConstraintValidatorFactory</parameter>
         <parameter key="validator.expression.class">Symfony\Component\Validator\Constraints\ExpressionValidator</parameter>
         <parameter key="validator.email.class">Symfony\Component\Validator\Constraints\EmailValidator</parameter>
     </parameters>

diff --git a/src/Symfony/Bundle/FrameworkBundle/Validator/LegacyConstraintValidatorFactory.php b/src/Symfony/Bundle/FrameworkBundle/Validator/LegacyConstraintValidatorFactory.php
@@ -0,0 +1,91 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\FrameworkBundle\Validator;
+
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\ConstraintValidatorFactoryInterface;
+use Symfony\Component\Validator\ConstraintValidatorInterface;
+use Symfony\Component\Validator\Exception\UnexpectedTypeException;
+
+/**
+ * Like {@link ConstraintValidatorFactory}, but aware of services compatible
+ * with the 2.4 API.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ * @author Kris Wallsmith <kris@symfony.com>
+ *
+ * @see ConstraintValidatorFactory
+ */
+class LegacyConstraintValidatorFactory implements ConstraintValidatorFactoryInterface
+{
+    const BASE_NAMESPACE = 'Symfony\\Component\\Validator\\Constraints';
+
+    protected $container;
+    protected $validators;
+
+    /**
+     * Constructor.
+     *
+     * @param ContainerInterface $container  The service container
+     * @param array              $validators An array of validators
+     */
+    public function __construct(ContainerInterface $container, array $validators = array())
+    {
+        $this->container = $container;
+        $this->validators = $validators;
+    }
+
+    /**
+     * Returns the validator for the supplied constraint.
+     *
+     * @param Constraint $constraint A constraint
+     *
+     * @return ConstraintValidatorInterface A validator for the supplied constraint
+     *
+     * @throws UnexpectedTypeException When the validator is not an instance of ConstraintValidatorInterface
+     */
+    public function getInstance(Constraint $constraint)
+    {
+        $name = $constraint->validatedBy();
+
+        if (!isset($this->validators[$name])) {
+            switch (get_class($constraint)) {
+                case self::BASE_NAMESPACE.'\\All':
+                    $name = self::BASE_NAMESPACE.'\\LegacyAllValidator';
+                    break;
+                case self::BASE_NAMESPACE.'\\Choice':
+                    $name = self::BASE_NAMESPACE.'\\LegacyChoiceValidator';
+                    break;
+                case self::BASE_NAMESPACE.'\\Collection':
+                    $name = self::BASE_NAMESPACE.'\\LegacyCollectionValidator';
+                    break;
+                case self::BASE_NAMESPACE.'\\Count':
+                    $name = self::BASE_NAMESPACE.'\\LegacyCountValidator';
+                    break;
+                case self::BASE_NAMESPACE.'\\Length':
+                    $name = self::BASE_NAMESPACE.'\\LegacyLengthValidator';
+                    break;
+            }
+
+            $this->validators[$name] = new $name();
+        } elseif (is_string($this->validators[$name])) {
+            $this->validators[$name] = $this->container->get($this->validators[$name]);
+        }
+
+        if (!$this->validators[$name] instanceof ConstraintValidatorInterface) {
+            throw new UnexpectedTypeException($this->validators[$name], 'Symfony\Component\Validator\ConstraintValidatorInterface');
+        }
+
+        return $this->validators[$name];
+    }
+}
diff --git a/src/Symfony/Component/Console/CHANGELOG.md b/src/Symfony/Component/Console/CHANGELOG.md
@@ -13,6 +13,7 @@ CHANGELOG
  * deprecated the dialog helper (use the question helper instead)
  * deprecated TableHelper in favor of Table
  * deprecated ProgressHelper in favor of ProgressBar
+ * added ConsoleLogger
  * added a question helper
  * added a way to set the process name of a command
  * added a way to set a default command instead of `ListCommand`

diff --git a/src/Symfony/Component/Security/Core/Encoder/BasePasswordEncoder.php b/src/Symfony/Component/Security/Core/Encoder/BasePasswordEncoder.php
@@ -89,7 +89,7 @@ protected function comparePasswords($password1, $password2)
     /**
      * Checks if the password is too long.
      *
-     * @param string $password The password
+     * @param string $password The password to check
      *
      * @return bool true if the password is too long, false otherwise
      */

diff --git a/src/Symfony/Component/Serializer/Tests/Normalizer/GetSetMethodNormalizerTest.php b/src/Symfony/Component/Serializer/Tests/Normalizer/GetSetMethodNormalizerTest.php
@@ -145,6 +145,7 @@ public function testConstructorWithObjectDenormalize()
         $data = new \stdClass();
         $data->foo = 'foo';
         $data->bar = 'bar';
+        $data->baz = true;
         $data->fooBar = 'foobar';
         $obj = $this->normalizer->denormalize($data, __NAMESPACE__.'\GetConstructorDummy', 'any');
         $this->assertEquals('foo', $obj->getFoo());

diff --git a/src/Symfony/Component/Validator/Constraints/AllValidator.php b/src/Symfony/Component/Validator/Constraints/AllValidator.php
@@ -41,11 +41,10 @@ public function validate($value, Constraint $constraint)
 
         $context = $this->context;
         $group = $context->getGroup();
+        $validator = $context->getValidator()->inContext($context);
 
         foreach ($value as $key => $element) {
-            foreach ($constraint->constraints as $constr) {
-                $context->validateValue($element, $constr, '['.$key.']', $group);
-            }
+            $validator->atPath('['.$key.']')->validate($element, $constraint->constraints, $group);
         }
     }
 }
diff --git a/src/Symfony/Component/Validator/Constraints/ChoiceValidator.php b/src/Symfony/Component/Validator/Constraints/ChoiceValidator.php
@@ -63,33 +63,35 @@ public function validate($value, Constraint $constraint)
         if ($constraint->multiple) {
             foreach ($value as $_value) {
                 if (!in_array($_value, $choices, $constraint->strict)) {
-                    $this->context->addViolation($constraint->multipleMessage, array(
-                        '{{ value }}' => $this->formatValue($_value),
-                    ));
+                    $this->context->buildViolation($constraint->multipleMessage)
+                        ->setParameter('{{ value }}', $this->formatValue($_value))
+                        ->addViolation();
                 }
             }
 
             $count = count($value);
 
             if ($constraint->min !== null && $count < $constraint->min) {
-                $this->context->addViolation($constraint->minMessage, array(
-                    '{{ limit }}' => $constraint->min
-                ), null, (int) $constraint->min);
+                $this->context->buildViolation($constraint->minMessage)
+                    ->setParameter('{{ limit }}', $constraint->min)
+                    ->setPlural((int) $constraint->min)
+                    ->addViolation();
 
                 return;
             }
 
             if ($constraint->max !== null && $count > $constraint->max) {
-                $this->context->addViolation($constraint->maxMessage, array(
-                    '{{ limit }}' => $constraint->max
-                ), null, (int) $constraint->max);
+                $this->context->buildViolation($constraint->maxMessage)
+                    ->setParameter('{{ limit }}', $constraint->max)
+                    ->setPlural((int) $constraint->max)
+                    ->addViolation();
 
                 return;
             }
         } elseif (!in_array($value, $choices, $constraint->strict)) {
-            $this->context->addViolation($constraint->message, array(
-                '{{ value }}' => $this->formatValue($value)
-            ));
+            $this->context->buildViolation($constraint->message)
+                ->setParameter('{{ value }}', $this->formatValue($value))
+                ->addViolation();
         }
     }
 }
diff --git a/src/Symfony/Component/Validator/Constraints/CollectionValidator.php b/src/Symfony/Component/Validator/Constraints/CollectionValidator.php
@@ -50,29 +50,35 @@ public function validate($value, Constraint $constraint)
         // to validate() instead.
         $context = $this->context;
         $group = $context->getGroup();
+        $validator = $context->getValidator()->inContext($context);
 
         foreach ($constraint->fields as $field => $fieldConstraint) {
-            if (
-                // bug fix issue #2779
-                (is_array($value) && array_key_exists($field, $value)) ||
-                ($value instanceof \ArrayAccess && $value->offsetExists($field))
-            ) {
-                foreach ($fieldConstraint->constraints as $constr) {
-                    $context->validateValue($value[$field], $constr, '['.$field.']', $group);
+            // bug fix issue #2779
+            $existsInArray = is_array($value) && array_key_exists($field, $value);
+            $existsInArrayAccess = $value instanceof \ArrayAccess && $value->offsetExists($field);
+
+            if ($existsInArray || $existsInArrayAccess) {
+                if (count($fieldConstraint->constraints) > 0) {
+                    $validator->atPath('['.$field.']')
+                        ->validate($value[$field], $fieldConstraint->constraints, $group);
                 }
             } elseif (!$fieldConstraint instanceof Optional && !$constraint->allowMissingFields) {
-                $context->addViolationAt('['.$field.']', $constraint->missingFieldsMessage, array(
-                    '{{ field }}' => $this->formatValue($field)
-                ), null);
+                $context->buildViolation($constraint->missingFieldsMessage)
+                    ->atPath('['.$field.']')
+                    ->setParameter('{{ field }}', $this->formatValue($field))
+                    ->setInvalidValue(null)
+                    ->addViolation();
             }
         }
 
         if (!$constraint->allowExtraFields) {
             foreach ($value as $field => $fieldValue) {
                 if (!isset($constraint->fields[$field])) {
-                    $context->addViolationAt('['.$field.']', $constraint->extraFieldsMessage, array(
-                        '{{ field }}' => $this->formatValue($field)
-                    ), $fieldValue);
+                    $context->buildViolation($constraint->extraFieldsMessage)
+                        ->atPath('['.$field.']')
+                        ->setParameter('{{ field }}', $this->formatValue($field))
+                        ->setInvalidValue($fieldValue)
+                        ->addViolation();
                 }
             }
         }

diff --git a/src/Symfony/Component/Validator/Constraints/CountValidator.php b/src/Symfony/Component/Validator/Constraints/CountValidator.php
@@ -36,28 +36,34 @@ public function validate($value, Constraint $constraint)
         $count = count($value);
 
         if ($constraint->min == $constraint->max && $count != $constraint->min) {
-            $this->context->addViolation($constraint->exactMessage, array(
-                '{{ count }}' => $count,
-                '{{ limit }}' => $constraint->min,
-            ), $value, (int) $constraint->min);
+            $this->context->buildViolation($constraint->exactMessage)
+                ->setParameter('{{ count }}', $count)
+                ->setParameter('{{ limit }}', $constraint->min)
+                ->setInvalidValue($value)
+                ->setPlural((int) $constraint->min)
+                ->addViolation();
 
             return;
         }
 
         if (null !== $constraint->max && $count > $constraint->max) {
-            $this->context->addViolation($constraint->maxMessage, array(
-                '{{ count }}' => $count,
-                '{{ limit }}' => $constraint->max,
-            ), $value, (int) $constraint->max);
+            $this->context->buildViolation($constraint->maxMessage)
+                ->setParameter('{{ count }}', $count)
+                ->setParameter('{{ limit }}', $constraint->max)
+                ->setInvalidValue($value)
+                ->setPlural((int) $constraint->max)
+                ->addViolation();
 
             return;
         }
 
         if (null !== $constraint->min && $count < $constraint->min) {
-            $this->context->addViolation($constraint->minMessage, array(
-                '{{ count }}' => $count,
-                '{{ limit }}' => $constraint->min,
-            ), $value, (int) $constraint->min);
+            $this->context->buildViolation($constraint->minMessage)
+                ->setParameter('{{ count }}', $count)
+                ->setParameter('{{ limit }}', $constraint->min)
+                ->setInvalidValue($value)
+                ->setPlural((int) $constraint->min)
+                ->addViolation();
         }
     }
 }
diff --git a/src/Symfony/Component/Validator/Constraints/DateTimeValidator.php b/src/Symfony/Component/Validator/Constraints/DateTimeValidator.php
@@ -43,7 +43,9 @@ public function validate($value, Constraint $constraint)
         $value = (string) $value;
 
         if (!preg_match(static::PATTERN, $value, $matches) || !checkdate($matches[2], $matches[3], $matches[1])) {
-            $this->context->addViolation($constraint->message, array('{{ value }}' => $value));
+            $this->context->addViolation($constraint->message, array(
+                '{{ value }}' => $this->formatValue($value),
+            ));
         }
     }
 }
diff --git a/src/Symfony/Component/Validator/Constraints/ExpressionValidator.php b/src/Symfony/Component/Validator/Constraints/ExpressionValidator.php
@@ -74,14 +74,18 @@ public function validate($value, Constraint $constraint)
             $variables['value'] = $value;
             $variables['this'] = $value;
         } else {
-            // Extract the object that the property belongs to from the object
-            // graph
-            $path = new PropertyPath($this->context->getPropertyPath());
-            $parentPath = $path->getParent();
             $root = $this->context->getRoot();
-
             $variables['value'] = $value;
-            $variables['this'] = $parentPath ? $this->getPropertyAccessor()->getValue($root, $parentPath) : $root;
+
+            if (is_object($root)) {
+                // Extract the object that the property belongs to from the object
+                // graph
+                $path = new PropertyPath($this->context->getPropertyPath());
+                $parentPath = $path->getParent();
+                $variables['this'] = $parentPath ? $this->getPropertyAccessor()->getValue($root, $parentPath) : $root;
+            } else {
+                $variables['this'] = null;
+            }
         }
 
         if (!$this->getExpressionLanguage()->evaluate($constraint->expression, $variables)) {

diff --git a/src/Symfony/Component/Validator/Constraints/FileValidator.php b/src/Symfony/Component/Validator/Constraints/FileValidator.php
@@ -156,10 +156,10 @@ public function validate($value, Constraint $constraint)
                 }
 
                 $this->context->addViolation($constraint->maxSizeMessage, array(
-                    '{{ size }}'    => $sizeAsString,
-                    '{{ limit }}'   => $limitAsString,
-                    '{{ suffix }}'  => self::$suffices[$coef],
-                    '{{ file }}'    => $path,
+                    '{{ size }}' => $sizeAsString,
+                    '{{ limit }}' => $limitAsString,
+                    '{{ suffix }}' => self::$suffices[$coef],
+                    '{{ file }}' => $this->formatValue($path),
                 ));
 
                 return;