Khusseini\PimcoreRadBrickBundle\ExpressionLanguage\ExpressionWrapper

Complexity

Total Complexity

12

Size/Duplication

Total Lines	98
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	getPropertyValue()	0	5	1
A	evaluateExpression()	0	6	2
A	evaluateExpressions()	0	22	4
A	setPropertyValue()	0	5	1
A	getExpressionLanguage()	0	7	2
A	getPropertyAccess()	0	9	2

<?php

namespace Khusseini\PimcoreRadBrickBundle\ExpressionLanguage;

use Khusseini\PimcoreRadBrickBundle\Context;
use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
use Symfony\Component\PropertyAccess\Exception\AccessException;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;

class ExpressionWrapper
{
    /**
     * @var ExpressionLanguage
     */
    private $expressionLanguage;

    /**
     * @var PropertyAccessorInterface
     */
    private $propAccess;

    private function getExpressionLanguage(): ExpressionLanguage
    {
        if (null === $this->expressionLanguage) {
            $this->expressionLanguage = new ExpressionLanguage();
        }

        return $this->expressionLanguage;
    }

    private function getPropertyAccess(): PropertyAccessorInterface
    {
        if (null === $this->propAccess) {
            $this->propAccess = PropertyAccess::createPropertyAccessorBuilder()
                ->enableExceptionOnInvalidIndex()
                ->getPropertyAccessor();
        }

        return $this->propAccess;
    }

    /**
     * @param array<mixed>  $data
     * @param array<string> $attributes
     *
     * @return array<mixed>
     */
    public function evaluateExpressions(
        array $data,
        array $attributes,
        string $contextPath = ''
    ): array {
        $context = $data;
        if ($contextPath) {
            $context = $this->getPropertyValue($data, $contextPath);
        }

        foreach ($attributes as $attributePath) {
            try {
                $value = $this->getPropertyValue($data, $attributePath);
            } catch (AccessException $ex) {
                continue;
            }

            $value = $this->evaluateExpression($value, $context);
            $data = $this->setPropertyValue($data, $attributePath, $value);
        }

        return $data;

The expression return $data could return the type object which is incompatible with the type-hinted return array. Consider adding an additional type-check to rule them out.

    }

    /**
     * @param array<array>|object $objectOrArray
     *
     * @return mixed
     */
    public function getPropertyValue($objectOrArray, string $propertyPath)
    {
        return $this
            ->getPropertyAccess()
            ->getValue($objectOrArray, $propertyPath);
    }

    /**
     * @param array<array>|object $objectOrArray
     * @param mixed               $value
     *
     * @return array<array>|object
     */
    public function setPropertyValue($objectOrArray, string $propertyPath, $value)
    {
        $this->getPropertyAccess()->setValue($objectOrArray, $propertyPath, $value);

        return $objectOrArray;
    }

    /**
     * @param array<array> $context
     *
     * @return mixed
     */
    public function evaluateExpression(string $value, array $context)
    {
        try {
            return $this->getExpressionLanguage()->evaluate($value, $context);
        } catch (\Exception $ex) {
            return $value;
        }
    }
}