vendor/symfony/expression-language/ExpressionLanguage.php line 37

  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\ExpressionLanguage;
  14. use Psr\Cache\CacheItemPoolInterface;
  15. use Symfony\Component\Cache\Adapter\ArrayAdapter;
  17. // Help opcache.preload discover always-needed symbols
  18. class_exists(ParsedExpression::class);
  20. /**
  21.  * Allows to compile and evaluate expressions written in your own DSL.
  22.  *
  23.  * @author Fabien Potencier <fabien@symfony.com>
  24.  */
  25. class ExpressionLanguage
  26. {
  27.     private CacheItemPoolInterface $cache;
  28.     private Lexer $lexer;
  29.     private Parser $parser;
  30.     private Compiler $compiler;
  32.     protected array $functions = [];
  34.     /**
  35.      * @param ExpressionFunctionProviderInterface[] $providers
  36.      */
  37.     public function __construct(CacheItemPoolInterface $cache = null, array $providers = [])
  38.     {
  39.         $this->cache = $cache ?? new ArrayAdapter();
  40.         $this->registerFunctions();
  41.         foreach ($providers as $provider) {
  42.             $this->registerProvider($provider);
  43.         }
  44.     }
  46.     /**
  47.      * Compiles an expression source code.
  48.      */
  49.     public function compile(Expression|string $expression, array $names = []): string
  50.     {
  51.         return $this->getCompiler()->compile($this->parse($expression, $names)->getNodes())->getSource();
  52.     }
  54.     /**
  55.      * Evaluate an expression.
  56.      */
  57.     public function evaluate(Expression|string $expression, array $values = []): mixed
  58.     {
  59.         return $this->parse($expression, array_keys($values))->getNodes()->evaluate($this->functions, $values);
  60.     }
  62.     /**
  63.      * Parses an expression.
  64.      */
  65.     public function parse(Expression|string $expression, array $names): ParsedExpression
  66.     {
  67.         if ($expression instanceof ParsedExpression) {
  68.             return $expression;
  69.         }
  71.         asort($names);
  72.         $cacheKeyItems = [];
  74.         foreach ($names as $nameKey => $name) {
  75.             $cacheKeyItems[] = \is_int($nameKey) ? $name : $nameKey.':'.$name;
  76.         }
  78.         $cacheItem = $this->cache->getItem(rawurlencode($expression.'//'.implode('|', $cacheKeyItems)));
  80.         if (null === $parsedExpression = $cacheItem->get()) {
  81.             $nodes = $this->getParser()->parse($this->getLexer()->tokenize((string) $expression), $names);
  82.             $parsedExpression = new ParsedExpression((string) $expression, $nodes);
  84.             $cacheItem->set($parsedExpression);
  85.             $this->cache->save($cacheItem);
  86.         }
  88.         return $parsedExpression;
  89.     }
  91.     /**
  92.      * Validates the syntax of an expression.
  93.      *
  94.      * @param array|null $names The list of acceptable variable names in the expression, or null to accept any names
  95.      *
  96.      * @throws SyntaxError When the passed expression is invalid
  97.      */
  98.     public function lint(Expression|string $expression, ?array $names): void
  99.     {
  100.         if ($expression instanceof ParsedExpression) {
  101.             return;
  102.         }
  104.         $this->getParser()->lint($this->getLexer()->tokenize((string) $expression), $names);
  105.     }
  107.     /**
  108.      * Registers a function.
  109.      *
  110.      * @param callable $compiler  A callable able to compile the function
  111.      * @param callable $evaluator A callable able to evaluate the function
  112.      *
  113.      * @throws \LogicException when registering a function after calling evaluate(), compile() or parse()
  114.      *
  115.      * @see ExpressionFunction
  116.      */
  117.     public function register(string $name, callable $compiler, callable $evaluator)
  118.     {
  119.         if (isset($this->parser)) {
  120.             throw new \LogicException('Registering functions after calling evaluate(), compile() or parse() is not supported.');
  121.         }
  123.         $this->functions[$name] = ['compiler' => $compiler, 'evaluator' => $evaluator];
  124.     }
  126.     public function addFunction(ExpressionFunction $function)
  127.     {
  128.         $this->register($function->getName(), $function->getCompiler(), $function->getEvaluator());
  129.     }
  131.     public function registerProvider(ExpressionFunctionProviderInterface $provider)
  132.     {
  133.         foreach ($provider->getFunctions() as $function) {
  134.             $this->addFunction($function);
  135.         }
  136.     }
  138.     protected function registerFunctions()
  139.     {
  140.         $this->addFunction(ExpressionFunction::fromPhp('constant'));
  141.     }
  143.     private function getLexer(): Lexer
  144.     {
  145.         return $this->lexer ??= new Lexer();
  146.     }
  148.     private function getParser(): Parser
  149.     {
  150.         return $this->parser ??= new Parser($this->functions);
  151.     }
  153.     private function getCompiler(): Compiler
  154.     {
  155.         $this->compiler ??= new Compiler($this->functions);
  157.         return $this->compiler->reset();
  158.     }
  159. }