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

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <[email protected]>
  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 <[email protected]>
  22.  */
  23. class ArrayNode extends BaseNode implements PrototypeNodeInterface
  24. {
  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(bool $normalizeKeys)
  36.     {
  37.         $this->normalizeKeys = $normalizeKeys;
  38.     }
  40.     /**
  41.      * {@inheritdoc}
  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.     protected function preNormalize($value)
  50.     {
  51.         if (!$this->normalizeKeys || !\is_array($value)) {
  52.             return $value;
  53.         }
  55.         $normalized = [];
  57.         foreach ($value as $k => $v) {
  58.             if (str_contains($k, '-') && !str_contains($k, '_') && !\array_key_exists($normalizedKey = str_replace('-', '_', $k), $value)) {
  59.                 $normalized[$normalizedKey] = $v;
  60.             } else {
  61.                 $normalized[$k] = $v;
  62.             }
  63.         }
  65.         return $normalized;
  66.     }
  68.     /**
  69.      * Retrieves the children of this node.
  70.      *
  71.      * @return array<string, NodeInterface>
  72.      */
  73.     public function getChildren()
  74.     {
  75.         return $this->children;
  76.     }
  78.     /**
  79.      * Sets the xml remappings that should be performed.
  80.      *
  81.      * @param array $remappings An array of the form [[string, string]]
  82.      */
  83.     public function setXmlRemappings(array $remappings)
  84.     {
  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.     {
  95.         return $this->xmlRemappings;
  96.     }
  98.     /**
  99.      * Sets whether to add default values for this array if it has not been
  100.      * defined in any of the configuration files.
  101.      */
  102.     public function setAddIfNotSet(bool $boolean)
  103.     {
  104.         $this->addIfNotSet = $boolean;
  105.     }
  107.     /**
  108.      * Sets whether false is allowed as value indicating that the array should be unset.
  109.      */
  110.     public function setAllowFalse(bool $allow)
  111.     {
  112.         $this->allowFalse = $allow;
  113.     }
  115.     /**
  116.      * Sets whether new keys can be defined in subsequent configurations.
  117.      */
  118.     public function setAllowNewKeys(bool $allow)
  119.     {
  120.         $this->allowNewKeys = $allow;
  121.     }
  123.     /**
  124.      * Sets if deep merging should occur.
  125.      */
  126.     public function setPerformDeepMerging(bool $boolean)
  127.     {
  128.         $this->performDeepMerging = $boolean;
  129.     }
  131.     /**
  132.      * Whether extra keys should just be ignored without an exception.
  133.      *
  134.      * @param bool $boolean To allow extra keys
  135.      * @param bool $remove  To remove extra keys
  136.      */
  137.     public function setIgnoreExtraKeys(bool $boolean, bool $remove = true)
  138.     {
  139.         $this->ignoreExtraKeys = $boolean;
  140.         $this->removeExtraKeys = $this->ignoreExtraKeys && $remove;
  141.     }
  143.     /**
  144.      * {@inheritdoc}
  145.      */
  146.     public function setName(string $name)
  147.     {
  148.         $this->name = $name;
  149.     }
  151.     /**
  152.      * {@inheritdoc}
  153.      */
  154.     public function hasDefaultValue()
  155.     {
  156.         return $this->addIfNotSet;
  157.     }
  159.     /**
  160.      * {@inheritdoc}
  161.      */
  162.     public function getDefaultValue()
  163.     {
  164.         if (!$this->hasDefaultValue()) {
  165.             throw new \RuntimeException(sprintf('The node at path "%s" has no default value.', $this->getPath()));
  166.         }
  168.         $defaults = [];
  169.         foreach ($this->children as $name => $child) {
  170.             if ($child->hasDefaultValue()) {
  171.                 $defaults[$name] = $child->getDefaultValue();
  172.             }
  173.         }
  175.         return $defaults;
  176.     }
  178.     /**
  179.      * Adds a child node.
  180.      *
  181.      * @throws \InvalidArgumentException when the child node has no name
  182.      * @throws \InvalidArgumentException when the child node's name is not unique
  183.      */
  184.     public function addChild(NodeInterface $node)
  185.     {
  186.         $name = $node->getName();
  187.         if ('' === $name) {
  188.             throw new \InvalidArgumentException('Child nodes must be named.');
  189.         }
  190.         if (isset($this->children[$name])) {
  191.             throw new \InvalidArgumentException(sprintf('A child node named "%s" already exists.', $name));
  192.         }
  194.         $this->children[$name] = $node;
  195.     }
  197.     /**
  198.      * {@inheritdoc}
  199.      *
  200.      * @throws UnsetKeyException
  201.      * @throws InvalidConfigurationException if the node doesn't have enough children
  202.      */
  203.     protected function finalizeValue($value)
  204.     {
  205.         if (false === $value) {
  206.             throw new UnsetKeyException(sprintf('Unsetting key for path "%s", value: %s.', $this->getPath(), json_encode($value)));
  207.         }
  209.         foreach ($this->children as $name => $child) {
  210.             if (!\array_key_exists($name, $value)) {
  211.                 if ($child->isRequired()) {
  212.                     $message = sprintf('The child config "%s" under "%s" must be configured', $name, $this->getPath());
  213.                     if ($child->getInfo()) {
  214.                         $message .= sprintf(': %s', $child->getInfo());
  215.                     } else {
  216.                         $message .= '.';
  217.                     }
  218.                     $ex = new InvalidConfigurationException($message);
  219.                     $ex->setPath($this->getPath());
  221.                     throw $ex;
  222.                 }
  224.                 if ($child->hasDefaultValue()) {
  225.                     $value[$name] = $child->getDefaultValue();
  226.                 }
  228.                 continue;
  229.             }
  231.             if ($child->isDeprecated()) {
  232.                 $deprecation = $child->getDeprecation($name, $this->getPath());
  233.                 trigger_deprecation($deprecation['package'], $deprecation['version'], $deprecation['message']);
  234.             }
  236.             try {
  237.                 $value[$name] = $child->finalize($value[$name]);
  238.             } catch (UnsetKeyException $e) {
  239.                 unset($value[$name]);
  240.             }
  241.         }
  243.         return $value;
  244.     }
  246.     /**
  247.      * {@inheritdoc}
  248.      */
  249.     protected function validateType($value)
  250.     {
  251.         if (!\is_array($value) && (!$this->allowFalse || false !== $value)) {
  252.             $ex = new InvalidTypeException(sprintf('Invalid type for path "%s". Expected "array", but got "%s"', $this->getPath(), get_debug_type($value)));
  253.             if ($hint = $this->getInfo()) {
  254.                 $ex->addHint($hint);
  255.             }
  256.             $ex->setPath($this->getPath());
  258.             throw $ex;
  259.         }
  260.     }
  262.     /**
  263.      * {@inheritdoc}
  264.      *
  265.      * @throws InvalidConfigurationException
  266.      */
  267.     protected function normalizeValue($value)
  268.     {
  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.                 unset($value[$name]);
  283.             } elseif (!$this->removeExtraKeys) {
  284.                 $normalized[$name] = $val;
  285.             }
  286.         }
  288.         // if extra fields are present, throw exception
  289.         if (\count($value) && !$this->ignoreExtraKeys) {
  290.             $proposals = array_keys($this->children);
  291.             sort($proposals);
  292.             $guesses = [];
  294.             foreach (array_keys($value) as $subject) {
  295.                 $minScore = \INF;
  296.                 foreach ($proposals as $proposal) {
  297.                     $distance = levenshtein($subject, $proposal);
  298.                     if ($distance <= $minScore && $distance < 3) {
  299.                         $guesses[$proposal] = $distance;
  300.                         $minScore = $distance;
  301.                     }
  302.                 }
  303.             }
  305.             $msg = sprintf('Unrecognized option%s "%s" under "%s"', 1 === \count($value) ? '' : 's', implode(', ', array_keys($value)), $this->getPath());
  307.             if (\count($guesses)) {
  308.                 asort($guesses);
  309.                 $msg .= sprintf('. Did you mean "%s"?', implode('", "', array_keys($guesses)));
  310.             } else {
  311.                 $msg .= sprintf('. Available option%s %s "%s".', 1 === \count($proposals) ? '' : 's', 1 === \count($proposals) ? 'is' : 'are', implode('", "', $proposals));
  312.             }
  314.             $ex = new InvalidConfigurationException($msg);
  315.             $ex->setPath($this->getPath());
  317.             throw $ex;
  318.         }
  320.         return $normalized;
  321.     }
  323.     /**
  324.      * Remaps multiple singular values to a single plural value.
  325.      *
  326.      * @return array The remapped values
  327.      */
  328.     protected function remapXml(array $value)
  329.     {
  330.         foreach ($this->xmlRemappings as [$singular, $plural]) {
  331.             if (!isset($value[$singular])) {
  332.                 continue;
  333.             }
  335.             $value[$plural] = Processor::normalizeConfig($value, $singular, $plural);
  336.             unset($value[$singular]);
  337.         }
  339.         return $value;
  340.     }
  342.     /**
  343.      * {@inheritdoc}
  344.      *
  345.      * @throws InvalidConfigurationException
  346.      * @throws \RuntimeException
  347.      */
  348.     protected function mergeValues($leftSide, $rightSide)
  349.     {
  350.         if (false === $rightSide) {
  351.             // if this is still false after the last config has been merged the
  352.             // finalization pass will take care of removing this key entirely
  353.             return false;
  354.         }
  356.         if (false === $leftSide || !$this->performDeepMerging) {
  357.             return $rightSide;
  358.         }
  360.         foreach ($rightSide as $k => $v) {
  361.             // no conflict
  362.             if (!\array_key_exists($k, $leftSide)) {
  363.                 if (!$this->allowNewKeys) {
  364.                     $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()));
  365.                     $ex->setPath($this->getPath());
  367.                     throw $ex;
  368.                 }
  370.                 $leftSide[$k] = $v;
  371.                 continue;
  372.             }
  374.             if (!isset($this->children[$k])) {
  375.                 if (!$this->ignoreExtraKeys || $this->removeExtraKeys) {
  376.                     throw new \RuntimeException('merge() expects a normalized config array.');
  377.                 }
  379.                 $leftSide[$k] = $v;
  380.                 continue;
  381.             }
  383.             $leftSide[$k] = $this->children[$k]->merge($leftSide[$k], $v);
  384.         }
  386.         return $leftSide;
  387.     }
  389.     /**
  390.      * {@inheritdoc}
  391.      */
  392.     protected function allowPlaceholders(): bool
  393.     {
  394.         return false;
  395.     }
  396. }