MagicWordArray.php

Go to the documentation of this file.

<?php
 
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
 
class MagicWordArray {
    public $names = [];
 
    private $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 ) {
        $this->names[] = $name;
        $this->hash = $this->baseRegex = $this->regex = null;
    }
 
    public function addArray( $names ) {
        $this->names = array_merge( $this->names, array_values( $names ) );
        $this->hash = $this->baseRegex = $this->regex = null;
    }
 
    public function getHash() {
        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() : array {
        if ( $this->baseRegex === null ) {
            $this->baseRegex = [ 0 => '', 1 => '' ];
            $allGroups = [];
            foreach ( $this->names as $name ) {
                $magic = $this->factory->get( $name );
                $case = intval( $magic->isCaseSensitive() );
                foreach ( $magic->getSynonyms() as $i => $syn ) {
                    // 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, '/' ) . ')';
                    // look for same group names to avoid same named subpatterns in the regex
                    if ( isset( $allGroups[$groupName] ) ) {
                        throw new MWException(
                            __METHOD__ . ': duplicate internal name in magic word array: ' . $name
                        );
                    }
                    $allGroups[$groupName] = true;
                    if ( $this->baseRegex[$case] === '' ) {
                        $this->baseRegex[$case] = $group;
                    } else {
                        $this->baseRegex[$case] .= '|' . $group;
                    }
                }
            }
        }
        return $this->baseRegex;
    }
 
    public function getRegex() {
        if ( $this->regex === null ) {
            $base = $this->getBaseRegex();
            $this->regex = [ '', '' ];
            if ( $this->baseRegex[0] !== '' ) {
                $this->regex[0] = "/{$base[0]}/iuS";
            }
            if ( $this->baseRegex[1] !== '' ) {
                $this->regex[1] = "/{$base[1]}/S";
            }
        }
        return $this->regex;
    }
 
    public function getVariableRegex() {
        return str_replace( "\\$1", "(.*?)", $this->getRegex() );
    }
 
    public function getRegexStart() {
        $base = $this->getBaseRegex();
        $newRegex = [ '', '' ];
        if ( $base[0] !== '' ) {
            $newRegex[0] = "/^(?:{$base[0]})/iuS";
        }
        if ( $base[1] !== '' ) {
            $newRegex[1] = "/^(?:{$base[1]})/S";
        }
        return $newRegex;
    }
 
    public function getVariableStartToEndRegex() {
        $base = $this->getBaseRegex();
        $newRegex = [ '', '' ];
        if ( $base[0] !== '' ) {
            $newRegex[0] = str_replace( "\\$1", "(.*?)", "/^(?:{$base[0]})$/iuS" );
        }
        if ( $base[1] !== '' ) {
            $newRegex[1] = str_replace( "\\$1", "(.*?)", "/^(?:{$base[1]})$/S" );
        }
        return $newRegex;
    }
 
    public function getNames() {
        return $this->names;
    }
 
    public function parseMatch( $m ) {
        reset( $m );
        while ( ( $key = key( $m ) ) !== null ) {
            $value = current( $m );
            next( $m );
            if ( $key === 0 || $value === '' ) {
                continue;
            }
            $parts = explode( '_', $key, 2 );
            if ( count( $parts ) != 2 ) {
                // This shouldn't happen
                // continue;
                throw new MWException( __METHOD__ . ': bad parameter name' );
            }
            list( /* $synIndex */, $magicName ) = $parts;
            $paramValue = next( $m );
            return [ $magicName, $paramValue ];
        }
        // This shouldn't happen either
        throw new MWException( __METHOD__ . ': parameter not found' );
    }
 
    public function matchVariableStartToEnd( $text ) {
        $regexes = $this->getVariableStartToEndRegex();
        foreach ( $regexes as $regex ) {
            if ( $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 ) {
        $found = [];
        $regexes = $this->getRegex();
        foreach ( $regexes as $regex ) {
            if ( $regex === '' ) {
                continue;
            }
            $matches = [];
            $res = preg_match_all( $regex, $text, $matches, PREG_SET_ORDER );
            if ( $res === false ) {
                LoggerFactory::getInstance( 'parser' )->warning( 'preg_match_all returned false', [
                    'code' => preg_last_error(),
                    'regex' => $regex,
                    'text' => $text,
                ] );
            } elseif ( $res ) {
                foreach ( $matches as $m ) {
                    list( $name, $param ) = $this->parseMatch( $m );
                    $found[$name] = $param;
                }
            }
            $res = preg_replace( $regex, '', $text );
            if ( $res === null ) {
                LoggerFactory::getInstance( 'parser' )->warning( 'preg_replace returned null', [
                    'code' => preg_last_error(),
                    'regex' => $regex,
                    'text' => $text,
                ] );
            }
            $text = $res;
        }
        return $found;
    }
 
    public function matchStartAndRemove( &$text ) {
        $regexes = $this->getRegexStart();
        foreach ( $regexes as $regex ) {
            if ( $regex === '' ) {
                continue;
            }
            if ( preg_match( $regex, $text, $m ) ) {
                list( $id, ) = $this->parseMatch( $m );
                if ( strlen( $m[0] ) >= strlen( $text ) ) {
                    $text = '';
                } else {
                    $text = substr( $text, strlen( $m[0] ) );
                }
                return $id;
            }
        }
        return false;
    }
}