79ceb094f0
Deleting an extra space in the exception.
347 lines
9.3 KiB
PHP
347 lines
9.3 KiB
PHP
<?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\OptionDefinitionException;
|
|
use Symfony\Component\OptionsResolver\Exception\InvalidOptionsException;
|
|
use Symfony\Component\OptionsResolver\Exception\MissingOptionsException;
|
|
|
|
/**
|
|
* Helper for merging default and concrete option values.
|
|
*
|
|
* @author Bernhard Schussek <bschussek@gmail.com>
|
|
* @author Tobias Schultze <http://tobion.de>
|
|
*/
|
|
class OptionsResolver implements OptionsResolverInterface
|
|
{
|
|
/**
|
|
* The default option values.
|
|
* @var Options
|
|
*/
|
|
private $defaultOptions;
|
|
|
|
/**
|
|
* The options known by the resolver.
|
|
* @var array
|
|
*/
|
|
private $knownOptions = array();
|
|
|
|
/**
|
|
* The options without defaults that are required to be passed to resolve().
|
|
* @var array
|
|
*/
|
|
private $requiredOptions = array();
|
|
|
|
/**
|
|
* A list of accepted values for each option.
|
|
* @var array
|
|
*/
|
|
private $allowedValues = array();
|
|
|
|
/**
|
|
* A list of accepted types for each option.
|
|
* @var array
|
|
*/
|
|
private $allowedTypes = array();
|
|
|
|
/**
|
|
* Creates a new instance.
|
|
*/
|
|
public function __construct()
|
|
{
|
|
$this->defaultOptions = new Options();
|
|
}
|
|
|
|
/**
|
|
* Clones the resolver.
|
|
*/
|
|
public function __clone()
|
|
{
|
|
$this->defaultOptions = clone $this->defaultOptions;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function setDefaults(array $defaultValues)
|
|
{
|
|
foreach ($defaultValues as $option => $value) {
|
|
$this->defaultOptions->overload($option, $value);
|
|
$this->knownOptions[$option] = true;
|
|
unset($this->requiredOptions[$option]);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function replaceDefaults(array $defaultValues)
|
|
{
|
|
foreach ($defaultValues as $option => $value) {
|
|
$this->defaultOptions->set($option, $value);
|
|
$this->knownOptions[$option] = true;
|
|
unset($this->requiredOptions[$option]);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function setOptional(array $optionNames)
|
|
{
|
|
foreach ($optionNames as $key => $option) {
|
|
if (!is_int($key)) {
|
|
throw new OptionDefinitionException('You should not pass default values to setOptional()');
|
|
}
|
|
|
|
$this->knownOptions[$option] = true;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function setRequired(array $optionNames)
|
|
{
|
|
foreach ($optionNames as $key => $option) {
|
|
if (!is_int($key)) {
|
|
throw new OptionDefinitionException('You should not pass default values to setRequired()');
|
|
}
|
|
|
|
$this->knownOptions[$option] = true;
|
|
// set as required if no default has been set already
|
|
if (!isset($this->defaultOptions[$option])) {
|
|
$this->requiredOptions[$option] = true;
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function setAllowedValues(array $allowedValues)
|
|
{
|
|
$this->validateOptionsExistence($allowedValues);
|
|
|
|
$this->allowedValues = array_replace($this->allowedValues, $allowedValues);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function addAllowedValues(array $allowedValues)
|
|
{
|
|
$this->validateOptionsExistence($allowedValues);
|
|
|
|
$this->allowedValues = array_merge_recursive($this->allowedValues, $allowedValues);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function setAllowedTypes(array $allowedTypes)
|
|
{
|
|
$this->validateOptionsExistence($allowedTypes);
|
|
|
|
$this->allowedTypes = array_replace($this->allowedTypes, $allowedTypes);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function addAllowedTypes(array $allowedTypes)
|
|
{
|
|
$this->validateOptionsExistence($allowedTypes);
|
|
|
|
$this->allowedTypes = array_merge_recursive($this->allowedTypes, $allowedTypes);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function setNormalizers(array $normalizers)
|
|
{
|
|
$this->validateOptionsExistence($normalizers);
|
|
|
|
foreach ($normalizers as $option => $normalizer) {
|
|
$this->defaultOptions->setNormalizer($option, $normalizer);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function isKnown($option)
|
|
{
|
|
return isset($this->knownOptions[$option]);
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function isRequired($option)
|
|
{
|
|
return isset($this->requiredOptions[$option]);
|
|
}
|
|
|
|
/**
|
|
* {@inheritdoc}
|
|
*/
|
|
public function resolve(array $options = array())
|
|
{
|
|
$this->validateOptionsExistence($options);
|
|
$this->validateOptionsCompleteness($options);
|
|
|
|
// Make sure this method can be called multiple times
|
|
$combinedOptions = clone $this->defaultOptions;
|
|
|
|
// Override options set by the user
|
|
foreach ($options as $option => $value) {
|
|
$combinedOptions->set($option, $value);
|
|
}
|
|
|
|
// Resolve options
|
|
$resolvedOptions = $combinedOptions->all();
|
|
|
|
$this->validateOptionValues($resolvedOptions);
|
|
$this->validateOptionTypes($resolvedOptions);
|
|
|
|
return $resolvedOptions;
|
|
}
|
|
|
|
/**
|
|
* Validates that the given option names exist and throws an exception
|
|
* otherwise.
|
|
*
|
|
* @param array $options An list of option names as keys.
|
|
*
|
|
* @throws InvalidOptionsException If any of the options has not been defined.
|
|
*/
|
|
private function validateOptionsExistence(array $options)
|
|
{
|
|
$diff = array_diff_key($options, $this->knownOptions);
|
|
|
|
if (count($diff) > 0) {
|
|
ksort($this->knownOptions);
|
|
ksort($diff);
|
|
|
|
throw new InvalidOptionsException(sprintf(
|
|
(count($diff) > 1 ? 'The options "%s" do not exist.' : 'The option "%s" does not exist.').' Known options are: "%s"',
|
|
implode('", "', array_keys($diff)),
|
|
implode('", "', array_keys($this->knownOptions))
|
|
));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validates that all required options are given and throws an exception
|
|
* otherwise.
|
|
*
|
|
* @param array $options An list of option names as keys.
|
|
*
|
|
* @throws MissingOptionsException If a required option is missing.
|
|
*/
|
|
private function validateOptionsCompleteness(array $options)
|
|
{
|
|
$diff = array_diff_key($this->requiredOptions, $options);
|
|
|
|
if (count($diff) > 0) {
|
|
ksort($diff);
|
|
|
|
throw new MissingOptionsException(sprintf(
|
|
count($diff) > 1 ? 'The required options "%s" are missing.' : 'The required option "%s" is missing.',
|
|
implode('", "', array_keys($diff))
|
|
));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validates that the given option values match the allowed values and
|
|
* throws an exception otherwise.
|
|
*
|
|
* @param array $options A list of option values.
|
|
*
|
|
* @throws InvalidOptionsException If any of the values does not match the
|
|
* allowed values of the option.
|
|
*/
|
|
private function validateOptionValues(array $options)
|
|
{
|
|
foreach ($this->allowedValues as $option => $allowedValues) {
|
|
if (isset($options[$option]) && !in_array($options[$option], $allowedValues, true)) {
|
|
throw new InvalidOptionsException(sprintf('The option "%s" has the value "%s", but is expected to be one of "%s"', $option, $options[$option], implode('", "', $allowedValues)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validates that the given options match the allowed types and
|
|
* throws an exception otherwise.
|
|
*
|
|
* @param array $options A list of options.
|
|
*
|
|
* @throws InvalidOptionsException If any of the types does not match the
|
|
* allowed types of the option.
|
|
*/
|
|
private function validateOptionTypes(array $options)
|
|
{
|
|
foreach ($this->allowedTypes as $option => $allowedTypes) {
|
|
if (!array_key_exists($option, $options)) {
|
|
continue;
|
|
}
|
|
|
|
$value = $options[$option];
|
|
$allowedTypes = (array) $allowedTypes;
|
|
|
|
foreach ($allowedTypes as $type) {
|
|
$isFunction = 'is_'.$type;
|
|
|
|
if (function_exists($isFunction) && $isFunction($value)) {
|
|
continue 2;
|
|
} elseif ($value instanceof $type) {
|
|
continue 2;
|
|
}
|
|
}
|
|
|
|
$printableValue = is_object($value)
|
|
? get_class($value)
|
|
: (is_array($value)
|
|
? 'Array'
|
|
: (string) $value);
|
|
|
|
throw new InvalidOptionsException(sprintf(
|
|
'The option "%s" with value "%s" is expected to be of type "%s"',
|
|
$option,
|
|
$printableValue,
|
|
implode('", "', $allowedTypes)
|
|
));
|
|
}
|
|
}
|
|
}
|