Grammar.php

Go to the documentation of this file.

<?php
namespace Wikimedia\Leximorph\Handler;
 
use Psr\Log\LoggerInterface;
use Wikimedia\Leximorph\Handler\Overrides\GrammarFallbackRegistry;
use Wikimedia\Leximorph\Provider;
 
class Grammar {
 
    public function __construct(
        protected readonly Provider $provider,
        private readonly GrammarFallbackRegistry $postProcessor,
        private readonly LoggerInterface $logger,
    ) {
    }
 
    public function process( string $word, string $case, ?array $overrideForms = [] ): string {
        $langCode = $this->provider->getLanguageCode();
 
        if ( isset( $overrideForms[$langCode][$case][$word] ) ) {
            return $overrideForms[$langCode][$case][$word];
        }
 
        $grammarTransformations = $this->provider->getGrammarTransformationsProvider()->getTransformations();
 
        if ( array_key_exists( $case, $grammarTransformations ) ) {
            $forms = $grammarTransformations[$case];
 
            // Some names of grammar rules are aliases for other rules.
            // In such cases the value is a string rather than object,
            // so load the actual rules.
            if ( is_string( $forms ) ) {
                $alias = $forms;
                if ( isset( $grammarTransformations[$alias] ) && is_array( $grammarTransformations[$alias] ) ) {
                    $forms = $grammarTransformations[$alias];
                } else {
                    $this->logger->error(
                        'Expected alias {alias} to resolve to an array in grammar transformations.',
                        [ 'alias' => $alias ]
                    );
 
                    return $word;
                }
            }
 
            if ( !is_array( $forms ) ) {
                $this->logger->error(
                    'Invalid type for grammar forms. Expected array, got {type}.',
                    [ 'type' => gettype( $forms ) ]
                );
 
                return $word;
            }
 
            foreach ( $forms as $rule ) {
                if ( !is_array( $rule ) || !isset( $rule[0] ) || !isset( $rule[1] ) ) {
                    $this->logger->warning(
                        'Skipping malformed grammar rule. Expected [pattern, replacement]. Case: {case}, Rule: {rule}',
                        [
                            'case' => $case,
                            'rule' => json_encode( $rule ),
                        ]
                    );
                    continue;
                }
 
                if ( !is_string( $rule[0] ) ) {
                    $this->logger->warning(
                        'Invalid grammar rule format: first element must be string. Case: {case}, Rule: {rule}',
                        [
                            'case' => $case,
                            'rule' => json_encode( $rule ),
                        ]
                    );
                    continue;
                }
 
                $form = $rule[0];
 
                if ( $form === '@metadata' ) {
                    continue;
                }
 
                $replacement = is_string( $rule[1] ) ? $rule[1] : '';
 
                $regex = '/' . addcslashes( $form, '/' ) . '/u';
                $patternMatches = preg_match( $regex, $word );
 
                if ( $patternMatches === false ) {
                    $this->logger->error(
                        'An error occurred while processing grammar: {error}. Word: {word}. Regex: /{form}/.',
                        [
                            'error' => preg_last_error_msg(),
                            'word' => $word,
                            'form' => $form,
                        ]
                    );
                } elseif ( $patternMatches === 1 ) {
                    $word = preg_replace( $regex, $replacement, $word ) ?? $word;
                    break;
                }
            }
        } else {
            $word = $this->postProcessor->apply( $this->provider->getLanguageCode(), $word, $case );
        }
 
        return $word;
    }
}