ICanBoogie\CLDR\Supplemental\Plurals\Rule

Complexity

Total Complexity

7

Size/Duplication

Total Lines	76
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	validate_and()	0	5	1
A	from()	0	5	1
A	parse_rule()	0	9	1
A	validate_or()	0	5	1
A	validate()	0	5	1
A	extract_relations()	0	5	1

<?php

namespace ICanBoogie\CLDR\Supplemental\Plurals;

use function array_map;
use function array_walk_recursive;
use function explode;
use function ICanBoogie\iterable_every;
use function ICanBoogie\iterable_some;

/**
 * Representation of plural samples.
 *
 * @link https://unicode.org/reports/tr35/tr35-72-numbers.html#Language_Plural_Rules
 */
final class Rule
{
    public static function from(string $rule): Rule
    {
        return RuleCache::get(
            $rule,
            static fn(): Rule => new self(self::parse_rule($rule))
        );
    }

    /**
     * @return array<Relation[]>
     *     An array of 'OR' relations, where _value_ is an array of 'AND' relations.
     */
    private static function parse_rule(string $rules): array
    {
        $relations = self::extract_relations($rules);
        array_walk_recursive($relations, function (string &$relation): void {
            $relation = Relation::from($relation);
        });

        /** @var array<Relation[]> */
        return $relations;
    }

    /**
     * @return array<string[]>
     *      An array of 'OR' relations, where _value_ is an array of 'AND' relations.
     */
    private static function extract_relations(string $rule): array
    {
        return array_map(
            static fn(string $rule): array => explode(' and ', $rule),
            explode(' or ', $rule)
        );
    }

    /**
     * @param Relation[][] $relations
     */
    private function __construct(
        private readonly array $relations
    ) {
    }

    /**
     * Whether a number matches the rule.
     *
     * @param float|int|numeric-string $number

The doc comment float|int|numeric-string at position 4 could not be parsed: Unknown type name 'numeric-string' at position 4 in float|int|numeric-string.

     */
    public function validate(float|int|string $number): bool
    {
        $operands = Operands::from($number);

        return $this->validate_or($operands, $this->relations);
    }

    /**
     * @param Relation[][] $or_relations
     */
    public function validate_or(Operands $operands, iterable $or_relations): bool
    {
        return iterable_some(
            $or_relations,
            fn($and_relations) => $this->validate_and($operands, $and_relations)
        );
    }

    /**
     * @param Relation[] $and_relations
     */
    public function validate_and(Operands $operands, iterable $and_relations): bool
    {
        return iterable_every(
            $and_relations,
            fn(Relation $relation) => $relation->evaluate($operands)
        );
    }
}