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

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\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 $cache;
  28.     private $lexer;
  29.     private $parser;
  30.     private $compiler;
  32.     protected $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.      * @param Expression|string $expression The expression to compile
  50.      *
  51.      * @return string The compiled PHP source code
  52.      */
  53.     public function compile($expression, array $names = [])
  54.     {
  55.         return $this->getCompiler()->compile($this->parse($expression, $names)->getNodes())->getSource();
  56.     }
  58.     /**
  59.      * Evaluate an expression.
  60.      *
  61.      * @param Expression|string $expression The expression to compile
  62.      *
  63.      * @return mixed The result of the evaluation of the expression
  64.      */
  65.     public function evaluate($expression, array $values = [])
  66.     {
  67.         return $this->parse($expression, array_keys($values))->getNodes()->evaluate($this->functions, $values);
  68.     }
  70.     /**
  71.      * Parses an expression.
  72.      *
  73.      * @param Expression|string $expression The expression to parse
  74.      *
  75.      * @return ParsedExpression A ParsedExpression instance
  76.      */
  77.     public function parse($expression, array $names)
  78.     {
  79.         if ($expression instanceof ParsedExpression) {
  80.             return $expression;
  81.         }
  83.         asort($names);
  84.         $cacheKeyItems = [];
  86.         foreach ($names as $nameKey => $name) {
  87.             $cacheKeyItems[] = \is_int($nameKey) ? $name : $nameKey.':'.$name;
  88.         }
  90.         $cacheItem = $this->cache->getItem(rawurlencode($expression.'//'.implode('|', $cacheKeyItems)));
  92.         if (null === $parsedExpression = $cacheItem->get()) {
  93.             $nodes = $this->getParser()->parse($this->getLexer()->tokenize((string) $expression), $names);
  94.             $parsedExpression = new ParsedExpression((string) $expression, $nodes);
  96.             $cacheItem->set($parsedExpression);
  97.             $this->cache->save($cacheItem);
  98.         }
  100.         return $parsedExpression;
  101.     }
  103.     /**
  104.      * Validates the syntax of an expression.
  105.      *
  106.      * @param Expression|string $expression The expression to validate
  107.      * @param array|null        $names      The list of acceptable variable names in the expression, or null to accept any names
  108.      *
  109.      * @throws SyntaxError When the passed expression is invalid
  110.      */
  111.     public function lint($expression, ?array $names): void
  112.     {
  113.         if ($expression instanceof ParsedExpression) {
  114.             return;
  115.         }
  117.         $this->getParser()->lint($this->getLexer()->tokenize((string) $expression), $names);
  118.     }
  120.     /**
  121.      * Registers a function.
  122.      *
  123.      * @param callable $compiler  A callable able to compile the function
  124.      * @param callable $evaluator A callable able to evaluate the function
  125.      *
  126.      * @throws \LogicException when registering a function after calling evaluate(), compile() or parse()
  127.      *
  128.      * @see ExpressionFunction
  129.      */
  130.     public function register(string $name, callable $compiler, callable $evaluator)
  131.     {
  132.         if (null !== $this->parser) {
  133.             throw new \LogicException('Registering functions after calling evaluate(), compile() or parse() is not supported.');
  134.         }
  136.         $this->functions[$name] = ['compiler' => $compiler, 'evaluator' => $evaluator];
  137.     }
  139.     public function addFunction(ExpressionFunction $function)
  140.     {
  141.         $this->register($function->getName(), $function->getCompiler(), $function->getEvaluator());
  142.     }
  144.     public function registerProvider(ExpressionFunctionProviderInterface $provider)
  145.     {
  146.         foreach ($provider->getFunctions() as $function) {
  147.             $this->addFunction($function);
  148.         }
  149.     }
  151.     protected function registerFunctions()
  152.     {
  153.         $this->addFunction(ExpressionFunction::fromPhp('constant'));
  154.     }
  156.     private function getLexer(): Lexer
  157.     {
  158.         if (null === $this->lexer) {
  159.             $this->lexer = new Lexer();
  160.         }
  162.         return $this->lexer;
  163.     }
  165.     private function getParser(): Parser
  166.     {
  167.         if (null === $this->parser) {
  168.             $this->parser = new Parser($this->functions);
  169.         }
  171.         return $this->parser;
  172.     }
  174.     private function getCompiler(): Compiler
  175.     {
  176.         if (null === $this->compiler) {
  177.             $this->compiler = new Compiler($this->functions);
  178.         }
  180.         return $this->compiler->reset();
  181.     }
  182. }