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

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