vendor/symfony/config/Definition/Builder/ExprBuilder.php line 239

  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\Exception\UnsetKeyException;
  16. /**
  17.  * This class builds an if expression.
  18.  *
  19.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  20.  * @author Christophe Coevoet <stof@notk.org>
  21.  */
  22. class ExprBuilder
  23. {
  24.     public const TYPE_ANY = 'any';
  25.     public const TYPE_STRING = 'string';
  26.     public const TYPE_NULL = 'null';
  27.     public const TYPE_ARRAY = 'array';
  29.     protected $node;
  31.     public $allowedTypes;
  32.     public $ifPart;
  33.     public $thenPart;
  35.     public function __construct(NodeDefinition $node)
  36.     {
  37.         $this->node = $node;
  38.     }
  40.     /**
  41.      * Marks the expression as being always used.
  42.      *
  43.      * @return $this
  44.      */
  45.     public function always(?\Closure $then = null): static
  46.     {
  47.         $this->ifPart = static fn () => true;
  48.         $this->allowedTypes = self::TYPE_ANY;
  50.         if (null !== $then) {
  51.             $this->thenPart = $then;
  52.         }
  54.         return $this;
  55.     }
  57.     /**
  58.      * Sets a closure to use as tests.
  59.      *
  60.      * The default one tests if the value is true.
  61.      *
  62.      * @return $this
  63.      */
  64.     public function ifTrue(?\Closure $closure = null): static
  65.     {
  66.         $this->ifPart = $closure ?? static fn ($v) => true === $v;
  67.         $this->allowedTypes = self::TYPE_ANY;
  69.         return $this;
  70.     }
  72.     /**
  73.      * Tests if the value is a string.
  74.      *
  75.      * @return $this
  76.      */
  77.     public function ifString(): static
  78.     {
  79.         $this->ifPart = \is_string(...);
  80.         $this->allowedTypes = self::TYPE_STRING;
  82.         return $this;
  83.     }
  85.     /**
  86.      * Tests if the value is null.
  87.      *
  88.      * @return $this
  89.      */
  90.     public function ifNull(): static
  91.     {
  92.         $this->ifPart = \is_null(...);
  93.         $this->allowedTypes = self::TYPE_NULL;
  95.         return $this;
  96.     }
  98.     /**
  99.      * Tests if the value is empty.
  100.      *
  101.      * @return $this
  102.      */
  103.     public function ifEmpty(): static
  104.     {
  105.         $this->ifPart = static fn ($v) => empty($v);
  106.         $this->allowedTypes = self::TYPE_ANY;
  108.         return $this;
  109.     }
  111.     /**
  112.      * Tests if the value is an array.
  113.      *
  114.      * @return $this
  115.      */
  116.     public function ifArray(): static
  117.     {
  118.         $this->ifPart = \is_array(...);
  119.         $this->allowedTypes = self::TYPE_ARRAY;
  121.         return $this;
  122.     }
  124.     /**
  125.      * Tests if the value is in an array.
  126.      *
  127.      * @return $this
  128.      */
  129.     public function ifInArray(array $array): static
  130.     {
  131.         $this->ifPart = static fn ($v) => \in_array($v, $array, true);
  132.         $this->allowedTypes = self::TYPE_ANY;
  134.         return $this;
  135.     }
  137.     /**
  138.      * Tests if the value is not in an array.
  139.      *
  140.      * @return $this
  141.      */
  142.     public function ifNotInArray(array $array): static
  143.     {
  144.         $this->ifPart = static fn ($v) => !\in_array($v, $array, true);
  145.         $this->allowedTypes = self::TYPE_ANY;
  147.         return $this;
  148.     }
  150.     /**
  151.      * Transforms variables of any type into an array.
  152.      *
  153.      * @return $this
  154.      */
  155.     public function castToArray(): static
  156.     {
  157.         $this->ifPart = static fn ($v) => !\is_array($v);
  158.         $this->allowedTypes = self::TYPE_ANY;
  159.         $this->thenPart = static fn ($v) => [$v];
  161.         return $this;
  162.     }
  164.     /**
  165.      * Sets the closure to run if the test pass.
  166.      *
  167.      * @return $this
  168.      */
  169.     public function then(\Closure $closure): static
  170.     {
  171.         $this->thenPart = $closure;
  173.         return $this;
  174.     }
  176.     /**
  177.      * Sets a closure returning an empty array.
  178.      *
  179.      * @return $this
  180.      */
  181.     public function thenEmptyArray(): static
  182.     {
  183.         $this->thenPart = static fn () => [];
  185.         return $this;
  186.     }
  188.     /**
  189.      * Sets a closure marking the value as invalid at processing time.
  190.      *
  191.      * if you want to add the value of the node in your message just use a %s placeholder.
  192.      *
  193.      * @return $this
  194.      *
  195.      * @throws \InvalidArgumentException
  196.      */
  197.     public function thenInvalid(string $message): static
  198.     {
  199.         $this->thenPart = static fn ($v) => throw new \InvalidArgumentException(sprintf($message, json_encode($v)));
  201.         return $this;
  202.     }
  204.     /**
  205.      * Sets a closure unsetting this key of the array at processing time.
  206.      *
  207.      * @return $this
  208.      *
  209.      * @throws UnsetKeyException
  210.      */
  211.     public function thenUnset(): static
  212.     {
  213.         $this->thenPart = static fn () => throw new UnsetKeyException('Unsetting key.');
  215.         return $this;
  216.     }
  218.     /**
  219.      * Returns the related node.
  220.      *
  221.      * @throws \RuntimeException
  222.      */
  223.     public function end(): NodeDefinition|ArrayNodeDefinition|VariableNodeDefinition
  224.     {
  225.         if (null === $this->ifPart) {
  226.             throw new \RuntimeException('You must specify an if part.');
  227.         }
  228.         if (null === $this->thenPart) {
  229.             throw new \RuntimeException('You must specify a then part.');
  230.         }
  232.         return $this->node;
  233.     }
  235.     /**
  236.      * Builds the expressions.
  237.      *
  238.      * @param ExprBuilder[] $expressions An array of ExprBuilder instances to build
  239.      */
  240.     public static function buildExpressions(array $expressions): array
  241.     {
  242.         foreach ($expressions as $k => $expr) {
  243.             if ($expr instanceof self) {
  244.                 $if = $expr->ifPart;
  245.                 $then = $expr->thenPart;
  246.                 $expressions[$k] = static fn ($v) => $if($v) ? $then($v) : $v;
  247.             }
  248.         }
  250.         return $expressions;
  251.     }
  252. }