FOS\ElasticaBundle\Provider\Indexable

Complexity

Total Complexity

19

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

76.6%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	buildCallback()	0	18	5
A	buildExpressionCallback()	0	21	3
A	getCallback()	0	8	2
A	getExpressionLanguage()	0	8	2
A	getExpressionVar()	0	10	2
A	isObjectIndexable()	0	17	4

<?php

/*
 * This file is part of the FOSElasticaBundle package.
 *
 * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace FOS\ElasticaBundle\Provider;

use Symfony\Component\ExpressionLanguage\Expression;
use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
use Symfony\Component\ExpressionLanguage\SyntaxError;

class Indexable implements IndexableInterface
{
    /**
     * An array of raw configured callbacks for all types.
     *
     * @var array
     */
    private $callbacks = [];

    /**
     * An instance of ExpressionLanguage.
     *
     * @var ExpressionLanguage
     */
    private $expressionLanguage;

    /**
     * An array of initialised callbacks.
     *
     * @var array
     */
    private $initialisedCallbacks = [];

    public function __construct(array $callbacks)
    {
        $this->callbacks = $callbacks;
    }

    /**
     * Return whether the object is indexable with respect to the callback.
     */
    public function isObjectIndexable(string $indexName, object $object): bool
    {
        if (!$callback = $this->getCallback($indexName, $object)) {
            return true;
        }

        if ($callback instanceof Expression) {
            return (bool) $this->getExpressionLanguage()->evaluate($callback, [
                'object' => $object,
                $this->getExpressionVar($object) => $object,
            ]);
        }

        return is_string($callback)
            ? call_user_func([$object, $callback])
            : call_user_func($callback, $object);
    }

    /**
     * Builds and initialises a callback.
     *
     * @return callable|string|ExpressionLanguage|null
     */
    private function buildCallback(string $index, object $object)
    {
        if (!array_key_exists($index, $this->callbacks)) {
            return null;
        }

        $callback = $this->callbacks[$index];

        if (is_callable($callback) or is_callable([$object, $callback])) {
            return $callback;
        }

        if (is_string($callback)) {
            return $this->buildExpressionCallback($index, $object, $callback);
        }

        throw new \InvalidArgumentException(sprintf('Callback for index "%s" is not a valid callback.', $index));
    }

    /**
     * Processes a string expression into an Expression.
     */
    private function buildExpressionCallback(string $index, object $object, string $callback): Expression
    {
        $expression = $this->getExpressionLanguage();
        if (!$expression) {
            throw new \RuntimeException('Unable to process an expression without the ExpressionLanguage component.');
        }

        try {
            $callback = new Expression($callback);
            $expression->compile($callback, [
                'object', $this->getExpressionVar($object),
            ]);

            return $callback;
        } catch (SyntaxError $e) {
            throw new \InvalidArgumentException(sprintf(
                'Callback for index "%s" is an invalid expression',
                $index
            ), $e->getCode(), $e);
        }
    }

    /**
     * Retreives a cached callback, or creates a new callback if one is not found.
     *
     * @return mixed
     */
    private function getCallback(string $index, object $object)
    {
        if (!array_key_exists($index, $this->initialisedCallbacks)) {
            $this->initialisedCallbacks[$index] = $this->buildCallback($index, $object);
        }

        return $this->initialisedCallbacks[$index];
    }

    /**
     * Returns the ExpressionLanguage class if it is available.
     */
    private function getExpressionLanguage(): ?ExpressionLanguage
    {
        if (null === $this->expressionLanguage) {
            $this->expressionLanguage = new ExpressionLanguage();
        }

        return $this->expressionLanguage;
    }

    /**
     * Returns the variable name to be used to access the object when using the ExpressionLanguage
     * component to parse and evaluate an expression.
     *
     * @param mixed $object
     */
    private function getExpressionVar($object = null): string
    {
        if (!is_object($object)) {
            return 'object';
        }

        $ref = new \ReflectionClass($object);

        return strtolower($ref->getShortName());
    }
}