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