Skip to content

Beautiful Open-Source Form Builder

8.2 KB
Raw Blame
<?php

namespace App\Service\Formulas;

use App\Service\Formulas\Functions\FunctionRegistry;

class Validator
{
    private const FUNCTION_ARGUMENTS = [
        // Math functions
        'SUM' => ['min' => 1],
        'AVERAGE' => ['min' => 1],
        'MIN' => ['min' => 1],
        'MAX' => ['min' => 1],
        'ROUND' => ['min' => 1, 'max' => 2],
        'FLOOR' => ['min' => 1, 'max' => 1],
        'CEIL' => ['min' => 1, 'max' => 1],
        'ABS' => ['min' => 1, 'max' => 1],
        'MOD' => ['min' => 2, 'max' => 2],
        'POWER' => ['min' => 2, 'max' => 2],
        'SQRT' => ['min' => 1, 'max' => 1],

        // Text functions
        'CONCAT' => ['min' => 1],
        'UPPER' => ['min' => 1, 'max' => 1],
        'LOWER' => ['min' => 1, 'max' => 1],
        'TRIM' => ['min' => 1, 'max' => 1],
        'LEFT' => ['min' => 2, 'max' => 2],
        'RIGHT' => ['min' => 2, 'max' => 2],
        'MID' => ['min' => 3, 'max' => 3],
        'LEN' => ['min' => 1, 'max' => 1],
        'SUBSTITUTE' => ['min' => 3, 'max' => 4],
        'REPLACE' => ['min' => 4, 'max' => 4],
        'FIND' => ['min' => 2, 'max' => 3],
        'SEARCH' => ['min' => 2, 'max' => 3],
        'REPT' => ['min' => 2, 'max' => 2],
        'TEXT' => ['min' => 2, 'max' => 2],

        // Logic functions
        'IF' => ['min' => 2, 'max' => 3],
        'AND' => ['min' => 1],
        'OR' => ['min' => 1],
        'NOT' => ['min' => 1, 'max' => 1],
        'XOR' => ['min' => 2],
        'ISBLANK' => ['min' => 1, 'max' => 1],
        'ISNUMBER' => ['min' => 1, 'max' => 1],
        'ISTEXT' => ['min' => 1, 'max' => 1],
        'IFERROR' => ['min' => 2, 'max' => 2],
        'IFBLANK' => ['min' => 2, 'max' => 2],
        'COALESCE' => ['min' => 1],
        'SWITCH' => ['min' => 3],
        'IFS' => ['min' => 2],
        'CHOOSE' => ['min' => 2],

        // Array functions
        'COUNT' => ['min' => 1, 'max' => 1],
        'ISEMPTY' => ['min' => 1, 'max' => 1],
        'CONTAINS' => ['min' => 2, 'max' => 2],
        'JOIN' => ['min' => 1, 'max' => 2],
    ];

    private array $availableFields;
    private array $availableVariables;
    private ?string $currentVariableId;

    public function __construct(array $options = [])
    {
        $this->availableFields = $options['availableFields'] ?? [];
        $this->availableVariables = $options['availableVariables'] ?? [];
        $this->currentVariableId = $options['currentVariableId'] ?? null;
    }

    public function validate(string $formula): ValidationResult
    {
        $result = new ValidationResult();

        if (empty(trim($formula))) {
            $result->addError('Formula cannot be empty');
            return $result;
        }

        try {
            $ast = Parser::parse($formula);
            $this->validateNode($ast, $result);
        } catch (FormulaException $e) {
            $result->addError($e->getMessage(), $e->getPosition());
        } catch (\Throwable $e) {
            $result->addError("Syntax error: {$e->getMessage()}");
        }

        return $result;
    }

    private function validateNode(array $node, ValidationResult $result): void
    {
        switch ($node['type']) {
            case 'field':
                $this->validateFieldReference($node, $result);
                break;
            case 'function':
                $this->validateFunctionCall($node, $result);
                break;
            case 'binary':
                $this->validateNode($node['left'], $result);
                $this->validateNode($node['right'], $result);
                break;
            case 'unary':
                $this->validateNode($node['operand'], $result);
                break;
        }
    }

    private function validateFieldReference(array $node, ValidationResult $result): void
    {
        $fieldId = $node['id'];

        // Check for self-reference
        if ($fieldId === $this->currentVariableId) {
            $result->addError('Variable cannot reference itself');
            return;
        }

        // Check if field exists
        $fieldExists = collect($this->availableFields)->contains('id', $fieldId);
        $variableExists = collect($this->availableVariables)->contains('id', $fieldId);

        if (!$fieldExists && !$variableExists) {
            $suggestion = $this->findSimilarField($fieldId);
            if ($suggestion) {
                $result->addError("Unknown field \"{$fieldId}\". Did you mean \"{$suggestion}\"?");
            } else {
                $result->addError("Unknown field \"{$fieldId}\"");
            }
        }
    }

    private function validateFunctionCall(array $node, ValidationResult $result): void
    {
        $funcName = strtoupper($node['name']);

        if (!FunctionRegistry::has($funcName)) {
            $suggestion = $this->findSimilarFunction($funcName);
            if ($suggestion) {
                $result->addError("Unknown function \"{$funcName}\". Did you mean \"{$suggestion}\"?");
            } else {
                $result->addError("Unknown function \"{$funcName}\"");
            }
            return;
        }

        $requirements = self::FUNCTION_ARGUMENTS[$funcName] ?? null;
        $argumentCount = count($node['args']);

        if ($requirements !== null && isset($requirements['min']) && $argumentCount < $requirements['min']) {
            $minimum = $requirements['min'];
            $argumentLabel = $minimum === 1 ? 'argument' : 'arguments';

            if (($requirements['max'] ?? null) === $minimum) {
                $result->addError("Function {$funcName}() requires exactly {$minimum} {$argumentLabel}, but got {$argumentCount}.");
            } else {
                $result->addError("Function {$funcName}() requires at least {$minimum} {$argumentLabel}, but got {$argumentCount}.");
            }

            return;
        }

        if ($requirements !== null && isset($requirements['max']) && $argumentCount > $requirements['max']) {
            $maximum = $requirements['max'];
            $argumentLabel = $maximum === 1 ? 'argument' : 'arguments';
            $result->addError("Function {$funcName}() accepts at most {$maximum} {$argumentLabel}, but got {$argumentCount}.");

            return;
        }

        // Validate function arguments
        foreach ($node['args'] as $arg) {
            $this->validateNode($arg, $result);
        }
    }

    private function findSimilarField(string $fieldId): ?string
    {
        $allIds = array_merge(
            array_column($this->availableFields, 'id'),
            array_column($this->availableVariables, 'id')
        );

        foreach ($allIds as $id) {
            if (levenshtein(strtolower($fieldId), strtolower($id)) <= 2) {
                return $id;
            }
        }

        return null;
    }

    private function findSimilarFunction(string $funcName): ?string
    {
        $functionNames = FunctionRegistry::getAll();

        foreach ($functionNames as $name) {
            if (levenshtein(strtolower($funcName), strtolower($name)) <= 2) {
                return $name;
            }
        }

        return null;
    }

    public static function extractFieldReferences(string $formula): array
    {
        try {
            return array_values(array_map(fn (Token $token) => trim($token->value), array_filter(
                (new Lexer($formula))->tokenize(),
                fn (Token $token) => $token->type === Token::FIELD_REF
            )));
        } catch (FormulaException $exception) {
            return [];
        }
    }
}

class ValidationResult
{
    public bool $valid = true;
    public array $errors = [];
    public array $warnings = [];

    public function addError(string $message, ?int $position = null): void
    {
        $this->valid = false;
        $this->errors[] = [
            'message' => $message,
            'position' => $position,
            'type' => 'error',
        ];
    }

    public function addWarning(string $message, ?int $position = null): void
    {
        $this->warnings[] = [
            'message' => $message,
            'position' => $position,
            'type' => 'warning',
        ];
    }

    public function toArray(): array
    {
        return [
            'valid' => $this->valid,
            'errors' => $this->errors,
            'warnings' => $this->warnings,
        ];
    }
}