vendor/symfony/config/Definition/ArrayNode.php line 227

Open in your IDE?
  1. <?php
  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.  */
  12. namespace Symfony\Component\Config\Definition;
  14. use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
  15. use Symfony\Component\Config\Definition\Exception\InvalidTypeException;
  16. use Symfony\Component\Config\Definition\Exception\UnsetKeyException;
  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 {
  25.     protected $xmlRemappings = [];
  26.     protected $children = [];
  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;
  35.     public function setNormalizeKeys($normalizeKeys) {
  36.         $this->normalizeKeys = (bool) $normalizeKeys;
  37.     }
  39.     /**
  40.      * Normalizes keys between the different configuration formats.
  41.      *
  42.      * Namely, you mostly have foo_bar in YAML while you have foo-bar in XML.
  43.      * After running this method, all keys are normalized to foo_bar.
  44.      *
  45.      * If you have a mixed key like foo-bar_moo, it will not be altered.
  46.      * The key will also not be altered if the target key already exists.
  47.      *
  48.      * @param mixed $value
  49.      *
  50.      * @return array The value with normalized keys
  51.      */
  52.     protected function preNormalize($value) {
  53.         if (!$this->normalizeKeys || !\is_array($value)) {
  54.             return $value;
  55.         }
  57.         $normalized = [];
  59.         foreach ($value as $k => $v) {
  60.             if (false !== strpos($k, '-') && false === strpos($k, '_') && !\array_key_exists($normalizedKey = str_replace('-', '_', $k), $value)) {
  61.                 $normalized[$normalizedKey] = $v;
  62.             } else {
  63.                 $normalized[$k] = $v;
  64.             }
  65.         }
  67.         return $normalized;
  68.     }
  70.     /**
  71.      * Retrieves the children of this node.
  72.      *
  73.      * @return array The children
  74.      */
  75.     public function getChildren() {
  76.         return $this->children;
  77.     }
  79.     /**
  80.      * Sets the xml remappings that should be performed.
  81.      *
  82.      * @param array $remappings An array of the form [[string, string]]
  83.      */
  84.     public function setXmlRemappings(array $remappings) {
  85.         $this->xmlRemappings = $remappings;
  86.     }
  88.     /**
  89.      * Gets the xml remappings that should be performed.
  90.      *
  91.      * @return array an array of the form [[string, string]]
  92.      */
  93.     public function getXmlRemappings() {
  94.         return $this->xmlRemappings;
  95.     }
  97.     /**
  98.      * Sets whether to add default values for this array if it has not been
  99.      * defined in any of the configuration files.
  100.      *
  101.      * @param bool $boolean
  102.      */
  103.     public function setAddIfNotSet($boolean) {
  104.         $this->addIfNotSet = (bool) $boolean;
  105.     }
  107.     /**
  108.      * Sets whether false is allowed as value indicating that the array should be unset.
  109.      *
  110.      * @param bool $allow
  111.      */
  112.     public function setAllowFalse($allow) {
  113.         $this->allowFalse = (bool) $allow;
  114.     }
  116.     /**
  117.      * Sets whether new keys can be defined in subsequent configurations.
  118.      *
  119.      * @param bool $allow
  120.      */
  121.     public function setAllowNewKeys($allow) {
  122.         $this->allowNewKeys = (bool) $allow;
  123.     }
  125.     /**
  126.      * Sets if deep merging should occur.
  127.      *
  128.      * @param bool $boolean
  129.      */
  130.     public function setPerformDeepMerging($boolean) {
  131.         $this->performDeepMerging = (bool) $boolean;
  132.     }
  134.     /**
  135.      * Whether extra keys should just be ignored without an exception.
  136.      *
  137.      * @param bool $boolean To allow extra keys
  138.      * @param bool $remove  To remove extra keys
  139.      */
  140.     public function setIgnoreExtraKeys($boolean, $remove = true) {
  141.         $this->ignoreExtraKeys = (bool) $boolean;
  142.         $this->removeExtraKeys = $this->ignoreExtraKeys && $remove;
  143.     }
  145.     /**
  146.      * {@inheritdoc}
  147.      */
  148.     public function setName($name) {
  149.         $this->name = $name;
  150.     }
  152.     /**
  153.      * {@inheritdoc}
  154.      */
  155.     public function hasDefaultValue() {
  156.         return $this->addIfNotSet;
  157.     }
  159.     /**
  160.      * {@inheritdoc}
  161.      */
  162.     public function getDefaultValue() {
  163.         if (!$this->hasDefaultValue()) {
  164.             throw new \RuntimeException(sprintf('The node at path "%s" has no default value.', $this->getPath()));
  165.         }
  167.         $defaults = [];
  168.         foreach ($this->children as $name => $child) {
  169.             if ($child->hasDefaultValue()) {
  170.                 $defaults[$name] = $child->getDefaultValue();
  171.             }
  172.         }
  174.         return $defaults;
  175.     }
  177.     /**
  178.      * Adds a child node.
  179.      *
  180.      * @throws \InvalidArgumentException when the child node has no name
  181.      * @throws \InvalidArgumentException when the child node's name is not unique
  182.      */
  183.     public function addChild(NodeInterface $node) {
  184.         $name = $node->getName();
  185.         if (!\strlen($name)) {
  186.             throw new \InvalidArgumentException('Child nodes must be named.');
  187.         }
  188.         if (isset($this->children[$name])) {
  189.             throw new \InvalidArgumentException(sprintf('A child node named "%s" already exists.', $name));
  190.         }
  192.         $this->children[$name] = $node;
  193.     }
  195.     /**
  196.      * Finalizes the value of this node.
  197.      *
  198.      * @param mixed $value
  199.      *
  200.      * @return mixed The finalised value
  201.      *
  202.      * @throws UnsetKeyException
  203.      * @throws InvalidConfigurationException if the node doesn't have enough children
  204.      */
  205.     protected function finalizeValue($value) {
  206.         if (false === $value) {
  207.             throw new UnsetKeyException(sprintf('Unsetting key for path "%s", value: %s', $this->getPath(), json_encode($value)));
  208.         }
  210.         foreach ($this->children as $name => $child) {
  211.             if (!\array_key_exists($name, $value)) {
  212.                 if ($child->isRequired()) {
  213.                     $ex = new InvalidConfigurationException(sprintf('The child node "%s" at path "%s" must be configured.', $name, $this->getPath()));
  214.                     $ex->setPath($this->getPath());
  216.                     throw $ex;
  217.                 }
  219.                 if ($child->hasDefaultValue()) {
  220.                     $value[$name] = $child->getDefaultValue();
  221.                 }
  223.                 continue;
  224.             }
  226.             if ($child->isDeprecated()) {
  227.                 @trigger_error($child->getDeprecationMessage($name, $this->getPath()), E_USER_DEPRECATED);
  228.             }
  230.             try {
  231.                 $value[$name] = $child->finalize($value[$name]);
  232.             } catch (UnsetKeyException $e) {
  233.                 unset($value[$name]);
  234.             }
  235.         }
  237.         return $value;
  238.     }
  240.     /**
  241.      * Validates the type of the value.
  242.      *
  243.      * @param mixed $value
  244.      *
  245.      * @throws InvalidTypeException
  246.      */
  247.     protected function validateType($value) {
  248.         if (!\is_array($value) && (!$this->allowFalse || false !== $value)) {
  249.             $ex = new InvalidTypeException(sprintf('Invalid type for path "%s". Expected array, but got %s', $this->getPath(), \gettype($value)));
  250.             if ($hint = $this->getInfo()) {
  251.                 $ex->addHint($hint);
  252.             }
  253.             $ex->setPath($this->getPath());
  255.             throw $ex;
  256.         }
  257.     }
  259.     /**
  260.      * Normalizes the value.
  261.      *
  262.      * @param mixed $value The value to normalize
  263.      *
  264.      * @return mixed The normalized value
  265.      *
  266.      * @throws InvalidConfigurationException
  267.      */
  268.     protected function normalizeValue($value) {
  269.         if (false === $value) {
  270.             return $value;
  271.         }
  273.         $value = $this->remapXml($value);
  275.         $normalized = [];
  276.         foreach ($value as $name => $val) {
  277.             if (isset($this->children[$name])) {
  278.                 try {
  279.                     $normalized[$name] = $this->children[$name]->normalize($val);
  280.                 } catch (UnsetKeyException $e) {
  281.                     
  282.                 }
  283.                 unset($value[$name]);
  284.             } elseif (!$this->removeExtraKeys) {
  285.                 $normalized[$name] = $val;
  286.             }
  287.         }
  289.         // if extra fields are present, throw exception
  290.         if (\count($value) && !$this->ignoreExtraKeys) {
  291.             $proposals = array_keys($this->children);
  292.             sort($proposals);
  293.             $guesses = [];
  295.             foreach (array_keys($value) as $subject) {
  296.                 $minScore = INF;
  297.                 foreach ($proposals as $proposal) {
  298.                     $distance = levenshtein($subject, $proposal);
  299.                     if ($distance <= $minScore && $distance < 3) {
  300.                         $guesses[$proposal] = $distance;
  301.                         $minScore = $distance;
  302.                     }
  303.                 }
  304.             }
  306.             $msg = sprintf('Unrecognized option%s "%s" under "%s"', 1 === \count($value) ? '' : 's', implode(', ', array_keys($value)), $this->getPath());
  308.             if (\count($guesses)) {
  309.                 asort($guesses);
  310.                 $msg .= sprintf('. Did you mean "%s"?', implode('", "', array_keys($guesses)));
  311.             } else {
  312.                 $msg .= sprintf('. Available option%s %s "%s".', 1 === \count($proposals) ? '' : 's', 1 === \count($proposals) ? 'is' : 'are', implode('", "', $proposals));
  313.             }
  315.             $ex = new InvalidConfigurationException($msg);
  316.             $ex->setPath($this->getPath());
  318.             throw $ex;
  319.         }
  321.         return $normalized;
  322.     }
  324.     /**
  325.      * Remaps multiple singular values to a single plural value.
  326.      *
  327.      * @param array $value The source values
  328.      *
  329.      * @return array The remapped values
  330.      */
  331.     protected function remapXml($value) {
  332.         foreach ($this->xmlRemappings as list($singular, $plural)) {
  333.             if (!isset($value[$singular])) {
  334.                 continue;
  335.             }
  337.             $value[$plural] = Processor::normalizeConfig($value, $singular, $plural);
  338.             unset($value[$singular]);
  339.         }
  341.         return $value;
  342.     }
  344.     /**
  345.      * Merges values together.
  346.      *
  347.      * @param mixed $leftSide  The left side to merge
  348.      * @param mixed $rightSide The right side to merge
  349.      *
  350.      * @return mixed The merged values
  351.      *
  352.      * @throws InvalidConfigurationException
  353.      * @throws \RuntimeException
  354.      */
  355.     protected function mergeValues($leftSide, $rightSide) {
  356.         if (false === $rightSide) {
  357.             // if this is still false after the last config has been merged the
  358.             // finalization pass will take care of removing this key entirely
  359.             return false;
  360.         }
  362.         if (false === $leftSide || !$this->performDeepMerging) {
  363.             return $rightSide;
  364.         }
  366.         foreach ($rightSide as $k => $v) {
  367.             // no conflict
  368.             if (!\array_key_exists($k, $leftSide)) {
  369.                 if (!$this->allowNewKeys) {
  370.                     $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()));
  371.                     $ex->setPath($this->getPath());
  373.                     throw $ex;
  374.                 }
  376.                 $leftSide[$k] = $v;
  377.                 continue;
  378.             }
  380.             if (!isset($this->children[$k])) {
  381.                 throw new \RuntimeException('merge() expects a normalized config array.');
  382.             }
  384.             $leftSide[$k] = $this->children[$k]->merge($leftSide[$k], $v);
  385.         }
  387.         return $leftSide;
  388.     }
  390.     /**
  391.      * {@inheritdoc}
  392.      */
  393.     protected function allowPlaceholders(): bool {
  394.         return false;
  395.     }
  397. }