vendor/symfony/config/Definition/Builder/NodeDefinition.php line 307

  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\Builder;
  14. use Symfony\Component\Config\Definition\BaseNode;
  15. use Symfony\Component\Config\Definition\Exception\InvalidDefinitionException;
  16. use Symfony\Component\Config\Definition\NodeInterface;
  18. /**
  19.  * This class provides a fluent interface for defining a node.
  20.  *
  21.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  22.  */
  23. abstract class NodeDefinition implements NodeParentInterface
  24. {
  25.     protected $name;
  26.     protected $normalization;
  27.     protected $validation;
  28.     protected $defaultValue;
  29.     protected $default = false;
  30.     protected $required = false;
  31.     protected $deprecation = [];
  32.     protected $merge;
  33.     protected $allowEmptyValue = true;
  34.     protected $nullEquivalent;
  35.     protected $trueEquivalent = true;
  36.     protected $falseEquivalent = false;
  37.     protected $pathSeparator = BaseNode::DEFAULT_PATH_SEPARATOR;
  38.     protected $parent;
  39.     protected $attributes = [];
  41.     public function __construct(?string $name, NodeParentInterface $parent = null)
  42.     {
  43.         $this->parent = $parent;
  44.         $this->name = $name;
  45.     }
  47.     /**
  48.      * Sets the parent node.
  49.      *
  50.      * @return $this
  51.      */
  52.     public function setParent(NodeParentInterface $parent): static
  53.     {
  54.         $this->parent = $parent;
  56.         return $this;
  57.     }
  59.     /**
  60.      * Sets info message.
  61.      *
  62.      * @return $this
  63.      */
  64.     public function info(string $info): static
  65.     {
  66.         return $this->attribute('info', $info);
  67.     }
  69.     /**
  70.      * Sets example configuration.
  71.      *
  72.      * @return $this
  73.      */
  74.     public function example(string|array $example): static
  75.     {
  76.         return $this->attribute('example', $example);
  77.     }
  79.     /**
  80.      * Sets an attribute on the node.
  81.      *
  82.      * @return $this
  83.      */
  84.     public function attribute(string $key, mixed $value): static
  85.     {
  86.         $this->attributes[$key] = $value;
  88.         return $this;
  89.     }
  91.     /**
  92.      * Returns the parent node.
  93.      */
  94.     public function end(): NodeParentInterface|NodeBuilder|NodeDefinition|ArrayNodeDefinition|VariableNodeDefinition|null
  95.     {
  96.         return $this->parent;
  97.     }
  99.     /**
  100.      * Creates the node.
  101.      */
  102.     public function getNode(bool $forceRootNode = false): NodeInterface
  103.     {
  104.         if ($forceRootNode) {
  105.             $this->parent = null;
  106.         }
  108.         if (null !== $this->normalization) {
  109.             $allowedTypes = [];
  110.             foreach ($this->normalization->before as $expr) {
  111.                 $allowedTypes[] = $expr->allowedTypes;
  112.             }
  113.             $allowedTypes = array_unique($allowedTypes);
  114.             $this->normalization->before = ExprBuilder::buildExpressions($this->normalization->before);
  115.             $this->normalization->declaredTypes = $allowedTypes;
  116.         }
  118.         if (null !== $this->validation) {
  119.             $this->validation->rules = ExprBuilder::buildExpressions($this->validation->rules);
  120.         }
  122.         $node = $this->createNode();
  123.         if ($node instanceof BaseNode) {
  124.             $node->setAttributes($this->attributes);
  125.         }
  127.         return $node;
  128.     }
  130.     /**
  131.      * Sets the default value.
  132.      *
  133.      * @return $this
  134.      */
  135.     public function defaultValue(mixed $value): static
  136.     {
  137.         $this->default = true;
  138.         $this->defaultValue = $value;
  140.         return $this;
  141.     }
  143.     /**
  144.      * Sets the node as required.
  145.      *
  146.      * @return $this
  147.      */
  148.     public function isRequired(): static
  149.     {
  150.         $this->required = true;
  152.         return $this;
  153.     }
  155.     /**
  156.      * Sets the node as deprecated.
  157.      *
  158.      * @param string $package The name of the composer package that is triggering the deprecation
  159.      * @param string $version The version of the package that introduced the deprecation
  160.      * @param string $message the deprecation message to use
  161.      *
  162.      * You can use %node% and %path% placeholders in your message to display,
  163.      * respectively, the node name and its complete path
  164.      *
  165.      * @return $this
  166.      */
  167.     public function setDeprecated(string $package, string $version, string $message = 'The child node "%node%" at path "%path%" is deprecated.'): static
  168.     {
  169.         $this->deprecation = [
  170.             'package' => $package,
  171.             'version' => $version,
  172.             'message' => $message,
  173.         ];
  175.         return $this;
  176.     }
  178.     /**
  179.      * Sets the equivalent value used when the node contains null.
  180.      *
  181.      * @return $this
  182.      */
  183.     public function treatNullLike(mixed $value): static
  184.     {
  185.         $this->nullEquivalent = $value;
  187.         return $this;
  188.     }
  190.     /**
  191.      * Sets the equivalent value used when the node contains true.
  192.      *
  193.      * @return $this
  194.      */
  195.     public function treatTrueLike(mixed $value): static
  196.     {
  197.         $this->trueEquivalent = $value;
  199.         return $this;
  200.     }
  202.     /**
  203.      * Sets the equivalent value used when the node contains false.
  204.      *
  205.      * @return $this
  206.      */
  207.     public function treatFalseLike(mixed $value): static
  208.     {
  209.         $this->falseEquivalent = $value;
  211.         return $this;
  212.     }
  214.     /**
  215.      * Sets null as the default value.
  216.      *
  217.      * @return $this
  218.      */
  219.     public function defaultNull(): static
  220.     {
  221.         return $this->defaultValue(null);
  222.     }
  224.     /**
  225.      * Sets true as the default value.
  226.      *
  227.      * @return $this
  228.      */
  229.     public function defaultTrue(): static
  230.     {
  231.         return $this->defaultValue(true);
  232.     }
  234.     /**
  235.      * Sets false as the default value.
  236.      *
  237.      * @return $this
  238.      */
  239.     public function defaultFalse(): static
  240.     {
  241.         return $this->defaultValue(false);
  242.     }
  244.     /**
  245.      * Sets an expression to run before the normalization.
  246.      */
  247.     public function beforeNormalization(): ExprBuilder
  248.     {
  249.         return $this->normalization()->before();
  250.     }
  252.     /**
  253.      * Denies the node value being empty.
  254.      *
  255.      * @return $this
  256.      */
  257.     public function cannotBeEmpty(): static
  258.     {
  259.         $this->allowEmptyValue = false;
  261.         return $this;
  262.     }
  264.     /**
  265.      * Sets an expression to run for the validation.
  266.      *
  267.      * The expression receives the value of the node and must return it. It can
  268.      * modify it.
  269.      * An exception should be thrown when the node is not valid.
  270.      */
  271.     public function validate(): ExprBuilder
  272.     {
  273.         return $this->validation()->rule();
  274.     }
  276.     /**
  277.      * Sets whether the node can be overwritten.
  278.      *
  279.      * @return $this
  280.      */
  281.     public function cannotBeOverwritten(bool $deny = true): static
  282.     {
  283.         $this->merge()->denyOverwrite($deny);
  285.         return $this;
  286.     }
  288.     /**
  289.      * Gets the builder for validation rules.
  290.      */
  291.     protected function validation(): ValidationBuilder
  292.     {
  293.         return $this->validation ??= new ValidationBuilder($this);
  294.     }
  296.     /**
  297.      * Gets the builder for merging rules.
  298.      */
  299.     protected function merge(): MergeBuilder
  300.     {
  301.         return $this->merge ??= new MergeBuilder($this);
  302.     }
  304.     /**
  305.      * Gets the builder for normalization rules.
  306.      */
  307.     protected function normalization(): NormalizationBuilder
  308.     {
  309.         return $this->normalization ??= new NormalizationBuilder($this);
  310.     }
  312.     /**
  313.      * Instantiate and configure the node according to this definition.
  314.      *
  315.      * @throws InvalidDefinitionException When the definition is invalid
  316.      */
  317.     abstract protected function createNode(): NodeInterface;
  319.     /**
  320.      * Set PathSeparator to use.
  321.      *
  322.      * @return $this
  323.      */
  324.     public function setPathSeparator(string $separator): static
  325.     {
  326.         if ($this instanceof ParentNodeDefinitionInterface) {
  327.             foreach ($this->getChildNodeDefinitions() as $child) {
  328.                 $child->setPathSeparator($separator);
  329.             }
  330.         }
  332.         $this->pathSeparator = $separator;
  334.         return $this;
  335.     }
  336. }