yaffs.net Git - yaffs-website/blob - vendor/symfony/config/Definition/ArrayNode.php

   1 <?php
   2
   3 /*
   4  * This file is part of the Symfony package.
   5  *
   6  * (c) Fabien Potencier <fabien@symfony.com>
   7  *
   8  * For the full copyright and license information, please view the LICENSE
   9  * file that was distributed with this source code.
  10  */
  11
  12 namespace Symfony\Component\Config\Definition;
  13
  14 use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
  15 use Symfony\Component\Config\Definition\Exception\InvalidTypeException;
  16 use Symfony\Component\Config\Definition\Exception\UnsetKeyException;
  17
  18 /**
  19  * Represents an Array node in the config tree.
  20  *
  21  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  22  */
  23 class ArrayNode extends BaseNode implements PrototypeNodeInterface
  24 {
  25     protected $xmlRemappings = array();
  26     protected $children = array();
  27     protected $allowFalse = false;
  28     protected $allowNewKeys = true;
  29     protected $addIfNotSet = false;
  30     protected $performDeepMerging = true;
  31     protected $ignoreExtraKeys = false;
  32     protected $removeExtraKeys = true;
  33     protected $normalizeKeys = true;
  34
  35     public function setNormalizeKeys($normalizeKeys)
  36     {
  37         $this->normalizeKeys = (bool) $normalizeKeys;
  38     }
  39
  40     /**
  41      * Normalizes keys between the different configuration formats.
  42      *
  43      * Namely, you mostly have foo_bar in YAML while you have foo-bar in XML.
  44      * After running this method, all keys are normalized to foo_bar.
  45      *
  46      * If you have a mixed key like foo-bar_moo, it will not be altered.
  47      * The key will also not be altered if the target key already exists.
  48      *
  49      * @param mixed $value
  50      *
  51      * @return array The value with normalized keys
  52      */
  53     protected function preNormalize($value)
  54     {
  55         if (!$this->normalizeKeys || !\is_array($value)) {
  56             return $value;
  57         }
  58
  59         $normalized = array();
  60
  61         foreach ($value as $k => $v) {
  62             if (false !== strpos($k, '-') && false === strpos($k, '_') && !array_key_exists($normalizedKey = str_replace('-', '_', $k), $value)) {
  63                 $normalized[$normalizedKey] = $v;
  64             } else {
  65                 $normalized[$k] = $v;
  66             }
  67         }
  68
  69         return $normalized;
  70     }
  71
  72     /**
  73      * Retrieves the children of this node.
  74      *
  75      * @return array The children
  76      */
  77     public function getChildren()
  78     {
  79         return $this->children;
  80     }
  81
  82     /**
  83      * Sets the xml remappings that should be performed.
  84      *
  85      * @param array $remappings An array of the form array(array(string, string))
  86      */
  87     public function setXmlRemappings(array $remappings)
  88     {
  89         $this->xmlRemappings = $remappings;
  90     }
  91
  92     /**
  93      * Gets the xml remappings that should be performed.
  94      *
  95      * @return array $remappings an array of the form array(array(string, string))
  96      */
  97     public function getXmlRemappings()
  98     {
  99         return $this->xmlRemappings;
 100     }
 101
 102     /**
 103      * Sets whether to add default values for this array if it has not been
 104      * defined in any of the configuration files.
 105      *
 106      * @param bool $boolean
 107      */
 108     public function setAddIfNotSet($boolean)
 109     {
 110         $this->addIfNotSet = (bool) $boolean;
 111     }
 112
 113     /**
 114      * Sets whether false is allowed as value indicating that the array should be unset.
 115      *
 116      * @param bool $allow
 117      */
 118     public function setAllowFalse($allow)
 119     {
 120         $this->allowFalse = (bool) $allow;
 121     }
 122
 123     /**
 124      * Sets whether new keys can be defined in subsequent configurations.
 125      *
 126      * @param bool $allow
 127      */
 128     public function setAllowNewKeys($allow)
 129     {
 130         $this->allowNewKeys = (bool) $allow;
 131     }
 132
 133     /**
 134      * Sets if deep merging should occur.
 135      *
 136      * @param bool $boolean
 137      */
 138     public function setPerformDeepMerging($boolean)
 139     {
 140         $this->performDeepMerging = (bool) $boolean;
 141     }
 142
 143     /**
 144      * Whether extra keys should just be ignore without an exception.
 145      *
 146      * @param bool $boolean To allow extra keys
 147      * @param bool $remove  To remove extra keys
 148      */
 149     public function setIgnoreExtraKeys($boolean, $remove = true)
 150     {
 151         $this->ignoreExtraKeys = (bool) $boolean;
 152         $this->removeExtraKeys = $this->ignoreExtraKeys && $remove;
 153     }
 154
 155     /**
 156      * {@inheritdoc}
 157      */
 158     public function setName($name)
 159     {
 160         $this->name = $name;
 161     }
 162
 163     /**
 164      * {@inheritdoc}
 165      */
 166     public function hasDefaultValue()
 167     {
 168         return $this->addIfNotSet;
 169     }
 170
 171     /**
 172      * {@inheritdoc}
 173      */
 174     public function getDefaultValue()
 175     {
 176         if (!$this->hasDefaultValue()) {
 177             throw new \RuntimeException(sprintf('The node at path "%s" has no default value.', $this->getPath()));
 178         }
 179
 180         $defaults = array();
 181         foreach ($this->children as $name => $child) {
 182             if ($child->hasDefaultValue()) {
 183                 $defaults[$name] = $child->getDefaultValue();
 184             }
 185         }
 186
 187         return $defaults;
 188     }
 189
 190     /**
 191      * Adds a child node.
 192      *
 193      * @throws \InvalidArgumentException when the child node has no name
 194      * @throws \InvalidArgumentException when the child node's name is not unique
 195      */
 196     public function addChild(NodeInterface $node)
 197     {
 198         $name = $node->getName();
 199         if (!\strlen($name)) {
 200             throw new \InvalidArgumentException('Child nodes must be named.');
 201         }
 202         if (isset($this->children[$name])) {
 203             throw new \InvalidArgumentException(sprintf('A child node named "%s" already exists.', $name));
 204         }
 205
 206         $this->children[$name] = $node;
 207     }
 208
 209     /**
 210      * Finalizes the value of this node.
 211      *
 212      * @param mixed $value
 213      *
 214      * @return mixed The finalised value
 215      *
 216      * @throws UnsetKeyException
 217      * @throws InvalidConfigurationException if the node doesn't have enough children
 218      */
 219     protected function finalizeValue($value)
 220     {
 221         if (false === $value) {
 222             throw new UnsetKeyException(sprintf('Unsetting key for path "%s", value: %s', $this->getPath(), json_encode($value)));
 223         }
 224
 225         foreach ($this->children as $name => $child) {
 226             if (!array_key_exists($name, $value)) {
 227                 if ($child->isRequired()) {
 228                     $ex = new InvalidConfigurationException(sprintf('The child node "%s" at path "%s" must be configured.', $name, $this->getPath()));
 229                     $ex->setPath($this->getPath());
 230
 231                     throw $ex;
 232                 }
 233
 234                 if ($child->hasDefaultValue()) {
 235                     $value[$name] = $child->getDefaultValue();
 236                 }
 237
 238                 continue;
 239             }
 240
 241             if ($child->isDeprecated()) {
 242                 @trigger_error($child->getDeprecationMessage($name, $this->getPath()), E_USER_DEPRECATED);
 243             }
 244
 245             try {
 246                 $value[$name] = $child->finalize($value[$name]);
 247             } catch (UnsetKeyException $e) {
 248                 unset($value[$name]);
 249             }
 250         }
 251
 252         return $value;
 253     }
 254
 255     /**
 256      * Validates the type of the value.
 257      *
 258      * @param mixed $value
 259      *
 260      * @throws InvalidTypeException
 261      */
 262     protected function validateType($value)
 263     {
 264         if (!\is_array($value) && (!$this->allowFalse || false !== $value)) {
 265             $ex = new InvalidTypeException(sprintf('Invalid type for path "%s". Expected array, but got %s', $this->getPath(), \gettype($value)));
 266             if ($hint = $this->getInfo()) {
 267                 $ex->addHint($hint);
 268             }
 269             $ex->setPath($this->getPath());
 270
 271             throw $ex;
 272         }
 273     }
 274
 275     /**
 276      * Normalizes the value.
 277      *
 278      * @param mixed $value The value to normalize
 279      *
 280      * @return mixed The normalized value
 281      *
 282      * @throws InvalidConfigurationException
 283      */
 284     protected function normalizeValue($value)
 285     {
 286         if (false === $value) {
 287             return $value;
 288         }
 289
 290         $value = $this->remapXml($value);
 291
 292         $normalized = array();
 293         foreach ($value as $name => $val) {
 294             if (isset($this->children[$name])) {
 295                 $normalized[$name] = $this->children[$name]->normalize($val);
 296                 unset($value[$name]);
 297             } elseif (!$this->removeExtraKeys) {
 298                 $normalized[$name] = $val;
 299             }
 300         }
 301
 302         // if extra fields are present, throw exception
 303         if (\count($value) && !$this->ignoreExtraKeys) {
 304             $ex = new InvalidConfigurationException(sprintf('Unrecognized option%s "%s" under "%s"', 1 === \count($value) ? '' : 's', implode(', ', array_keys($value)), $this->getPath()));
 305             $ex->setPath($this->getPath());
 306
 307             throw $ex;
 308         }
 309
 310         return $normalized;
 311     }
 312
 313     /**
 314      * Remaps multiple singular values to a single plural value.
 315      *
 316      * @param array $value The source values
 317      *
 318      * @return array The remapped values
 319      */
 320     protected function remapXml($value)
 321     {
 322         foreach ($this->xmlRemappings as list($singular, $plural)) {
 323             if (!isset($value[$singular])) {
 324                 continue;
 325             }
 326
 327             $value[$plural] = Processor::normalizeConfig($value, $singular, $plural);
 328             unset($value[$singular]);
 329         }
 330
 331         return $value;
 332     }
 333
 334     /**
 335      * Merges values together.
 336      *
 337      * @param mixed $leftSide  The left side to merge
 338      * @param mixed $rightSide The right side to merge
 339      *
 340      * @return mixed The merged values
 341      *
 342      * @throws InvalidConfigurationException
 343      * @throws \RuntimeException
 344      */
 345     protected function mergeValues($leftSide, $rightSide)
 346     {
 347         if (false === $rightSide) {
 348             // if this is still false after the last config has been merged the
 349             // finalization pass will take care of removing this key entirely
 350             return false;
 351         }
 352
 353         if (false === $leftSide || !$this->performDeepMerging) {
 354             return $rightSide;
 355         }
 356
 357         foreach ($rightSide as $k => $v) {
 358             // no conflict
 359             if (!array_key_exists($k, $leftSide)) {
 360                 if (!$this->allowNewKeys) {
 361                     $ex = new InvalidConfigurationException(sprintf('You are not allowed to define new elements for path "%s". Please define all elements for this path in one config file. If you are trying to overwrite an element, make sure you redefine it with the same name.', $this->getPath()));
 362                     $ex->setPath($this->getPath());
 363
 364                     throw $ex;
 365                 }
 366
 367                 $leftSide[$k] = $v;
 368                 continue;
 369             }
 370
 371             if (!isset($this->children[$k])) {
 372                 throw new \RuntimeException('merge() expects a normalized config array.');
 373             }
 374
 375             $leftSide[$k] = $this->children[$k]->merge($leftSide[$k], $v);
 376         }
 377
 378         return $leftSide;
 379     }
 380 }