Cycle\Database\Injection\JsonExpression

Complexity

Total Complexity

18

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	parseArraySyntax()	0	24	6
A	getTokens()	0	5	1
A	getType()	0	3	1
A	__toString()	0	3	1
A	__construct()	0	11	3
A	wrapPath()	0	8	2
A	getQuotes()	0	3	1
A	__set_state()	0	5	1
A	wrapPathSegment()	0	9	2

<?php

/**
 * This file is part of Cycle ORM package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Cycle\Database\Injection;

use Cycle\Database\Driver\CompilerInterface;
use Cycle\Database\Driver\Quoter;
use Cycle\Database\Exception\DriverException;

abstract class JsonExpression implements FragmentInterface
{
    protected string $expression;
    protected Quoter $quoter;

    /**
     * @var ParameterInterface[]
     */
    protected array $parameters = [];

    /**
     * @psalm-param non-empty-string $statement
     */
    public function __construct(string $statement, mixed ...$parameters)
    {
        $this->quoter = new Quoter('', $this->getQuotes());

        $this->expression = $this->compile($statement);

        foreach ($parameters as $parameter) {
            if ($parameter instanceof ParameterInterface) {
                $this->parameters[] = $parameter;
            } else {
                $this->parameters[] = new Parameter($parameter);
            }
        }
    }

    public function __toString(): string
    {
        return 'exp:' . $this->expression;
    }

    public static function __set_state(array $an_array): self
    {
        return new static(
            $an_array['expression'] ?? $an_array['statement'],
            ...($an_array['parameters'] ?? [])
        );
    }

    public function getType(): int
    {
        return CompilerInterface::JSON_EXPRESSION;
    }

    public function getTokens(): array
    {
        return [
            'expression' => $this->expression,
            'parameters' => $this->parameters,
        ];
    }

    abstract protected function compile(string $statement): string;

    /**
     * Transforms a string like "options->languages" into a correct path like $."options"."languages".
     *
     * @param non-empty-string $value

The doc comment non-empty-string at position 0 could not be parsed: Unknown type name 'non-empty-string' at position 0 in non-empty-string.

     * @param non-empty-string $delimiter
     *
     * @return non-empty-string

The doc comment non-empty-string at position 0 could not be parsed: Unknown type name 'non-empty-string' at position 0 in non-empty-string.

     */
    public function wrapPath(string $value, string $delimiter = '->'): string
    {
        $value = \preg_replace("/([\\\\]+)?\\'/", "''", $value);

        $segments = \explode($delimiter, $value);
        $path = \implode('.', \array_map(fn (string $segment): string => $this->wrapPathSegment($segment), $segments));

        return "'$" . (\str_starts_with($path, '[') ? '' : '.') . $path . "'";
    }

    /**
     * Parses a string with array access syntax (e.g., "field[array-key]") and extracts the field name and key.
     *
     * @param non-empty-string $path

The doc comment non-empty-string at position 0 could not be parsed: Unknown type name 'non-empty-string' at position 0 in non-empty-string.

     *
     * @return array<non-empty-string>

The doc comment array<non-empty-string> at position 2 could not be parsed: Unknown type name 'non-empty-string' at position 2 in array<non-empty-string>.

     */
    protected function parseArraySyntax(string $path): array
    {
        if (\preg_match('/(\[[^\]]+\])+$/', $path, $parts)) {
            $parsed = [\trim(\substr($path, 0, \strpos($path, $parts[0])))];

            \preg_match_all('/\[([^\]]+)\]/', $parts[0], $matches);

            foreach ($matches[1] as $key) {
                if (\trim($key) === '') {
                    throw new DriverException('Invalid JSON array path syntax. Array key must not be empty.');
                }
                $parsed[] = $key;
            }

            return $parsed;
        }

        if (\str_contains($path, '[') && \str_contains($path, ']')) {
            throw new DriverException(
                'Unable to parse array path syntax. Array key must be wrapped in square brackets.'
            );
        }

        return [$path];
    }

    protected function getQuotes(): string
    {
        return '""';
    }

    /**
     * @param non-empty-string $segment

The doc comment non-empty-string at position 0 could not be parsed: Unknown type name 'non-empty-string' at position 0 in non-empty-string.

     *
     * @return non-empty-string

The doc comment non-empty-string at position 0 could not be parsed: Unknown type name 'non-empty-string' at position 0 in non-empty-string.

     */
    private function wrapPathSegment(string $segment): string
    {
        $parts = $this->parseArraySyntax($segment);

        if (isset($parts[1])) {
            return \sprintf('"%s"[%s]', $parts[0], $parts[1]);
        }

        return \sprintf('"%s"', $segment);
    }
}