New plugin repo is cloned to /store/pluginrepos/REPONAME for analysis

library/symfony/options-resolver/CHANGELOG.md

@@ -0,0 +1,46 @@
+CHANGELOG
+=========
+
+2.6.0
+-----
+
+ * deprecated OptionsResolverInterface
+ * [BC BREAK] removed "array" type hint from OptionsResolverInterface methods
+   setRequired(), setAllowedValues(), addAllowedValues(), setAllowedTypes() and
+   addAllowedTypes()
+ * added OptionsResolver::setDefault()
+ * added OptionsResolver::hasDefault()
+ * added OptionsResolver::setNormalizer()
+ * added OptionsResolver::isRequired()
+ * added OptionsResolver::getRequiredOptions()
+ * added OptionsResolver::isMissing()
+ * added OptionsResolver::getMissingOptions()
+ * added OptionsResolver::setDefined()
+ * added OptionsResolver::isDefined()
+ * added OptionsResolver::getDefinedOptions()
+ * added OptionsResolver::remove()
+ * added OptionsResolver::clear()
+ * deprecated OptionsResolver::replaceDefaults()
+ * deprecated OptionsResolver::setOptional() in favor of setDefined()
+ * deprecated OptionsResolver::isKnown() in favor of isDefined()
+ * [BC BREAK] OptionsResolver::isRequired() returns true now if a required
+   option has a default value set
+ * [BC BREAK] merged Options into OptionsResolver and turned Options into an 
+   interface
+ * deprecated Options::overload() (now in OptionsResolver)
+ * deprecated Options::set() (now in OptionsResolver)
+ * deprecated Options::get() (now in OptionsResolver)
+ * deprecated Options::has() (now in OptionsResolver)
+ * deprecated Options::replace() (now in OptionsResolver)
+ * [BC BREAK] Options::get() (now in OptionsResolver) can only be used within
+   lazy option/normalizer closures now
+ * [BC BREAK] removed Traversable interface from Options since using within
+   lazy option/normalizer closures resulted in exceptions
+ * [BC BREAK] removed Options::all() since using within lazy option/normalizer 
+   closures resulted in exceptions
+ * [BC BREAK] OptionDefinitionException now extends LogicException instead of
+   RuntimeException
+ * [BC BREAK] normalizers are not executed anymore for unset options
+ * normalizers are executed after validating the options now
+ * [BC BREAK] an UndefinedOptionsException is now thrown instead of an
+   InvalidOptionsException when non-existing options are passed

library/symfony/options-resolver/Exception/AccessException.php

@@ -0,0 +1,22 @@
+<?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\Component\OptionsResolver\Exception;
+
+/**
+ * Thrown when trying to read an option outside of or write it inside of
+ * {@link \Symfony\Component\OptionsResolver\Options::resolve()}.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class AccessException extends \LogicException implements ExceptionInterface
+{
+}

library/symfony/options-resolver/Exception/ExceptionInterface.php

@@ -0,0 +1,21 @@
+<?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\Component\OptionsResolver\Exception;
+
+/**
+ * Marker interface for all exceptions thrown by the OptionsResolver component.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+interface ExceptionInterface
+{
+}

library/symfony/options-resolver/Exception/InvalidArgumentException.php

@@ -0,0 +1,21 @@
+<?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\Component\OptionsResolver\Exception;
+
+/**
+ * Thrown when an argument is invalid.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class InvalidArgumentException extends \InvalidArgumentException implements ExceptionInterface
+{
+}

library/symfony/options-resolver/Exception/InvalidOptionsException.php

@@ -0,0 +1,23 @@
+<?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\Component\OptionsResolver\Exception;
+
+/**
+ * Thrown when the value of an option does not match its validation rules.
+ *
+ * You should make sure a valid value is passed to the option.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class InvalidOptionsException extends InvalidArgumentException
+{
+}

library/symfony/options-resolver/Exception/MissingOptionsException.php

@@ -0,0 +1,23 @@
+<?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\Component\OptionsResolver\Exception;
+
+/**
+ * Exception thrown when a required option is missing.
+ *
+ * Add the option to the passed options array.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class MissingOptionsException extends InvalidArgumentException
+{
+}

library/symfony/options-resolver/Exception/NoSuchOptionException.php

@@ -0,0 +1,26 @@
+<?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\Component\OptionsResolver\Exception;
+
+/**
+ * Thrown when trying to read an option that has no value set.
+ *
+ * When accessing optional options from within a lazy option or normalizer you should first
+ * check whether the optional option is set. You can do this with `isset($options['optional'])`.
+ * In contrast to the {@link UndefinedOptionsException}, this is a runtime exception that can
+ * occur when evaluating lazy options.
+ *
+ * @author Tobias Schultze <http://tobion.de>
+ */
+class NoSuchOptionException extends \OutOfBoundsException implements ExceptionInterface
+{
+}

library/symfony/options-resolver/Exception/OptionDefinitionException.php

@@ -0,0 +1,21 @@
+<?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\Component\OptionsResolver\Exception;
+
+/**
+ * Thrown when two lazy options have a cyclic dependency.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class OptionDefinitionException extends \LogicException implements ExceptionInterface
+{
+}

library/symfony/options-resolver/Exception/UndefinedOptionsException.php

@@ -0,0 +1,24 @@
+<?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\Component\OptionsResolver\Exception;
+
+/**
+ * Exception thrown when an undefined option is passed.
+ *
+ * You should remove the options in question from your code or define them
+ * beforehand.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+class UndefinedOptionsException extends InvalidArgumentException
+{
+}

library/symfony/options-resolver/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2004-2015 Fabien Potencier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

library/symfony/options-resolver/Options.php

@@ -0,0 +1,22 @@
+<?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\Component\OptionsResolver;
+
+/**
+ * Contains resolved option values.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ * @author Tobias Schultze <http://tobion.de>
+ */
+interface Options extends \ArrayAccess, \Countable
+{
+}

library/symfony/options-resolver/OptionsResolverInterface.php

@@ -0,0 +1,212 @@
+<?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\Component\OptionsResolver;
+
+use Symfony\Component\OptionsResolver\Exception\InvalidOptionsException;
+use Symfony\Component\OptionsResolver\Exception\MissingOptionsException;
+use Symfony\Component\OptionsResolver\Exception\OptionDefinitionException;
+
+/**
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ *
+ * @deprecated since version 2.6, to be removed in 3.0. Use {@link OptionsResolver} instead.
+ */
+interface OptionsResolverInterface
+{
+    /**
+     * Sets default option values.
+     *
+     * The options can either be values of any types or closures that
+     * evaluate the option value lazily. These closures must have one
+     * of the following signatures:
+     *
+     * <code>
+     * function (Options $options)
+     * function (Options $options, $value)
+     * </code>
+     *
+     * The second parameter passed to the closure is the previously
+     * set default value, in case you are overwriting an existing
+     * default value.
+     *
+     * The closures should return the lazily created option value.
+     *
+     * @param array $defaultValues A list of option names as keys and default
+     *                             values or closures as values.
+     *
+     * @return OptionsResolverInterface The resolver instance.
+     */
+    public function setDefaults(array $defaultValues);
+
+    /**
+     * Replaces default option values.
+     *
+     * Old defaults are erased, which means that closures passed here cannot
+     * access the previous default value. This may be useful to improve
+     * performance if the previous default value is calculated by an expensive
+     * closure.
+     *
+     * @param array $defaultValues A list of option names as keys and default
+     *                             values or closures as values.
+     *
+     * @return OptionsResolverInterface The resolver instance.
+     */
+    public function replaceDefaults(array $defaultValues);
+
+    /**
+     * Sets optional options.
+     *
+     * This method declares valid option names without setting default values for them.
+     * If these options are not passed to {@link resolve()} and no default has been set
+     * for them, they will be missing in the final options array. This can be helpful
+     * if you want to determine whether an option has been set or not because otherwise
+     * {@link resolve()} would trigger an exception for unknown options.
+     *
+     * @param array $optionNames A list of option names.
+     *
+     * @return OptionsResolverInterface The resolver instance.
+     */
+    public function setOptional(array $optionNames);
+
+    /**
+     * Sets required options.
+     *
+     * If these options are not passed to {@link resolve()} and no default has been set for
+     * them, an exception will be thrown.
+     *
+     * @param array $optionNames A list of option names.
+     *
+     * @return OptionsResolverInterface The resolver instance.
+     */
+    public function setRequired($optionNames);
+
+    /**
+     * Sets allowed values for a list of options.
+     *
+     * @param array $allowedValues A list of option names as keys and arrays
+     *                             with values acceptable for that option as
+     *                             values.
+     *
+     * @return OptionsResolverInterface The resolver instance.
+     *
+     * @throws InvalidOptionsException If an option has not been defined
+     *                                 (see {@link isKnown()}) for which
+     *                                 an allowed value is set.
+     */
+    public function setAllowedValues($allowedValues);
+
+    /**
+     * Adds allowed values for a list of options.
+     *
+     * The values are merged with the allowed values defined previously.
+     *
+     * @param array $allowedValues A list of option names as keys and arrays
+     *                             with values acceptable for that option as
+     *                             values.
+     *
+     * @return OptionsResolverInterface The resolver instance.
+     *
+     * @throws InvalidOptionsException If an option has not been defined
+     *                                 (see {@link isKnown()}) for which
+     *                                 an allowed value is set.
+     */
+    public function addAllowedValues($allowedValues);
+
+    /**
+     * Sets allowed types for a list of options.
+     *
+     * @param array $allowedTypes A list of option names as keys and type
+     *                            names passed as string or array as values.
+     *
+     * @return OptionsResolverInterface The resolver instance.
+     *
+     * @throws InvalidOptionsException If an option has not been defined for
+     *                                 which an allowed type is set.
+     */
+    public function setAllowedTypes($allowedTypes);
+
+    /**
+     * Adds allowed types for a list of options.
+     *
+     * The types are merged with the allowed types defined previously.
+     *
+     * @param array $allowedTypes A list of option names as keys and type
+     *                            names passed as string or array as values.
+     *
+     * @return OptionsResolverInterface The resolver instance.
+     *
+     * @throws InvalidOptionsException If an option has not been defined for
+     *                                 which an allowed type is set.
+     */
+    public function addAllowedTypes($allowedTypes);
+
+    /**
+     * Sets normalizers that are applied on resolved options.
+     *
+     * The normalizers should be closures with the following signature:
+     *
+     * <code>
+     * function (Options $options, $value)
+     * </code>
+     *
+     * The second parameter passed to the closure is the value of
+     * the option.
+     *
+     * The closure should return the normalized value.
+     *
+     * @param array $normalizers An array of closures.
+     *
+     * @return OptionsResolverInterface The resolver instance.
+     */
+    public function setNormalizers(array $normalizers);
+
+    /**
+     * Returns whether an option is known.
+     *
+     * An option is known if it has been passed to either {@link setDefaults()},
+     * {@link setRequired()} or {@link setOptional()} before.
+     *
+     * @param string $option The name of the option.
+     *
+     * @return bool Whether the option is known.
+     */
+    public function isKnown($option);
+
+    /**
+     * Returns whether an option is required.
+     *
+     * An option is required if it has been passed to {@link setRequired()},
+     * but not to {@link setDefaults()}. That is, the option has been declared
+     * as required and no default value has been set.
+     *
+     * @param string $option The name of the option.
+     *
+     * @return bool Whether the option is required.
+     */
+    public function isRequired($option);
+
+    /**
+     * Returns the combination of the default and the passed options.
+     *
+     * @param array $options The custom option values.
+     *
+     * @return array A list of options and their values.
+     *
+     * @throws InvalidOptionsException   If any of the passed options has not
+     *                                   been defined or does not contain an
+     *                                   allowed value.
+     * @throws MissingOptionsException   If a required option is missing.
+     * @throws OptionDefinitionException If a cyclic dependency is detected
+     *                                   between two lazy options.
+     */
+    public function resolve(array $options = array());
+}

library/symfony/options-resolver/README.md

@@ -0,0 +1,20 @@
+OptionsResolver Component
+=========================
+
+This component processes and validates option arrays.
+
+Documentation
+-------------
+
+The documentation for the component can be found [online] [1].
+
+Resources
+---------
+
+You can run the unit tests with the following command:
+
+    $ cd path/to/Symfony/Component/OptionsResolver/
+    $ composer install
+    $ phpunit
+
+[1]: https://symfony.com/doc/current/components/options_resolver.html

library/symfony/options-resolver/Tests/LegacyOptionsResolverTest.php

@@ -0,0 +1,733 @@
+<?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\Component\OptionsResolver\Tests;
+
+use Symfony\Component\OptionsResolver\OptionsResolver;
+use Symfony\Component\OptionsResolver\Options;
+
+/**
+ * @group legacy
+ */
+class LegacyOptionsResolverTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var OptionsResolver
+     */
+    private $resolver;
+
+    protected function setUp()
+    {
+        $this->resolver = new OptionsResolver();
+    }
+
+    public function testResolve()
+    {
+        $this->resolver->setDefaults(array(
+            'one' => '1',
+            'two' => '2',
+        ));
+
+        $options = array(
+            'two' => '20',
+        );
+
+        $this->assertEquals(array(
+            'one' => '1',
+            'two' => '20',
+        ), $this->resolver->resolve($options));
+    }
+
+    public function testResolveNumericOptions()
+    {
+        $this->resolver->setDefaults(array(
+            '1' => '1',
+            '2' => '2',
+        ));
+
+        $options = array(
+            '2' => '20',
+        );
+
+        $this->assertEquals(array(
+            '1' => '1',
+            '2' => '20',
+        ), $this->resolver->resolve($options));
+    }
+
+    public function testResolveLazy()
+    {
+        $this->resolver->setDefaults(array(
+            'one' => '1',
+            'two' => function (Options $options) {
+                return '20';
+            },
+        ));
+
+        $this->assertEquals(array(
+            'one' => '1',
+            'two' => '20',
+        ), $this->resolver->resolve(array()));
+    }
+
+    public function testTypeAliasesForAllowedTypes()
+    {
+        $this->resolver->setDefaults(array(
+            'force' => false,
+        ));
+
+        $this->resolver->setAllowedTypes(array(
+            'force' => 'boolean',
+        ));
+
+        $this->resolver->resolve(array(
+            'force' => true,
+        ));
+    }
+
+    public function testResolveLazyDependencyOnOptional()
+    {
+        $this->resolver->setDefaults(array(
+            'one' => '1',
+            'two' => function (Options $options) {
+                return $options['one'].'2';
+            },
+        ));
+
+        $options = array(
+            'one' => '10',
+        );
+
+        $this->assertEquals(array(
+            'one' => '10',
+            'two' => '102',
+        ), $this->resolver->resolve($options));
+    }
+
+    public function testResolveLazyDependencyOnMissingOptionalWithoutDefault()
+    {
+        $test = $this;
+
+        $this->resolver->setOptional(array(
+            'one',
+        ));
+
+        $this->resolver->setDefaults(array(
+            'two' => function (Options $options) use ($test) {
+                /* @var \PHPUnit_Framework_TestCase $test */
+                $test->assertFalse(isset($options['one']));
+
+                return '2';
+            },
+        ));
+
+        $options = array();
+
+        $this->assertEquals(array(
+            'two' => '2',
+        ), $this->resolver->resolve($options));
+    }
+
+    public function testResolveLazyDependencyOnOptionalWithoutDefault()
+    {
+        $test = $this;
+
+        $this->resolver->setOptional(array(
+            'one',
+        ));
+
+        $this->resolver->setDefaults(array(
+            'two' => function (Options $options) use ($test) {
+                /* @var \PHPUnit_Framework_TestCase $test */
+                $test->assertTrue(isset($options['one']));
+
+                return $options['one'].'2';
+            },
+        ));
+
+        $options = array(
+            'one' => '10',
+        );
+
+        $this->assertEquals(array(
+            'one' => '10',
+            'two' => '102',
+        ), $this->resolver->resolve($options));
+    }
+
+    public function testResolveLazyDependencyOnRequired()
+    {
+        $this->resolver->setRequired(array(
+            'one',
+        ));
+        $this->resolver->setDefaults(array(
+            'two' => function (Options $options) {
+                return $options['one'].'2';
+            },
+        ));
+
+        $options = array(
+            'one' => '10',
+        );
+
+        $this->assertEquals(array(
+            'one' => '10',
+            'two' => '102',
+        ), $this->resolver->resolve($options));
+    }
+
+    public function testResolveLazyReplaceDefaults()
+    {
+        $test = $this;
+
+        $this->resolver->setDefaults(array(
+            'one' => function (Options $options) use ($test) {
+                /* @var \PHPUnit_Framework_TestCase $test */
+                $test->fail('Previous closure should not be executed');
+            },
+        ));
+
+        $this->resolver->replaceDefaults(array(
+            'one' => function (Options $options, $previousValue) {
+                return '1';
+            },
+        ));
+
+        $this->assertEquals(array(
+            'one' => '1',
+        ), $this->resolver->resolve(array()));
+    }
+
+    /**
+     * @expectedException        \Symfony\Component\OptionsResolver\Exception\UndefinedOptionsException
+     * @expectedExceptionMessage The option "foo" does not exist. Defined options are: "one", "three", "two".
+     */
+    public function testResolveFailsIfNonExistingOption()
+    {
+        $this->resolver->setDefaults(array(
+            'one' => '1',
+        ));
+
+        $this->resolver->setRequired(array(
+            'two',
+        ));
+
+        $this->resolver->setOptional(array(
+            'three',
+        ));
+
+        $this->resolver->resolve(array(
+            'foo' => 'bar',
+        ));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\OptionsResolver\Exception\MissingOptionsException
+     */
+    public function testResolveFailsIfMissingRequiredOption()
+    {
+        $this->resolver->setRequired(array(
+            'one',
+        ));
+
+        $this->resolver->setDefaults(array(
+            'two' => '2',
+        ));
+
+        $this->resolver->resolve(array(
+            'two' => '20',
+        ));
+    }
+
+    public function testResolveSucceedsIfOptionValueAllowed()
+    {
+        $this->resolver->setDefaults(array(
+            'one' => '1',
+        ));
+
+        $this->resolver->setAllowedValues(array(
+            'one' => array('1', 'one'),
+        ));
+
+        $options = array(
+            'one' => 'one',
+        );
+
+        $this->assertEquals(array(
+            'one' => 'one',
+        ), $this->resolver->resolve($options));
+    }
+
+    public function testResolveSucceedsIfOptionValueAllowed2()
+    {
+        $this->resolver->setDefaults(array(
+            'one' => '1',
+            'two' => '2',
+        ));
+
+        $this->resolver->setAllowedValues(array(
+            'one' => '1',
+            'two' => '2',
+        ));
+        $this->resolver->addAllowedValues(array(
+            'one' => 'one',
+            'two' => 'two',
+        ));
+
+        $options = array(
+            'one' => '1',
+            'two' => 'two',
+        );
+
+        $this->assertEquals(array(
+            'one' => '1',
+            'two' => 'two',
+        ), $this->resolver->resolve($options));
+    }
+
+    public function testResolveSucceedsIfOptionalWithAllowedValuesNotSet()
+    {
+        $this->resolver->setRequired(array(
+            'one',
+        ));
+
+        $this->resolver->setOptional(array(
+            'two',
+        ));
+
+        $this->resolver->setAllowedValues(array(
+            'one' => array('1', 'one'),
+            'two' => array('2', 'two'),
+        ));
+
+        $options = array(
+            'one' => '1',
+        );
+
+        $this->assertEquals(array(
+            'one' => '1',
+        ), $this->resolver->resolve($options));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException
+     */
+    public function testResolveFailsIfOptionValueNotAllowed()
+    {
+        $this->resolver->setDefaults(array(
+            'one' => '1',
+        ));
+
+        $this->resolver->setAllowedValues(array(
+            'one' => array('1', 'one'),
+        ));
+
+        $this->resolver->resolve(array(
+            'one' => '2',
+        ));
+    }
+
+    public function testResolveSucceedsIfOptionTypeAllowed()
+    {
+        $this->resolver->setDefaults(array(
+            'one' => '1',
+        ));
+
+        $this->resolver->setAllowedTypes(array(
+            'one' => 'string',
+        ));
+
+        $options = array(
+            'one' => 'one',
+        );
+
+        $this->assertEquals(array(
+            'one' => 'one',
+        ), $this->resolver->resolve($options));
+    }
+
+    public function testResolveSucceedsIfOptionTypeAllowedPassArray()
+    {
+        $this->resolver->setDefaults(array(
+            'one' => '1',
+        ));
+
+        $this->resolver->setAllowedTypes(array(
+            'one' => array('string', 'bool'),
+        ));
+
+        $options = array(
+            'one' => true,
+        );
+
+        $this->assertEquals(array(
+            'one' => true,
+        ), $this->resolver->resolve($options));
+    }
+
+    public function testResolveSucceedsIfOptionTypeAllowedPassObject()
+    {
+        $this->resolver->setDefaults(array(
+            'one' => '1',
+        ));
+
+        $this->resolver->setAllowedTypes(array(
+            'one' => 'object',
+        ));
+
+        $object = new \stdClass();
+        $options = array(
+            'one' => $object,
+        );
+
+        $this->assertEquals(array(
+            'one' => $object,
+        ), $this->resolver->resolve($options));
+    }
+
+    public function testResolveSucceedsIfOptionTypeAllowedPassClass()
+    {
+        $this->resolver->setDefaults(array(
+            'one' => '1',
+        ));
+
+        $this->resolver->setAllowedTypes(array(
+            'one' => '\stdClass',
+        ));
+
+        $object = new \stdClass();
+        $options = array(
+            'one' => $object,
+        );
+
+        $this->assertEquals(array(
+            'one' => $object,
+        ), $this->resolver->resolve($options));
+    }
+
+    public function testResolveSucceedsIfOptionTypeAllowedAddTypes()
+    {
+        $this->resolver->setDefaults(array(
+            'one' => '1',
+            'two' => '2',
+        ));
+
+        $this->resolver->setAllowedTypes(array(
+            'one' => 'string',
+            'two' => 'bool',
+        ));
+        $this->resolver->addAllowedTypes(array(
+            'one' => 'float',
+            'two' => 'integer',
+        ));
+
+        $options = array(
+            'one' => 1.23,
+            'two' => false,
+        );
+
+        $this->assertEquals(array(
+            'one' => 1.23,
+            'two' => false,
+        ), $this->resolver->resolve($options));
+    }
+
+    public function testResolveSucceedsIfOptionalWithTypeAndWithoutValue()
+    {
+        $this->resolver->setOptional(array(
+            'one',
+            'two',
+        ));
+
+        $this->resolver->setAllowedTypes(array(
+            'one' => 'string',
+            'two' => 'int',
+        ));
+
+        $options = array(
+            'two' => 1,
+        );
+
+        $this->assertEquals(array(
+            'two' => 1,
+        ), $this->resolver->resolve($options));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException
+     */
+    public function testResolveFailsIfOptionTypeNotAllowed()
+    {
+        $this->resolver->setDefaults(array(
+            'one' => '1',
+        ));
+
+        $this->resolver->setAllowedTypes(array(
+            'one' => array('string', 'bool'),
+        ));
+
+        $this->resolver->resolve(array(
+            'one' => 1.23,
+        ));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException
+     */
+    public function testResolveFailsIfOptionTypeNotAllowedMultipleOptions()
+    {
+        $this->resolver->setDefaults(array(
+            'one' => '1',
+            'two' => '2',
+        ));
+
+        $this->resolver->setAllowedTypes(array(
+            'one' => 'string',
+            'two' => 'bool',
+        ));
+
+        $this->resolver->resolve(array(
+            'one' => 'foo',
+            'two' => 1.23,
+        ));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException
+     */
+    public function testResolveFailsIfOptionTypeNotAllowedAddTypes()
+    {
+        $this->resolver->setDefaults(array(
+            'one' => '1',
+        ));
+
+        $this->resolver->setAllowedTypes(array(
+            'one' => 'string',
+        ));
+        $this->resolver->addAllowedTypes(array(
+            'one' => 'bool',
+        ));
+
+        $this->resolver->resolve(array(
+            'one' => 1.23,
+        ));
+    }
+
+    public function testFluidInterface()
+    {
+        $this->resolver->setDefaults(array('one' => '1'))
+            ->replaceDefaults(array('one' => '2'))
+            ->setAllowedValues(array('one' => array('1', '2')))
+            ->addAllowedValues(array('one' => array('3')))
+            ->setRequired(array('two'))
+            ->setOptional(array('three'));
+
+        $options = array(
+            'two' => '2',
+        );
+
+        $this->assertEquals(array(
+            'one' => '2',
+            'two' => '2',
+        ), $this->resolver->resolve($options));
+    }
+
+    public function testKnownIfDefaultWasSet()
+    {
+        $this->assertFalse($this->resolver->isKnown('foo'));
+
+        $this->resolver->setDefaults(array(
+            'foo' => 'bar',
+        ));
+
+        $this->assertTrue($this->resolver->isKnown('foo'));
+    }
+
+    public function testKnownIfRequired()
+    {
+        $this->assertFalse($this->resolver->isKnown('foo'));
+
+        $this->resolver->setRequired(array(
+            'foo',
+        ));
+
+        $this->assertTrue($this->resolver->isKnown('foo'));
+    }
+
+    public function testKnownIfOptional()
+    {
+        $this->assertFalse($this->resolver->isKnown('foo'));
+
+        $this->resolver->setOptional(array(
+            'foo',
+        ));
+
+        $this->assertTrue($this->resolver->isKnown('foo'));
+    }
+
+    public function testRequiredIfRequired()
+    {
+        $this->assertFalse($this->resolver->isRequired('foo'));
+
+        $this->resolver->setRequired(array(
+            'foo',
+        ));
+
+        $this->assertTrue($this->resolver->isRequired('foo'));
+    }
+
+    public function testNormalizersTransformFinalOptions()
+    {
+        $this->resolver->setDefaults(array(
+            'foo' => 'bar',
+            'bam' => 'baz',
+        ));
+        $this->resolver->setNormalizers(array(
+            'foo' => function (Options $options, $value) {
+                return $options['bam'].'['.$value.']';
+            },
+        ));
+
+        $expected = array(
+            'foo' => 'baz[bar]',
+            'bam' => 'baz',
+        );
+
+        $this->assertEquals($expected, $this->resolver->resolve(array()));
+
+        $expected = array(
+            'foo' => 'boo[custom]',
+            'bam' => 'boo',
+        );
+
+        $this->assertEquals($expected, $this->resolver->resolve(array(
+            'foo' => 'custom',
+            'bam' => 'boo',
+        )));
+    }
+
+    public function testResolveWithoutOptionSucceedsIfRequiredAndDefaultValue()
+    {
+        $this->resolver->setRequired(array(
+            'foo',
+        ));
+        $this->resolver->setDefaults(array(
+            'foo' => 'bar',
+        ));
+
+        $this->assertEquals(array(
+            'foo' => 'bar',
+        ), $this->resolver->resolve(array()));
+    }
+
+    public function testResolveWithoutOptionSucceedsIfDefaultValueAndRequired()
+    {
+        $this->resolver->setDefaults(array(
+            'foo' => 'bar',
+        ));
+        $this->resolver->setRequired(array(
+            'foo',
+        ));
+
+        $this->assertEquals(array(
+            'foo' => 'bar',
+        ), $this->resolver->resolve(array()));
+    }
+
+    public function testResolveSucceedsIfOptionRequiredAndValueAllowed()
+    {
+        $this->resolver->setRequired(array(
+            'one', 'two',
+        ));
+        $this->resolver->setAllowedValues(array(
+            'two' => array('2'),
+        ));
+
+        $options = array(
+            'one' => '1',
+            'two' => '2',
+        );
+
+        $this->assertEquals($options, $this->resolver->resolve($options));
+    }
+
+    public function testResolveSucceedsIfValueAllowedCallbackReturnsTrue()
+    {
+        $this->resolver->setRequired(array(
+            'test',
+        ));
+        $this->resolver->setAllowedValues(array(
+            'test' => function ($value) {
+                return true;
+            },
+        ));
+
+        $options = array(
+            'test' => true,
+        );
+
+        $this->assertEquals($options, $this->resolver->resolve($options));
+    }
+
+    /**
+     * @expectedException \Symfony\Component\OptionsResolver\Exception\InvalidOptionsException
+     */
+    public function testResolveFailsIfValueAllowedCallbackReturnsFalse()
+    {
+        $this->resolver->setRequired(array(
+            'test',
+        ));
+        $this->resolver->setAllowedValues(array(
+            'test' => function ($value) {
+                return false;
+            },
+        ));
+
+        $options = array(
+            'test' => true,
+        );
+
+        $this->assertEquals($options, $this->resolver->resolve($options));
+    }
+
+    public function testClone()
+    {
+        $this->resolver->setDefaults(array('one' => '1'));
+
+        $clone = clone $this->resolver;
+
+        // Changes after cloning don't affect each other
+        $this->resolver->setDefaults(array('two' => '2'));
+        $clone->setDefaults(array('three' => '3'));
+
+        $this->assertEquals(array(
+            'one' => '1',
+            'two' => '2',
+        ), $this->resolver->resolve());
+
+        $this->assertEquals(array(
+            'one' => '1',
+            'three' => '3',
+        ), $clone->resolve());
+    }
+
+    public function testOverloadReturnsThis()
+    {
+        $this->assertSame($this->resolver, $this->resolver->overload('foo', 'bar'));
+    }
+
+    public function testOverloadCallsSet()
+    {
+        $this->resolver->overload('foo', 'bar');
+
+        $this->assertSame(array('foo' => 'bar'), $this->resolver->resolve());
+    }
+}

library/symfony/options-resolver/Tests/LegacyOptionsTest.php

@@ -0,0 +1,337 @@
+<?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\Component\OptionsResolver\Tests;
+
+use Symfony\Component\OptionsResolver\Options;
+use Symfony\Component\OptionsResolver\OptionsResolver;
+
+/**
+ * @group legacy
+ */
+class LegacyOptionsTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var OptionsResolver
+     */
+    private $options;
+
+    protected function setUp()
+    {
+        $this->options = new OptionsResolver();
+    }
+
+    public function testSetLazyOption()
+    {
+        $test = $this;
+
+        $this->options->set('foo', function (Options $options) use ($test) {
+            return 'dynamic';
+        });
+
+        $this->assertEquals(array('foo' => 'dynamic'), $this->options->resolve());
+    }
+
+    public function testOverloadKeepsPreviousValue()
+    {
+        $test = $this;
+
+        // defined by superclass
+        $this->options->set('foo', 'bar');
+
+        // defined by subclass
+        $this->options->overload('foo', function (Options $options, $previousValue) use ($test) {
+            /* @var \PHPUnit_Framework_TestCase $test */
+            $test->assertEquals('bar', $previousValue);
+
+            return 'dynamic';
+        });
+
+        $this->assertEquals(array('foo' => 'dynamic'), $this->options->resolve());
+    }
+
+    public function testPreviousValueIsEvaluatedIfLazy()
+    {
+        $test = $this;
+
+        // defined by superclass
+        $this->options->set('foo', function (Options $options) {
+            return 'bar';
+        });
+
+        // defined by subclass
+        $this->options->overload('foo', function (Options $options, $previousValue) use ($test) {
+            /* @var \PHPUnit_Framework_TestCase $test */
+            $test->assertEquals('bar', $previousValue);
+
+            return 'dynamic';
+        });
+
+        $this->assertEquals(array('foo' => 'dynamic'), $this->options->resolve());
+    }
+
+    public function testPreviousValueIsNotEvaluatedIfNoSecondArgument()
+    {
+        $test = $this;
+
+        // defined by superclass
+        $this->options->set('foo', function (Options $options) use ($test) {
+            $test->fail('Should not be called');
+        });
+
+        // defined by subclass, no $previousValue argument defined!
+        $this->options->overload('foo', function (Options $options) use ($test) {
+            return 'dynamic';
+        });
+
+        $this->assertEquals(array('foo' => 'dynamic'), $this->options->resolve());
+    }
+
+    public function testLazyOptionCanAccessOtherOptions()
+    {
+        $test = $this;
+
+        $this->options->set('foo', 'bar');
+
+        $this->options->set('bam', function (Options $options) use ($test) {
+            /* @var \PHPUnit_Framework_TestCase $test */
+            $test->assertEquals('bar', $options->get('foo'));
+
+            return 'dynamic';
+        });
+
+        $this->assertEquals(array('foo' => 'bar', 'bam' => 'dynamic'), $this->options->resolve());
+    }
+
+    public function testLazyOptionCanAccessOtherLazyOptions()
+    {
+        $test = $this;
+
+        $this->options->set('foo', function (Options $options) {
+            return 'bar';
+        });
+
+        $this->options->set('bam', function (Options $options) use ($test) {
+            /* @var \PHPUnit_Framework_TestCase $test */
+            $test->assertEquals('bar', $options->get('foo'));
+
+            return 'dynamic';
+        });
+
+        $this->assertEquals(array('foo' => 'bar', 'bam' => 'dynamic'), $this->options->resolve());
+    }
+
+    public function testNormalizer()
+    {
+        $this->options->set('foo', 'bar');
+
+        $this->options->setNormalizer('foo', function () {
+            return 'normalized';
+        });
+
+        $this->assertEquals(array('foo' => 'normalized'), $this->options->resolve());
+    }
+
+    public function testNormalizerReceivesUnnormalizedValue()
+    {
+        $this->options->set('foo', 'bar');
+
+        $this->options->setNormalizer('foo', function (Options $options, $value) {
+            return 'normalized['.$value.']';
+        });
+
+        $this->assertEquals(array('foo' => 'normalized[bar]'), $this->options->resolve());
+    }
+
+    public function testNormalizerCanAccessOtherOptions()
+    {
+        $test = $this;
+
+        $this->options->set('foo', 'bar');
+        $this->options->set('bam', 'baz');
+
+        $this->options->setNormalizer('bam', function (Options $options) use ($test) {
+            /* @var \PHPUnit_Framework_TestCase $test */
+            $test->assertEquals('bar', $options->get('foo'));
+
+            return 'normalized';
+        });
+
+        $this->assertEquals(array('foo' => 'bar', 'bam' => 'normalized'), $this->options->resolve());
+    }
+
+    public function testNormalizerCanAccessOtherLazyOptions()
+    {
+        $test = $this;
+
+        $this->options->set('foo', function (Options $options) {
+            return 'bar';
+        });
+        $this->options->set('bam', 'baz');
+
+        $this->options->setNormalizer('bam', function (Options $options) use ($test) {
+            /* @var \PHPUnit_Framework_TestCase $test */
+            $test->assertEquals('bar', $options->get('foo'));
+
+            return 'normalized';
+        });
+
+        $this->assertEquals(array('foo' => 'bar', 'bam' => 'normalized'), $this->options->resolve());
+    }
+
+    /**
+     * @expectedException \Symfony\Component\OptionsResolver\Exception\OptionDefinitionException
+     */
+    public function testFailForCyclicDependencies()
+    {
+        $this->options->set('foo', function (Options $options) {
+            $options->get('bam');
+        });
+
+        $this->options->set('bam', function (Options $options) {
+            $options->get('foo');
+        });
+
+        $this->options->resolve();
+    }
+
+    /**
+     * @expectedException \Symfony\Component\OptionsResolver\Exception\OptionDefinitionException
+     */
+    public function testFailForCyclicDependenciesBetweenNormalizers()
+    {
+        $this->options->set('foo', 'bar');
+        $this->options->set('bam', 'baz');
+
+        $this->options->setNormalizer('foo', function (Options $options) {
+            $options->get('bam');
+        });
+
+        $this->options->setNormalizer('bam', function (Options $options) {
+            $options->get('foo');
+        });
+
+        $this->options->resolve();
+    }
+
+    /**
+     * @expectedException \Symfony\Component\OptionsResolver\Exception\OptionDefinitionException
+     */
+    public function testFailForCyclicDependenciesBetweenNormalizerAndLazyOption()
+    {
+        $this->options->set('foo', function (Options $options) {
+            $options->get('bam');
+        });
+        $this->options->set('bam', 'baz');
+
+        $this->options->setNormalizer('bam', function (Options $options) {
+            $options->get('foo');
+        });
+
+        $this->options->resolve();
+    }
+
+    public function testReplaceClearsAndSets()
+    {
+        $this->options->set('one', '1');
+
+        $this->options->replace(array(
+            'two' => '2',
+            'three' => function (Options $options) {
+                return '2' === $options['two'] ? '3' : 'foo';
+            },
+        ));
+
+        $this->assertEquals(array(
+            'two' => '2',
+            'three' => '3',
+        ), $this->options->resolve());
+    }
+
+    public function testClearRemovesAllOptions()
+    {
+        $this->options->set('one', 1);
+        $this->options->set('two', 2);
+
+        $this->options->clear();
+
+        $this->assertEmpty($this->options->resolve());
+    }
+
+    public function testOverloadCannotBeEvaluatedLazilyWithoutExpectedClosureParams()
+    {
+        $this->options->set('foo', 'bar');
+
+        $this->options->overload('foo', function () {
+            return 'test';
+        });
+
+        $resolved = $this->options->resolve();
+        $this->assertTrue(is_callable($resolved['foo']));
+    }
+
+    public function testOverloadCannotBeEvaluatedLazilyWithoutFirstParamTypeHint()
+    {
+        $this->options->set('foo', 'bar');
+
+        $this->options->overload('foo', function ($object) {
+            return 'test';
+        });
+
+        $resolved = $this->options->resolve();
+        $this->assertTrue(is_callable($resolved['foo']));
+    }
+
+    public function testRemoveOptionAndNormalizer()
+    {
+        $this->options->set('foo1', 'bar');
+        $this->options->setNormalizer('foo1', function (Options $options) {
+            return '';
+        });
+        $this->options->set('foo2', 'bar');
+        $this->options->setNormalizer('foo2', function (Options $options) {
+            return '';
+        });
+
+        $this->options->remove('foo2');
+        $this->assertEquals(array('foo1' => ''), $this->options->resolve());
+    }
+
+    public function testReplaceOptionAndNormalizer()
+    {
+        $this->options->set('foo1', 'bar');
+        $this->options->setNormalizer('foo1', function (Options $options) {
+            return '';
+        });
+        $this->options->set('foo2', 'bar');
+        $this->options->setNormalizer('foo2', function (Options $options) {
+            return '';
+        });
+
+        $this->options->replace(array('foo1' => 'new'));
+        $this->assertEquals(array('foo1' => 'new'), $this->options->resolve());
+    }
+
+    public function testClearOptionAndNormalizer()
+    {
+        $this->options->set('foo1', 'bar');
+        $this->options->setNormalizer('foo1', function (Options $options) {
+            return '';
+        });
+        $this->options->set('foo2', 'bar');
+        $this->options->setNormalizer('foo2', function (Options $options) {
+            return '';
+        });
+
+        $this->options->clear();
+        $this->assertEmpty($this->options->resolve());
+    }
+}

library/symfony/options-resolver/phpunit.xml.dist

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.1/phpunit.xsd"
+         backupGlobals="false"
+         colors="true"
+         bootstrap="vendor/autoload.php"
+>
+    <php>
+        <ini name="error_reporting" value="-1" />
+    </php>
+
+    <testsuites>
+        <testsuite name="Symfony OptionsResolver Component Test Suite">
+            <directory>./Tests/</directory>
+        </testsuite>
+    </testsuites>
+
+    <filter>
+        <whitelist>
+            <directory>./</directory>
+            <exclude>
+                <directory>./Resources</directory>
+                <directory>./Tests</directory>
+                <directory>./vendor</directory>
+            </exclude>
+        </whitelist>
+    </filter>
+</phpunit>