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

  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
  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.     /**
  36.      * @return void
  37.      */
  38.     public function setNormalizeKeys(bool $normalizeKeys)
  39.     {
  40.         $this->normalizeKeys = $normalizeKeys;
  41.     }
  43.     /**
  44.      * Namely, you mostly have foo_bar in YAML while you have foo-bar in XML.
  45.      * After running this method, all keys are normalized to foo_bar.
  46.      *
  47.      * If you have a mixed key like foo-bar_moo, it will not be altered.
  48.      * The key will also not be altered if the target key already exists.
  49.      */
  50.     protected function preNormalize(mixed $value): mixed
  51.     {
  52.         if (!$this->normalizeKeys || !\is_array($value)) {
  53.             return $value;
  54.         }
  56.         $normalized = [];
  58.         foreach ($value as $k => $v) {
  59.             if (str_contains($k, '-') && !str_contains($k, '_') && !\array_key_exists($normalizedKey = str_replace('-', '_', $k), $value)) {
  60.                 $normalized[$normalizedKey] = $v;
  61.             } else {
  62.                 $normalized[$k] = $v;
  63.             }
  64.         }
  66.         return $normalized;
  67.     }
  69.     /**
  70.      * Retrieves the children of this node.
  71.      *
  72.      * @return array<string, NodeInterface>
  73.      */
  74.     public function getChildren(): array
  75.     {
  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.      * @return void
  85.      */
  86.     public function setXmlRemappings(array $remappings)
  87.     {
  88.         $this->xmlRemappings = $remappings;
  89.     }
  91.     /**
  92.      * Gets the xml remappings that should be performed.
  93.      *
  94.      * @return array an array of the form [[string, string]]
  95.      */
  96.     public function getXmlRemappings(): array
  97.     {
  98.         return $this->xmlRemappings;
  99.     }
  101.     /**
  102.      * Sets whether to add default values for this array if it has not been
  103.      * defined in any of the configuration files.
  104.      *
  105.      * @return void
  106.      */
  107.     public function setAddIfNotSet(bool $boolean)
  108.     {
  109.         $this->addIfNotSet = $boolean;
  110.     }
  112.     /**
  113.      * Sets whether false is allowed as value indicating that the array should be unset.
  114.      *
  115.      * @return void
  116.      */
  117.     public function setAllowFalse(bool $allow)
  118.     {
  119.         $this->allowFalse = $allow;
  120.     }
  122.     /**
  123.      * Sets whether new keys can be defined in subsequent configurations.
  124.      *
  125.      * @return void
  126.      */
  127.     public function setAllowNewKeys(bool $allow)
  128.     {
  129.         $this->allowNewKeys = $allow;
  130.     }
  132.     /**
  133.      * Sets if deep merging should occur.
  134.      *
  135.      * @return void
  136.      */
  137.     public function setPerformDeepMerging(bool $boolean)
  138.     {
  139.         $this->performDeepMerging = $boolean;
  140.     }
  142.     /**
  143.      * Whether extra keys should just be ignored without an exception.
  144.      *
  145.      * @param bool $boolean To allow extra keys
  146.      * @param bool $remove  To remove extra keys
  147.      *
  148.      * @return void
  149.      */
  150.     public function setIgnoreExtraKeys(bool $boolean, bool $remove = true)
  151.     {
  152.         $this->ignoreExtraKeys = $boolean;
  153.         $this->removeExtraKeys = $this->ignoreExtraKeys && $remove;
  154.     }
  156.     /**
  157.      * Returns true when extra keys should be ignored without an exception.
  158.      */
  159.     public function shouldIgnoreExtraKeys(): bool
  160.     {
  161.         return $this->ignoreExtraKeys;
  162.     }
  164.     /**
  165.      * @return void
  166.      */
  167.     public function setName(string $name)
  168.     {
  169.         $this->name = $name;
  170.     }
  172.     public function hasDefaultValue(): bool
  173.     {
  174.         return $this->addIfNotSet;
  175.     }
  177.     public function getDefaultValue(): mixed
  178.     {
  179.         if (!$this->hasDefaultValue()) {
  180.             throw new \RuntimeException(sprintf('The node at path "%s" has no default value.', $this->getPath()));
  181.         }
  183.         $defaults = [];
  184.         foreach ($this->children as $name => $child) {
  185.             if ($child->hasDefaultValue()) {
  186.                 $defaults[$name] = $child->getDefaultValue();
  187.             }
  188.         }
  190.         return $defaults;
  191.     }
  193.     /**
  194.      * Adds a child node.
  195.      *
  196.      * @return void
  197.      *
  198.      * @throws \InvalidArgumentException when the child node has no name
  199.      * @throws \InvalidArgumentException when the child node's name is not unique
  200.      */
  201.     public function addChild(NodeInterface $node)
  202.     {
  203.         $name = $node->getName();
  204.         if ('' === $name) {
  205.             throw new \InvalidArgumentException('Child nodes must be named.');
  206.         }
  207.         if (isset($this->children[$name])) {
  208.             throw new \InvalidArgumentException(sprintf('A child node named "%s" already exists.', $name));
  209.         }
  211.         $this->children[$name] = $node;
  212.     }
  214.     /**
  215.      * @throws UnsetKeyException
  216.      * @throws InvalidConfigurationException if the node doesn't have enough children
  217.      */
  218.     protected function finalizeValue(mixed $value): mixed
  219.     {
  220.         if (false === $value) {
  221.             throw new UnsetKeyException(sprintf('Unsetting key for path "%s", value: %s.', $this->getPath(), json_encode($value)));
  222.         }
  224.         foreach ($this->children as $name => $child) {
  225.             if (!\array_key_exists($name, $value)) {
  226.                 if ($child->isRequired()) {
  227.                     $message = sprintf('The child config "%s" under "%s" must be configured', $name, $this->getPath());
  228.                     if ($child->getInfo()) {
  229.                         $message .= sprintf(': %s', $child->getInfo());
  230.                     } else {
  231.                         $message .= '.';
  232.                     }
  233.                     $ex = new InvalidConfigurationException($message);
  234.                     $ex->setPath($this->getPath());
  236.                     throw $ex;
  237.                 }
  239.                 if ($child->hasDefaultValue()) {
  240.                     $value[$name] = $child->getDefaultValue();
  241.                 }
  243.                 continue;
  244.             }
  246.             if ($child->isDeprecated()) {
  247.                 $deprecation = $child->getDeprecation($name, $this->getPath());
  248.                 trigger_deprecation($deprecation['package'], $deprecation['version'], $deprecation['message']);
  249.             }
  251.             try {
  252.                 $value[$name] = $child->finalize($value[$name]);
  253.             } catch (UnsetKeyException) {
  254.                 unset($value[$name]);
  255.             }
  256.         }
  258.         return $value;
  259.     }
  261.     /**
  262.      * @return void
  263.      */
  264.     protected function validateType(mixed $value)
  265.     {
  266.         if (!\is_array($value) && (!$this->allowFalse || false !== $value)) {
  267.             $ex = new InvalidTypeException(sprintf('Invalid type for path "%s". Expected "array", but got "%s"', $this->getPath(), get_debug_type($value)));
  268.             if ($hint = $this->getInfo()) {
  269.                 $ex->addHint($hint);
  270.             }
  271.             $ex->setPath($this->getPath());
  273.             throw $ex;
  274.         }
  275.     }
  277.     /**
  278.      * @throws InvalidConfigurationException
  279.      */
  280.     protected function normalizeValue(mixed $value): mixed
  281.     {
  282.         if (false === $value) {
  283.             return $value;
  284.         }
  286.         $value = $this->remapXml($value);
  288.         $normalized = [];
  289.         foreach ($value as $name => $val) {
  290.             if (isset($this->children[$name])) {
  291.                 try {
  292.                     $normalized[$name] = $this->children[$name]->normalize($val);
  293.                 } catch (UnsetKeyException) {
  294.                 }
  295.                 unset($value[$name]);
  296.             } elseif (!$this->removeExtraKeys) {
  297.                 $normalized[$name] = $val;
  298.             }
  299.         }
  301.         // if extra fields are present, throw exception
  302.         if (\count($value) && !$this->ignoreExtraKeys) {
  303.             $proposals = array_keys($this->children);
  304.             sort($proposals);
  305.             $guesses = [];
  307.             foreach (array_keys($value) as $subject) {
  308.                 $minScore = \INF;
  309.                 foreach ($proposals as $proposal) {
  310.                     $distance = levenshtein($subject, $proposal);
  311.                     if ($distance <= $minScore && $distance < 3) {
  312.                         $guesses[$proposal] = $distance;
  313.                         $minScore = $distance;
  314.                     }
  315.                 }
  316.             }
  318.             $msg = sprintf('Unrecognized option%s "%s" under "%s"', 1 === \count($value) ? '' : 's', implode(', ', array_keys($value)), $this->getPath());
  320.             if (\count($guesses)) {
  321.                 asort($guesses);
  322.                 $msg .= sprintf('. Did you mean "%s"?', implode('", "', array_keys($guesses)));
  323.             } else {
  324.                 $msg .= sprintf('. Available option%s %s "%s".', 1 === \count($proposals) ? '' : 's', 1 === \count($proposals) ? 'is' : 'are', implode('", "', $proposals));
  325.             }
  327.             $ex = new InvalidConfigurationException($msg);
  328.             $ex->setPath($this->getPath());
  330.             throw $ex;
  331.         }
  333.         return $normalized;
  334.     }
  336.     /**
  337.      * Remaps multiple singular values to a single plural value.
  338.      */
  339.     protected function remapXml(array $value): array
  340.     {
  341.         foreach ($this->xmlRemappings as [$singular, $plural]) {
  342.             if (!isset($value[$singular])) {
  343.                 continue;
  344.             }
  346.             $value[$plural] = Processor::normalizeConfig($value, $singular, $plural);
  347.             unset($value[$singular]);
  348.         }
  350.         return $value;
  351.     }
  353.     /**
  354.      * @throws InvalidConfigurationException
  355.      * @throws \RuntimeException
  356.      */
  357.     protected function mergeValues(mixed $leftSide, mixed $rightSide): mixed
  358.     {
  359.         if (false === $rightSide) {
  360.             // if this is still false after the last config has been merged the
  361.             // finalization pass will take care of removing this key entirely
  362.             return false;
  363.         }
  365.         if (false === $leftSide || !$this->performDeepMerging) {
  366.             return $rightSide;
  367.         }
  369.         foreach ($rightSide as $k => $v) {
  370.             // no conflict
  371.             if (!\array_key_exists($k, $leftSide)) {
  372.                 if (!$this->allowNewKeys) {
  373.                     $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()));
  374.                     $ex->setPath($this->getPath());
  376.                     throw $ex;
  377.                 }
  379.                 $leftSide[$k] = $v;
  380.                 continue;
  381.             }
  383.             if (!isset($this->children[$k])) {
  384.                 if (!$this->ignoreExtraKeys || $this->removeExtraKeys) {
  385.                     throw new \RuntimeException('merge() expects a normalized config array.');
  386.                 }
  388.                 $leftSide[$k] = $v;
  389.                 continue;
  390.             }
  392.             $leftSide[$k] = $this->children[$k]->merge($leftSide[$k], $v);
  393.         }
  395.         return $leftSide;
  396.     }
  398.     protected function allowPlaceholders(): bool
  399.     {
  400.         return false;
  401.     }
  402. }