StringMatcher.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\MessageProcessing;
 
use MetaYamlSchemaExtender;
use Title;
 
class StringMatcher implements StringMangler, MetaYamlSchemaExtender {
    protected $sPrefix = '';
    protected $aExact = [];
    protected $aPrefix = [];
    protected $aRegex = [];
 
    public function __construct( string $prefix = '', array $patterns = [] ) {
        $this->sPrefix = $prefix;
        $this->init( $patterns );
    }
 
    protected function init( array $strings ): void {
        foreach ( $strings as $string ) {
            $pos = strpos( $string, '*' );
            if ( $pos === false ) {
                $this->aExact[] = $string;
            } elseif ( $pos + 1 === strlen( $string ) ) {
                $prefix = substr( $string, 0, -1 );
                $this->aPrefix[$prefix] = strlen( $prefix );
            } else {
                $string = str_replace( '\\*', '.+', preg_quote( $string, '/' ) );
                $this->aRegex[] = "/^$string$/";
            }
        }
    }
 
    protected static function getValidKeyChars(): string {
        static $valid = null;
        if ( $valid === null ) {
            $valid = strtr(
                Title::legalChars(),
                [
                    '=' => '', // equals sign, which is itself usef for escaping
                    '&' => '', // ampersand, for entities
                    '%' => '', // percent sign, which is used in URL encoding
                ]
            );
        }
 
        return $valid;
    }
 
    public function setConf( array $conf ): void {
        $this->sPrefix = $conf['prefix'];
        $this->init( $conf['patterns'] );
    }
 
    public function matches( string $key ): bool {
        if ( in_array( $key, $this->aExact ) ) {
            return true;
        }
 
        foreach ( $this->aPrefix as $prefix => $len ) {
            if ( strncmp( $key, $prefix, $len ) === 0 ) {
                return true;
            }
        }
 
        foreach ( $this->aRegex as $regex ) {
            if ( preg_match( $regex, $key ) ) {
                return true;
            }
        }
 
        return false;
    }
 
    public function mangle( string $key ): string {
        if ( $this->matches( $key ) ) {
            $key = $this->sPrefix . $key;
        }
 
        $escaper = static function ( $match ) {
            $esc = '';
            foreach ( str_split( $match[0] ) as $c ) {
                $esc .= '=' . sprintf( '%02X', ord( $c ) );
            }
            return $esc;
        };
 
        // Apply a "quoted-printable"-like escaping
        $valid = self::getValidKeyChars();
        $key = preg_replace_callback( "/[^$valid]/", $escaper, $key );
        // Additional limitations in MediaWiki, see MediaWikiTitleCodec::splitTitleString
        $key = preg_replace_callback( '/(~~~|^[ _]|[ _]$|[ _]{2,}|^:)/', $escaper, $key );
        // TODO: length check + truncation
        // TODO: forbid path travels
 
        return $key;
    }
 
    public function mangleList( array $list ): array {
        return array_map( [ $this, 'mangle' ], $list );
    }
 
    public function mangleArray( array $array ): array {
        $out = [];
        foreach ( $array as $key => $value ) {
            $out[$this->mangle( (string)$key )] = $value;
        }
 
        return $out;
    }
 
    public function unmangle( string $key ): string {
        // Unescape the "quoted-printable"-like escaping,
        // which is applied in mangle
        $unescapedString = preg_replace_callback(
            '/=([A-F0-9]{2})/',
            static function ( $match ) {
                return chr( hexdec( $match[1] ) );
            },
            $key
        );
 
        if ( strncmp( $unescapedString, $this->sPrefix, strlen( $this->sPrefix ) ) === 0 ) {
            $unmangled = substr( $unescapedString, strlen( $this->sPrefix ) );
 
            // Check if this string should be mangled / un-mangled to begin with
            if ( $this->matches( $unmangled ) ) {
                return $unmangled;
            }
        }
        return $unescapedString;
    }
 
    public function unmangleList( array $list ): array {
        foreach ( $list as $index => $key ) {
            $list[$index] = $this->unmangle( $key );
        }
 
        return $list;
    }
 
    public function unmangleArray( array $array ): array {
        $out = [];
        foreach ( $array as $key => $value ) {
            $out[$this->unmangle( $key )] = $value;
        }
 
        return $out;
    }
 
    public static function getExtraSchema(): array {
        $schema = [
            'root' => [
                '_type' => 'array',
                '_children' => [
                    'MANGLER' => [
                        '_type' => 'array',
                        '_children' => [
                            'prefix' => [
                                '_type' => 'text',
                                '_not_empty' => true,
                            ],
                            'patterns' => [
                                '_type' => 'array',
                                '_required' => true,
                                '_ignore_extra_keys' => true,
                                '_children' => [],
                            ],
                        ],
                    ],
                ],
            ],
        ];
 
        return $schema;
    }
}