MagicWordArray.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Parser;
 
use LogicException;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
 
class MagicWordArray {
 
    public $names = [];
    private MagicWordFactory $factory;
 
    private $hash;
 
    private $baseRegex;
 
    private $regex;
 
    public function __construct( $names = [], MagicWordFactory $factory = null ) {
        $this->names = $names;
        $this->factory = $factory ?: MediaWikiServices::getInstance()->getMagicWordFactory();
    }
 
    public function add( $name ): void {
        $this->names[] = $name;
        $this->hash = $this->baseRegex = $this->regex = null;
    }
 
    public function getHash(): array {
        if ( $this->hash === null ) {
            $this->hash = [ 0 => [], 1 => [] ];
            foreach ( $this->names as $name ) {
                $magic = $this->factory->get( $name );
                $case = intval( $magic->isCaseSensitive() );
                foreach ( $magic->getSynonyms() as $syn ) {
                    if ( !$case ) {
                        $syn = $this->factory->getContentLanguage()->lc( $syn );
                    }
                    $this->hash[$case][$syn] = $name;
                }
            }
        }
        return $this->hash;
    }
 
    public function getBaseRegex( bool $capture = true, string $delimiter = '/' ): array {
        if ( $capture && $delimiter === '/' && $this->baseRegex !== null ) {
            return $this->baseRegex;
        }
        $regex = [ 0 => [], 1 => [] ];
        foreach ( $this->names as $name ) {
            $magic = $this->factory->get( $name );
            $case = $magic->isCaseSensitive() ? 1 : 0;
            foreach ( $magic->getSynonyms() as $i => $syn ) {
                if ( $capture ) {
                    // Group name must start with a non-digit in PCRE 8.34+
                    $it = strtr( $i, '0123456789', 'abcdefghij' );
                    $groupName = $it . '_' . $name;
                    $group = '(?P<' . $groupName . '>' . preg_quote( $syn, $delimiter ) . ')';
                    $regex[$case][] = $group;
                } else {
                    $regex[$case][] = preg_quote( $syn, $delimiter );
                }
            }
        }
        '@phan-var array<int,string[]> $regex';
        foreach ( $regex as $case => &$re ) {
            $re = count( $re ) ? implode( '|', $re ) : '(?!)';
            if ( !$case ) {
                $re = "(?i:{$re})";
            }
        }
        '@phan-var array<int,string> $regex';
 
        if ( $capture && $delimiter === '/' ) {
            $this->baseRegex = $regex;
        }
        return $regex;
    }
 
    private function getRegex(): array {
        if ( $this->regex === null ) {
            $this->regex = [];
            $base = $this->getBaseRegex( true, '/' );
            foreach ( $base as $case => $re ) {
                $this->regex[$case] = "/$re/JS";
            }
            // As a performance optimization, turn on unicode mode only for
            // case-insensitive matching.
            $this->regex[0] .= 'u';
        }
        return $this->regex;
    }
 
    private function getRegexStart(): array {
        $newRegex = [];
        $base = $this->getBaseRegex( true, '/' );
        foreach ( $base as $case => $re ) {
            $newRegex[$case] = "/^(?:$re)/JS";
        }
        // As a performance optimization, turn on unicode mode only for
        // case-insensitive matching.
        $newRegex[0] .= 'u';
        return $newRegex;
    }
 
    private function getVariableStartToEndRegex(): array {
        $newRegex = [];
        $base = $this->getBaseRegex( true, '/' );
        foreach ( $base as $case => $re ) {
            $newRegex[$case] = str_replace( '\$1', '(.*?)', "/^(?:$re)$/JS" );
        }
        // As a performance optimization, turn on unicode mode only for
        // case-insensitive matching.
        $newRegex[0] .= 'u';
        return $newRegex;
    }
 
    public function getNames() {
        return $this->names;
    }
 
    private function parseMatch( array $matches ): array {
        $magicName = null;
        foreach ( $matches as $key => $match ) {
            if ( $magicName !== null ) {
                // The structure we found at this point is [ …,
                //     'a_magicWordName' => 'matchedSynonym',
                //     n                 => 'matchedSynonym (again)',
                //     n + 1             => 'parameterValue',
                // … ]
                return [ $magicName, $matches[$key + 1] ?? false ];
            }
            // Skip the initial full match and any non-matching group
            if ( $match !== '' && $key !== 0 ) {
                $parts = explode( '_', $key, 2 );
                if ( !isset( $parts[1] ) ) {
                    throw new LogicException( 'Unexpected group name' );
                }
                $magicName = $parts[1];
            }
        }
        throw new LogicException( 'Unexpected $m array with no match' );
    }
 
    public function matchVariableStartToEnd( $text ): array {
        $regexes = $this->getVariableStartToEndRegex();
        foreach ( $regexes as $regex ) {
            $m = [];
            if ( preg_match( $regex, $text, $m ) ) {
                return $this->parseMatch( $m );
            }
        }
        return [ false, false ];
    }
 
    public function matchStartToEnd( $text ) {
        $hash = $this->getHash();
        if ( isset( $hash[1][$text] ) ) {
            return $hash[1][$text];
        }
        $lc = $this->factory->getContentLanguage()->lc( $text );
        return $hash[0][$lc] ?? false;
    }
 
    public function matchAndRemove( &$text ): array {
        $found = [];
        $regexes = $this->getRegex();
        $res = preg_replace_callback( $regexes, function ( $m ) use ( &$found ) {
            [ $name, $param ] = $this->parseMatch( $m );
            $found[$name] = $param;
            return '';
        }, $text );
        // T321234: Don't try to fix old revisions with broken UTF-8, just return $text as is
        if ( $res === null ) {
            $error = preg_last_error();
            $errorText = preg_last_error_msg();
            LoggerFactory::getInstance( 'parser' )->warning( 'preg_match_all error: {code} {errorText}', [
                'code' => $error,
                'regex' => $regexes,
                'text' => $text,
                'errorText' => $errorText
            ] );
            if ( $error !== PREG_BAD_UTF8_ERROR ) {
                throw new LogicException( "preg_match_all error $error: $errorText" );
            }
        } else {
            $text = $res;
        }
        return $found;
    }
 
    public function matchStartAndRemove( &$text ) {
        $regexes = $this->getRegexStart();
        foreach ( $regexes as $regex ) {
            if ( preg_match( $regex, $text, $m ) ) {
                [ $id, ] = $this->parseMatch( $m );
                if ( strlen( $m[0] ) >= strlen( $text ) ) {
                    $text = '';
                } else {
                    $text = substr( $text, strlen( $m[0] ) );
                }
                return $id;
            }
        }
        return false;
    }
}
 
class_alias( MagicWordArray::class, 'MagicWordArray' );