Make evaluation of expression arguments optional

To prevent all kinds of runtime errors, evalution of expression
arguments has been made optional and should be deliberately turned on.

This fixes #7.

Author: matthiasnoback

ArgumentValidator.php

@@ -16,13 +16,16 @@ class ArgumentValidator implements ArgumentValidatorInterface
 {
     private $containerBuilder;
     private $resultingClassResolver;
+    private $evaluateExpressions;
 
     public function __construct(
         ContainerBuilder $containerBuilder,
-        ResultingClassResolverInterface $resultingClassResolver
+        ResultingClassResolverInterface $resultingClassResolver,
+        $evaluateExpressions = false
     ) {
         $this->containerBuilder = $containerBuilder;
         $this->resultingClassResolver = $resultingClassResolver;
+        $this->evaluateExpressions = $evaluateExpressions;
     }
 
     public function validate(\ReflectionParameter $parameter, $argument)
@@ -88,10 +91,26 @@ private function validateExpressionArgument($className, Expression $expression,
     {
         $expressionLanguage = new ExpressionLanguage();
 
+        $this->validateExpressionSyntax($expression, $expressionLanguage);
+
+        if ($this->evaluateExpressions) {
+            $this->validateExpressionResult($className, $expression, $allowsNull, $expressionLanguage);
+        }
+    }
+
+    private function validateExpressionSyntax(Expression $expression, ExpressionLanguage $expressionLanguage)
+    {
         try {
-            $result = $expressionLanguage->evaluate($expression, array('container' => $this->containerBuilder));
+            $expressionLanguage->parse($expression, array('container'));
         } catch (SyntaxError $exception) {
             throw new InvalidExpressionSyntaxException($expression, $exception);
+        }
+    }
+
+    private function validateExpressionResult($className, Expression $expression, $allowsNull, ExpressionLanguage $expressionLanguage)
+    {
+        try {
+            $result = $expressionLanguage->evaluate($expression, array('container' => $this->containerBuilder));
         } catch (\Exception $exception) {
             throw new InvalidExpressionException($expression, $exception);
         }

Compiler/ValidateServiceDefinitionsPass.php

@@ -3,6 +3,7 @@
 namespace Matthias\SymfonyServiceDefinitionValidator\Compiler;
 
 use Matthias\SymfonyServiceDefinitionValidator\BatchServiceDefinitionValidator;
+use Matthias\SymfonyServiceDefinitionValidator\Configuration;
 use Matthias\SymfonyServiceDefinitionValidator\Error\Printer\SimpleErrorListPrinter;
 use Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorFactory;
 use Matthias\SymfonyServiceDefinitionValidator\Exception\InvalidServiceDefinitionsException;
@@ -12,11 +13,18 @@
 
 class ValidateServiceDefinitionsPass implements CompilerPassInterface
 {
+    private $configuration;
+
+    public function __construct(Configuration $configuration = null)
+    {
+        $this->configuration = $configuration;
+    }
+
     public function process(ContainerBuilder $container)
     {
         $serviceDefinitions = $container->getDefinitions();
 
-        $validatorFactory = new ServiceDefinitionValidatorFactory();
+        $validatorFactory = new ServiceDefinitionValidatorFactory($this->configuration);
         $validator = $validatorFactory->create($container);
 
         $batchValidator = new BatchServiceDefinitionValidator(

Configuration.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Matthias\SymfonyServiceDefinitionValidator;
+
+class Configuration
+{
+    private $evaluateExpressions = false;
+
+    /**
+     * Configure whether or not to evaluate expression arguments
+     *
+     * @param boolean $evaluateExpressions
+     */
+    public function setEvaluateExpressions($evaluateExpressions)
+    {
+        $this->evaluateExpressions = (boolean) $evaluateExpressions;
+
+        return $this;
+    }
+
+    public function getEvaluateExpressions()
+    {
+        return $this->evaluateExpressions;
+    }
+}

README.md

@@ -67,6 +67,7 @@ To process multiple definitions at once, wrap the validator inside a batch valid
 
 ```php
 <?php
+
 use Matthias\SymfonyServiceDefinitionValidator\BatchServiceDefinitionValidator;
 use Matthias\SymfonyServiceDefinitionValidator\Error\ValidationErrorFactory;
 
@@ -107,6 +108,28 @@ class SomeBundle extends Bundle
 This compiler pass will throw an exception. The message of this exception will contain a list
 of invalid service definitions.
 
+### Configure the validator
+
+Both ``ValidateServiceDefinitionsPass`` and ``ServiceDefinitionValidatorFactory`` accept a ``Configuration`` object.
+It allows you to configure whether or not expression arguments should be evaluated. Since evaluating expressions can
+cause all kinds of runtime errors, it is *off by default*, but you can easily turn it on:
+
+```php
+<?php
+
+use Matthias\SymfonyServiceDefinitionValidator\Configuration;
+use Matthias\SymfonyServiceDefinitionValidator\Compiler\ValidateServiceDefinitionsPass;
+
+$configuration = new Configuration();
+$configuration->setEvaluateExpressions(true);
+
+$compilerPass = new ValidateServiceDefinitionsPass($configuration);
+
+// or
+
+$validatorFactory = new ServiceDefinitionValidatorFactory($configuration);
+```
+
 ### Fixing invalid service definitions in third-party bundles
 
 When the validator finds a problem with one of the service definitions that is your own, you can of course fix the

ServiceDefinitionValidatorFactory.php

@@ -6,13 +6,28 @@
 
 class ServiceDefinitionValidatorFactory implements ServiceDefinitionValidatorFactoryInterface
 {
+    private $configuration;
+
+    public function __construct(Configuration $configuration = null)
+    {
+        if ($configuration === null) {
+            $configuration = new Configuration();
+        }
+
+        $this->configuration = $configuration;
+    }
+
     public function create(ContainerBuilder $containerBuilder)
     {
         $resultingClassResolver = new ResultingClassResolver($containerBuilder);
 
         $constructorResolver = new ConstructorResolver($containerBuilder, $resultingClassResolver);
 
-        $argumentValidator = new ArgumentValidator($containerBuilder, $resultingClassResolver);
+        $argumentValidator = new ArgumentValidator(
+            $containerBuilder,
+            $resultingClassResolver,
+            $this->configuration->getEvaluateExpressions()
+        );
         $argumentsValidator = new ArgumentsValidator($argumentValidator);
 
         $definitionArgumentsValidator = new DefinitionArgumentsValidator($constructorResolver, $argumentsValidator);

Tests/ArgumentValidatorTest.php

@@ -94,7 +94,7 @@ public function testFailsWhenResultOfExpressionIsNotAnObjectOfTheExpectedClass()
         $containerBuilder = new ContainerBuilder();
         $containerBuilder->setDefinition('service_wrong_class', new Definition('stdClass'));
 
-        $validator = new ArgumentValidator($containerBuilder, $this->createMockResultingClassResolver());
+        $validator = new ArgumentValidator($containerBuilder, $this->createMockResultingClassResolver(), true);
 
         $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');
 
@@ -108,7 +108,7 @@ public function testFailsWhenResultOfExpressionIsNotAnObject()
         $parameter = new \ReflectionParameter(array($class, '__construct'), 'expected');
         $argument = new Expression('"a string"');
 
-        $validator = new ArgumentValidator(new ContainerBuilder(), $this->createMockResultingClassResolver());
+        $validator = new ArgumentValidator(new ContainerBuilder(), $this->createMockResultingClassResolver(), true);
 
         $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\TypeHintMismatchException', 'ExpectedClass');
 
@@ -152,7 +152,7 @@ public function testFailsIfExpressionCouldNotBeEvaluated()
         $parameter = new \ReflectionParameter(array($class, '__construct'), 'expected');
         $argument = new Expression('service("invalid service")');
 
-        $validator = new ArgumentValidator(new ContainerBuilder(), $this->createMockResultingClassResolver());
+        $validator = new ArgumentValidator(new ContainerBuilder(), $this->createMockResultingClassResolver(), true);
 
         $this->setExpectedException('Matthias\SymfonyServiceDefinitionValidator\Exception\InvalidExpressionException');
 

Tests/Functional/FunctionalTest.php

@@ -3,6 +3,7 @@
 namespace Matthias\SymfonyServiceDefinitionValidator\Functional;
 
 use Matthias\SymfonyServiceDefinitionValidator\Compiler\ValidateServiceDefinitionsPass;
+use Matthias\SymfonyServiceDefinitionValidator\Configuration;
 use Symfony\Component\Config\FileLocator;
 use Symfony\Component\DependencyInjection\Compiler\PassConfig;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
@@ -19,7 +20,10 @@ protected function setUp()
     {
         $this->container = new ContainerBuilder();
 
-        $compilerPass = new ValidateServiceDefinitionsPass();
+        $configuration = new Configuration();
+        $configuration->setEvaluateExpressions(true);
+
+        $compilerPass = new ValidateServiceDefinitionsPass($configuration);
 
         $this->container->addCompilerPass($compilerPass, PassConfig::TYPE_AFTER_REMOVING);
     }