JsTables.php

<?php
/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
/**
 * Italix Rules - JsTables
 *
 * @package Italix\Rules
 * @license MPL-2.0
 */

declare(strict_types=1);

namespace Italix\Rules;

use Italix\Rules\Checks\IbanCheck;
use Italix\Rules\Checks\PhoneCheck;
use Italix\Rules\Checks\TaxCodeCheck;
use Italix\Rules\Checks\VatNumberCheck;
use Italix\Rules\Checks\ZipCodeCheck;
use ReflectionClass;

/**
 * The browser mirror's data tables, rendered from the PHP ones.
 *
 * The mirror is split deliberately: **the facts are generated, the arithmetic
 * is hand-written.** Copying the tables by hand would guarantee drift — someone
 * adds a country to the PHP side, the browser keeps rejecting it, and the form
 * disagrees with the save for months without anybody noticing. Generated, they
 * cannot diverge.
 *
 * The arithmetic stays hand-written because PHP and JavaScript differ enough
 * that a transliteration would be its own bug farm. What proves it agrees is
 * not codegen, it is `tests/MirrorTest.php`, which runs both sides over a
 * generated corpus.
 *
 * This lives in the library rather than in a console command so that the
 * library's own test suite can assert the committed file is current. A check
 * that only a console verb can run is a check nobody runs.
 */
final class JsTables
{
    /** Where the rendered file belongs, relative to this package's root. */
    public const PATH = 'js/rules-data.js';

    /**
     * Every table the mirror needs, read from the checks that own them.
     *
     * @return array<string, array<mixed>>
     */
    public static function tables(): array
    {
        return [
            'iban_lengths' => self::read(IbanCheck::class, 'lengths'),
            'vat_weights'  => self::read(VatNumberCheck::class, 'WEIGHTS'),
            'vat_prefixes' => self::read(VatNumberCheck::class, 'PREFIXES'),
            'vat_covered'  => array_keys(self::read(VatNumberCheck::class, 'ALGORITHMS')),
            'zip_patterns' => self::js_patterns(self::read(ZipCodeCheck::class, 'patterns')),
            'tax_odd'      => self::read(TaxCodeCheck::class, 'odd_values'),
            'tax_omocodia' => self::read(TaxCodeCheck::class, 'omocodia'),
            'phone_prefixes' => self::read(PhoneCheck::class, 'dialing_prefixes'),
        ];
    }

    /** The file, exactly as it should be on disk. */
    public static function render(): string
    {
        $lines = [
            '/*',
            ' * This Source Code Form is subject to the terms of the Mozilla Public',
            ' * License, v. 2.0. If a copy of the MPL was not distributed with this',
            ' * file, You can obtain one at https://mozilla.org/MPL/2.0/.',
            ' */',
            '',
            '// GENERATED by `ix rules:emit-js` — do not edit.',
            '//',
            '// These are the same tables the PHP checks use, read out of them by',
            '// reflection. They are generated rather than copied so that the browser and',
            '// the server cannot disagree about a fact: add a country to the PHP table and',
            '// this file follows, instead of the form quietly rejecting what the save',
            '// accepts. tests/GeneratedTest.php fails when the two have drifted.',
            '//',
            '// The arithmetic that uses them is hand-written, in rules.js, and proved to',
            '// agree with PHP by tests/MirrorTest.php.',
            '',
        ];

        foreach (self::tables() as $name_c => $table) {
            $json = json_encode(
                $table,
                JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE
            );

            $lines[] = sprintf('export const %s = %s;', $name_c, $json);
            $lines[] = '';
        }

        return implode("\n", $lines);
    }

    /** Is what is on disk what {@see render()} would write? */
    public static function is_current(string $path): bool
    {
        return is_file($path) && trim((string) file_get_contents($path)) === trim(self::render());
    }

    /**
     * A private constant or static property, without making it public.
     *
     * These tables are private for a good reason — they are an implementation
     * detail of the check, not part of its contract — and reflection reads one
     * without widening the surface for everybody else.
     *
     * @return array<mixed>
     */
    private static function read(string $class_c, string $name_c): array
    {
        $reflection = new ReflectionClass($class_c);

        if ($reflection->hasConstant($name_c)) {
            return (array) $reflection->getConstant($name_c);
        }

        $property = $reflection->getProperty($name_c);
        $property->setAccessible(true);

        return (array) $property->getValue();
    }

    /**
     * PHP patterns are delimited (`~^…$~`); a JavaScript RegExp is not.
     *
     * Emitted as strings rather than regex literals so that a pattern
     * containing a slash cannot break the generated file — the escaping becomes
     * JSON's problem, which JSON is better at than this class.
     *
     * @param  array<string, string> $patterns
     * @return array<string, string>
     */
    private static function js_patterns(array $patterns): array
    {
        $out = [];

        foreach ($patterns as $country_c => $pattern_c) {
            $delimiter_c = substr($pattern_c, 0, 1);
            $end_n       = strrpos($pattern_c, $delimiter_c);

            $out[$country_c] = substr($pattern_c, 1, $end_n - 1);
        }

        return $out;
    }
}