uuf6429\ExpressionLanguage\Node\ArrowFuncNode

Complexity

Total Complexity

11

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	compile()	0	16	3
B	evaluate()	0	25	3
A	toArray()	0	17	3
A	__construct()	0	14	2

<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace uuf6429\ExpressionLanguage\Node;

use Symfony\Component\ExpressionLanguage\Node\Node;
use Symfony\Component\ExpressionLanguage\Compiler;
use uuf6429\ExpressionLanguage\SafeCallable;

/**
 * @author Christian Sciberras <christian@sciberras.me>
 *
 * @internal
 */
class ArrowFuncNode extends Node
{
    /**
     * @var SafeCallable
     */
    private static $noopSafeCallable;

    /**
     * @param NameNode[] $parameters
     * @param Node|null  $body
     */
    public function __construct(array $parameters, Node $body = null)
    {
        parent::__construct(
            array(
                'parameters' => $parameters,
                'body' => $body,
            )
        );

        if (!self::$noopSafeCallable) {
            self::$noopSafeCallable = new SafeCallable(function () {
            });
        }
    }

    public function compile(Compiler $compiler)
    {
        $arguments = array();

        foreach ($this->nodes['parameters'] as $parameterNode) {
            $arguments[] = $compiler->subcompile($parameterNode);
        }

        $compiler->raw(
            sprintf(
                'function (%s) { return %s; }',
                implode(', ', $arguments),
                $this->nodes['body'] ? $compiler->subcompile($this->nodes['body']) : 'null'
            )
        );
    }

    public function evaluate($functions, $values)
    {
        /** @var Node|null $bodyNode */
        $bodyNode = $this->nodes['body'];

        if (!$bodyNode) {
            return self::$noopSafeCallable;
        }

        $paramNames = array();

        foreach ($this->nodes['parameters'] as $parameterNode) {
            /** @var NameNode $parameterNode */
            $nodeData = $parameterNode->toArray();
            $paramNames[] = $nodeData[0];
        }

        return new SafeCallable(
            function () use ($functions, $paramNames, $bodyNode) {
                $passedValues = array_combine($paramNames, func_get_args());

                return $bodyNode->evaluate($functions, $passedValues);
            }
        );
    }

    public function toArray()
    {
        $array = array();

        foreach ($this->nodes['parameters'] as $node) {
            $array[] = ', ';
            $array[] = $node;
        }
        $array[0] = '(';
        $array[] = ') -> {';
        if ($this->nodes['body']) {
            $array[] = $this->nodes['body'];
        }
        $array[] = '}';

        return $array;
    }
}