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

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
  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. * Returns true when extra keys should be ignored without an exception.
  145. */
  146. public function shouldIgnoreExtraKeys(): bool
  147. {
  148. return $this->ignoreExtraKeys;
  149. }
  151. /**
  152. * {@inheritdoc}
  153. */
  154. public function setName(string $name)
  155. {
  156. $this->name = $name;
  157. }
  159. /**
  160. * {@inheritdoc}
  161. */
  162. public function hasDefaultValue()
  163. {
  164. return $this->addIfNotSet;
  165. }
  167. /**
  168. * {@inheritdoc}
  169. */
  170. public function getDefaultValue()
  171. {
  172. if (!$this->hasDefaultValue()) {
  173. throw new \RuntimeException(sprintf('The node at path "%s" has no default value.', $this->getPath()));
  174. }
  176. $defaults = [];
  177. foreach ($this->children as $name => $child) {
  178. if ($child->hasDefaultValue()) {
  179. $defaults[$name] = $child->getDefaultValue();
  180. }
  181. }
  183. return $defaults;
  184. }
  186. /**
  187. * Adds a child node.
  188. *
  189. * @throws \InvalidArgumentException when the child node has no name
  190. * @throws \InvalidArgumentException when the child node's name is not unique
  191. */
  192. public function addChild(NodeInterface $node)
  193. {
  194. $name = $node->getName();
  195. if ('' === $name) {
  196. throw new \InvalidArgumentException('Child nodes must be named.');
  197. }
  198. if (isset($this->children[$name])) {
  199. throw new \InvalidArgumentException(sprintf('A child node named "%s" already exists.', $name));
  200. }
  202. $this->children[$name] = $node;
  203. }
  205. /**
  206. * {@inheritdoc}
  207. *
  208. * @throws UnsetKeyException
  209. * @throws InvalidConfigurationException if the node doesn't have enough children
  210. */
  211. protected function finalizeValue($value)
  212. {
  213. if (false === $value) {
  214. throw new UnsetKeyException(sprintf('Unsetting key for path "%s", value: %s.', $this->getPath(), json_encode($value)));
  215. }
  217. foreach ($this->children as $name => $child) {
  218. if (!\array_key_exists($name, $value)) {
  219. if ($child->isRequired()) {
  220. $message = sprintf('The child config "%s" under "%s" must be configured', $name, $this->getPath());
  221. if ($child->getInfo()) {
  222. $message .= sprintf(': %s', $child->getInfo());
  223. } else {
  224. $message .= '.';
  225. }
  226. $ex = new InvalidConfigurationException($message);
  227. $ex->setPath($this->getPath());
  229. throw $ex;
  230. }
  232. if ($child->hasDefaultValue()) {
  233. $value[$name] = $child->getDefaultValue();
  234. }
  236. continue;
  237. }
  239. if ($child->isDeprecated()) {
  240. $deprecation = $child->getDeprecation($name, $this->getPath());
  241. trigger_deprecation($deprecation['package'], $deprecation['version'], $deprecation['message']);
  242. }
  244. try {
  245. $value[$name] = $child->finalize($value[$name]);
  246. } catch (UnsetKeyException $e) {
  247. unset($value[$name]);
  248. }
  249. }
  251. return $value;
  252. }
  254. /**
  255. * {@inheritdoc}
  256. */
  257. protected function validateType($value)
  258. {
  259. if (!\is_array($value) && (!$this->allowFalse || false !== $value)) {
  260. $ex = new InvalidTypeException(sprintf('Invalid type for path "%s". Expected "array", but got "%s"', $this->getPath(), get_debug_type($value)));
  261. if ($hint = $this->getInfo()) {
  262. $ex->addHint($hint);
  263. }
  264. $ex->setPath($this->getPath());
  266. throw $ex;
  267. }
  268. }
  270. /**
  271. * {@inheritdoc}
  272. *
  273. * @throws InvalidConfigurationException
  274. */
  275. protected function normalizeValue($value)
  276. {
  277. if (false === $value) {
  278. return $value;
  279. }
  281. $value = $this->remapXml($value);
  283. $normalized = [];
  284. foreach ($value as $name => $val) {
  285. if (isset($this->children[$name])) {
  286. try {
  287. $normalized[$name] = $this->children[$name]->normalize($val);
  288. } catch (UnsetKeyException $e) {
  289. }
  290. unset($value[$name]);
  291. } elseif (!$this->removeExtraKeys) {
  292. $normalized[$name] = $val;
  293. }
  294. }
  296. // if extra fields are present, throw exception
  297. if (\count($value) && !$this->ignoreExtraKeys) {
  298. $proposals = array_keys($this->children);
  299. sort($proposals);
  300. $guesses = [];
  302. foreach (array_keys($value) as $subject) {
  303. $minScore = \INF;
  304. foreach ($proposals as $proposal) {
  305. $distance = levenshtein($subject, $proposal);
  306. if ($distance <= $minScore && $distance < 3) {
  307. $guesses[$proposal] = $distance;
  308. $minScore = $distance;
  309. }
  310. }
  311. }
  313. $msg = sprintf('Unrecognized option%s "%s" under "%s"', 1 === \count($value) ? '' : 's', implode(', ', array_keys($value)), $this->getPath());
  315. if (\count($guesses)) {
  316. asort($guesses);
  317. $msg .= sprintf('. Did you mean "%s"?', implode('", "', array_keys($guesses)));
  318. } else {
  319. $msg .= sprintf('. Available option%s %s "%s".', 1 === \count($proposals) ? '' : 's', 1 === \count($proposals) ? 'is' : 'are', implode('", "', $proposals));
  320. }
  322. $ex = new InvalidConfigurationException($msg);
  323. $ex->setPath($this->getPath());
  325. throw $ex;
  326. }
  328. return $normalized;
  329. }
  331. /**
  332. * Remaps multiple singular values to a single plural value.
  333. *
  334. * @return array
  335. */
  336. protected function remapXml(array $value)
  337. {
  338. foreach ($this->xmlRemappings as [$singular, $plural]) {
  339. if (!isset($value[$singular])) {
  340. continue;
  341. }
  343. $value[$plural] = Processor::normalizeConfig($value, $singular, $plural);
  344. unset($value[$singular]);
  345. }
  347. return $value;
  348. }
  350. /**
  351. * {@inheritdoc}
  352. *
  353. * @throws InvalidConfigurationException
  354. * @throws \RuntimeException
  355. */
  356. protected function mergeValues($leftSide, $rightSide)
  357. {
  358. if (false === $rightSide) {
  359. // if this is still false after the last config has been merged the
  360. // finalization pass will take care of removing this key entirely
  361. return false;
  362. }
  364. if (false === $leftSide || !$this->performDeepMerging) {
  365. return $rightSide;
  366. }
  368. foreach ($rightSide as $k => $v) {
  369. // no conflict
  370. if (!\array_key_exists($k, $leftSide)) {
  371. if (!$this->allowNewKeys) {
  372. $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()));
  373. $ex->setPath($this->getPath());
  375. throw $ex;
  376. }
  378. $leftSide[$k] = $v;
  379. continue;
  380. }
  382. if (!isset($this->children[$k])) {
  383. if (!$this->ignoreExtraKeys || $this->removeExtraKeys) {
  384. throw new \RuntimeException('merge() expects a normalized config array.');
  385. }
  387. $leftSide[$k] = $v;
  388. continue;
  389. }
  391. $leftSide[$k] = $this->children[$k]->merge($leftSide[$k], $v);
  392. }
  394. return $leftSide;
  395. }
  397. /**
  398. * {@inheritdoc}
  399. */
  400. protected function allowPlaceholders(): bool
  401. {
  402. return false;
  403. }
  404. }