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

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\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.         $this->parent = $parent;
  46.         return $this;
  47.     }
  49.     /**
  50.      * Creates a child array node.
  51.      */
  52.     public function arrayNode(string $name): ArrayNodeDefinition
  53.     {
  54.         return $this->node($name, 'array');
  55.     }
  57.     /**
  58.      * Creates a child scalar node.
  59.      */
  60.     public function scalarNode(string $name): ScalarNodeDefinition
  61.     {
  62.         return $this->node($name, 'scalar');
  63.     }
  65.     /**
  66.      * Creates a child Boolean node.
  67.      */
  68.     public function booleanNode(string $name): BooleanNodeDefinition
  69.     {
  70.         return $this->node($name, 'boolean');
  71.     }
  73.     /**
  74.      * Creates a child integer node.
  75.      */
  76.     public function integerNode(string $name): IntegerNodeDefinition
  77.     {
  78.         return $this->node($name, 'integer');
  79.     }
  81.     /**
  82.      * Creates a child float node.
  83.      */
  84.     public function floatNode(string $name): FloatNodeDefinition
  85.     {
  86.         return $this->node($name, 'float');
  87.     }
  89.     /**
  90.      * Creates a child EnumNode.
  91.      */
  92.     public function enumNode(string $name): EnumNodeDefinition
  93.     {
  94.         return $this->node($name, 'enum');
  95.     }
  97.     /**
  98.      * Creates a child variable node.
  99.      */
  100.     public function variableNode(string $name): VariableNodeDefinition
  101.     {
  102.         return $this->node($name, 'variable');
  103.     }
  105.     /**
  106.      * Returns the parent node.
  107.      *
  108.      * @return NodeDefinition&ParentNodeDefinitionInterface
  109.      */
  110.     public function end()
  111.     {
  112.         return $this->parent;
  113.     }
  115.     /**
  116.      * Creates a child node.
  117.      *
  118.      * @throws \RuntimeException When the node type is not registered
  119.      * @throws \RuntimeException When the node class is not found
  120.      */
  121.     public function node(?string $name, string $type): NodeDefinition
  122.     {
  123.         $class = $this->getNodeClass($type);
  125.         $node = new $class($name);
  127.         $this->append($node);
  129.         return $node;
  130.     }
  132.     /**
  133.      * Appends a node definition.
  134.      *
  135.      * Usage:
  136.      *
  137.      *     $node = new ArrayNodeDefinition('name')
  138.      *         ->children()
  139.      *             ->scalarNode('foo')->end()
  140.      *             ->scalarNode('baz')->end()
  141.      *             ->append($this->getBarNodeDefinition())
  142.      *         ->end()
  143.      *     ;
  144.      *
  145.      * @return $this
  146.      */
  147.     public function append(NodeDefinition $node): static
  148.     {
  149.         if ($node instanceof BuilderAwareInterface) {
  150.             $builder = clone $this;
  151.             $builder->setParent(null);
  152.             $node->setBuilder($builder);
  153.         }
  155.         if (null !== $this->parent) {
  156.             $this->parent->append($node);
  157.             // Make this builder the node parent to allow for a fluid interface
  158.             $node->setParent($this);
  159.         }
  161.         return $this;
  162.     }
  164.     /**
  165.      * Adds or overrides a node Type.
  166.      *
  167.      * @param string $type  The name of the type
  168.      * @param string $class The fully qualified name the node definition class
  169.      *
  170.      * @return $this
  171.      */
  172.     public function setNodeClass(string $type, string $class): static
  173.     {
  174.         $this->nodeMapping[strtolower($type)] = $class;
  176.         return $this;
  177.     }
  179.     /**
  180.      * Returns the class name of the node definition.
  181.      *
  182.      * @throws \RuntimeException When the node type is not registered
  183.      * @throws \RuntimeException When the node class is not found
  184.      */
  185.     protected function getNodeClass(string $type): string
  186.     {
  187.         $type = strtolower($type);
  189.         if (!isset($this->nodeMapping[$type])) {
  190.             throw new \RuntimeException(sprintf('The node type "%s" is not registered.', $type));
  191.         }
  193.         $class = $this->nodeMapping[$type];
  195.         if (!class_exists($class)) {
  196.             throw new \RuntimeException(sprintf('The node class "%s" does not exist.', $class));
  197.         }
  199.         return $class;
  200.     }
  201. }