vendor/symfony/config/Definition/Builder/NodeBuilder.php line 198

  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. /**
  15.  * This class provides a fluent interface for building a node.
  16.  *
  17.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  18.  */
  19. class NodeBuilder implements NodeParentInterface
  20. {
  21.     protected $parent;
  22.     protected $nodeMapping;
  24.     public function __construct()
  25.     {
  26.         $this->nodeMapping = [
  27.             'variable' => VariableNodeDefinition::class,
  28.             'scalar' => ScalarNodeDefinition::class,
  29.             'boolean' => BooleanNodeDefinition::class,
  30.             'integer' => IntegerNodeDefinition::class,
  31.             'float' => FloatNodeDefinition::class,
  32.             'array' => ArrayNodeDefinition::class,
  33.             'enum' => EnumNodeDefinition::class,
  34.         ];
  35.     }
  37.     /**
  38.      * Set the parent node.
  39.      *
  40.      * @return $this
  41.      */
  42.     public function setParent(ParentNodeDefinitionInterface $parent = null): static
  43.     {
  44.         if (1 > \func_num_args()) {
  45.             trigger_deprecation('symfony/form', '6.2', 'Calling "%s()" without any arguments is deprecated, pass null explicitly instead.', __METHOD__);
  46.         }
  47.         $this->parent = $parent;
  49.         return $this;
  50.     }
  52.     /**
  53.      * Creates a child array node.
  54.      */
  55.     public function arrayNode(string $name): ArrayNodeDefinition
  56.     {
  57.         return $this->node($name, 'array');
  58.     }
  60.     /**
  61.      * Creates a child scalar node.
  62.      */
  63.     public function scalarNode(string $name): ScalarNodeDefinition
  64.     {
  65.         return $this->node($name, 'scalar');
  66.     }
  68.     /**
  69.      * Creates a child Boolean node.
  70.      */
  71.     public function booleanNode(string $name): BooleanNodeDefinition
  72.     {
  73.         return $this->node($name, 'boolean');
  74.     }
  76.     /**
  77.      * Creates a child integer node.
  78.      */
  79.     public function integerNode(string $name): IntegerNodeDefinition
  80.     {
  81.         return $this->node($name, 'integer');
  82.     }
  84.     /**
  85.      * Creates a child float node.
  86.      */
  87.     public function floatNode(string $name): FloatNodeDefinition
  88.     {
  89.         return $this->node($name, 'float');
  90.     }
  92.     /**
  93.      * Creates a child EnumNode.
  94.      */
  95.     public function enumNode(string $name): EnumNodeDefinition
  96.     {
  97.         return $this->node($name, 'enum');
  98.     }
  100.     /**
  101.      * Creates a child variable node.
  102.      */
  103.     public function variableNode(string $name): VariableNodeDefinition
  104.     {
  105.         return $this->node($name, 'variable');
  106.     }
  108.     /**
  109.      * Returns the parent node.
  110.      *
  111.      * @return NodeDefinition&ParentNodeDefinitionInterface
  112.      */
  113.     public function end()
  114.     {
  115.         return $this->parent;
  116.     }
  118.     /**
  119.      * Creates a child node.
  120.      *
  121.      * @throws \RuntimeException When the node type is not registered
  122.      * @throws \RuntimeException When the node class is not found
  123.      */
  124.     public function node(?string $name, string $type): NodeDefinition
  125.     {
  126.         $class = $this->getNodeClass($type);
  128.         $node = new $class($name);
  130.         $this->append($node);
  132.         return $node;
  133.     }
  135.     /**
  136.      * Appends a node definition.
  137.      *
  138.      * Usage:
  139.      *
  140.      *     $node = new ArrayNodeDefinition('name')
  141.      *         ->children()
  142.      *             ->scalarNode('foo')->end()
  143.      *             ->scalarNode('baz')->end()
  144.      *             ->append($this->getBarNodeDefinition())
  145.      *         ->end()
  146.      *     ;
  147.      *
  148.      * @return $this
  149.      */
  150.     public function append(NodeDefinition $node): static
  151.     {
  152.         if ($node instanceof BuilderAwareInterface) {
  153.             $builder = clone $this;
  154.             $builder->setParent(null);
  155.             $node->setBuilder($builder);
  156.         }
  158.         if (null !== $this->parent) {
  159.             $this->parent->append($node);
  160.             // Make this builder the node parent to allow for a fluid interface
  161.             $node->setParent($this);
  162.         }
  164.         return $this;
  165.     }
  167.     /**
  168.      * Adds or overrides a node Type.
  169.      *
  170.      * @param string $type  The name of the type
  171.      * @param string $class The fully qualified name the node definition class
  172.      *
  173.      * @return $this
  174.      */
  175.     public function setNodeClass(string $type, string $class): static
  176.     {
  177.         $this->nodeMapping[strtolower($type)] = $class;
  179.         return $this;
  180.     }
  182.     /**
  183.      * Returns the class name of the node definition.
  184.      *
  185.      * @throws \RuntimeException When the node type is not registered
  186.      * @throws \RuntimeException When the node class is not found
  187.      */
  188.     protected function getNodeClass(string $type): string
  189.     {
  190.         $type = strtolower($type);
  192.         if (!isset($this->nodeMapping[$type])) {
  193.             throw new \RuntimeException(sprintf('The node type "%s" is not registered.', $type));
  194.         }
  196.         $class = $this->nodeMapping[$type];
  198.         if (!class_exists($class)) {
  199.             throw new \RuntimeException(sprintf('The node class "%s" does not exist.', $class));
  200.         }
  202.         return $class;
  203.     }
  204. }