MagicWord.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;
 
class MagicWord {
    public $mId;
 
    public $mSynonyms;
 
    public $mCaseSensitive;
 
    private $mRegex = '';
 
    private $mRegexStart = '';
 
    private $mRegexStartToEnd = '';
 
    private $mBaseRegex = '';
 
    private $mVariableRegex = '';
 
    private $mVariableStartToEndRegex = '';
 
    private $mModified = false;
 
    private $mFound = false;
 
    private $contLang;
 
    public function __construct( $id = null, $syn = [], $cs = false, Language $contLang = null ) {
        $this->mId = $id;
        $this->mSynonyms = (array)$syn;
        $this->mCaseSensitive = $cs;
        $this->contLang = $contLang ?: MediaWikiServices::getInstance()->getContentLanguage();
    }
 
    public static function get( $id ) {
        wfDeprecated( __METHOD__, '1.32' );
        return MediaWikiServices::getInstance()->getMagicWordFactory()->get( $id );
    }
 
    public static function getVariableIDs() {
        wfDeprecated( __METHOD__, '1.32' );
        return MediaWikiServices::getInstance()->getMagicWordFactory()->getVariableIDs();
    }
 
    public static function getSubstIDs() {
        wfDeprecated( __METHOD__, '1.32' );
        return MediaWikiServices::getInstance()->getMagicWordFactory()->getSubstIDs();
    }
 
    public static function getCacheTTL( $id ) {
        wfDeprecated( __METHOD__, '1.32' );
        return MediaWikiServices::getInstance()->getMagicWordFactory()->getCacheTTL( $id );
    }
 
    public static function getDoubleUnderscoreArray() {
        wfDeprecated( __METHOD__, '1.32' );
        return MediaWikiServices::getInstance()->getMagicWordFactory()->getDoubleUnderscoreArray();
    }
 
    public function load( $id ) {
        $this->mId = $id;
        $this->contLang->getMagic( $this );
        if ( !$this->mSynonyms ) {
            $this->mSynonyms = [ 'brionmademeputthishere' ];
            throw new MWException( "Error: invalid magic word '$id'" );
        }
    }
 
    public function initRegex() {
        // Sort the synonyms by length, descending, so that the longest synonym
        // matches in precedence to the shortest
        $synonyms = $this->mSynonyms;
        usort( $synonyms, [ $this, 'compareStringLength' ] );
 
        $escSyn = [];
        foreach ( $synonyms as $synonym ) {
            // In case a magic word contains /, like that's going to happen;)
            $escSyn[] = preg_quote( $synonym, '/' );
        }
        $this->mBaseRegex = implode( '|', $escSyn );
 
        $case = $this->mCaseSensitive ? '' : 'iu';
        $this->mRegex = "/{$this->mBaseRegex}/{$case}";
        $this->mRegexStart = "/^(?:{$this->mBaseRegex})/{$case}";
        $this->mRegexStartToEnd = "/^(?:{$this->mBaseRegex})$/{$case}";
        $this->mVariableRegex = str_replace( "\\$1", "(.*?)", $this->mRegex );
        $this->mVariableStartToEndRegex = str_replace( "\\$1", "(.*?)",
            "/^(?:{$this->mBaseRegex})$/{$case}" );
    }
 
    public function compareStringLength( $s1, $s2 ) {
        $l1 = strlen( $s1 );
        $l2 = strlen( $s2 );
        return $l2 <=> $l1; // descending
    }
 
    public function getRegex() {
        if ( $this->mRegex == '' ) {
            $this->initRegex();
        }
        return $this->mRegex;
    }
 
    public function getRegexCase() {
        if ( $this->mRegex === '' ) {
            $this->initRegex();
        }
 
        return $this->mCaseSensitive ? '' : 'iu';
    }
 
    public function getRegexStart() {
        if ( $this->mRegex == '' ) {
            $this->initRegex();
        }
        return $this->mRegexStart;
    }
 
    public function getRegexStartToEnd() {
        if ( $this->mRegexStartToEnd == '' ) {
            $this->initRegex();
        }
        return $this->mRegexStartToEnd;
    }
 
    public function getBaseRegex() {
        if ( $this->mRegex == '' ) {
            $this->initRegex();
        }
        return $this->mBaseRegex;
    }
 
    public function match( $text ) {
        return (bool)preg_match( $this->getRegex(), $text );
    }
 
    public function matchStart( $text ) {
        return (bool)preg_match( $this->getRegexStart(), $text );
    }
 
    public function matchStartToEnd( $text ) {
        return (bool)preg_match( $this->getRegexStartToEnd(), $text );
    }
 
    public function matchVariableStartToEnd( $text ) {
        $matches = [];
        $matchcount = preg_match( $this->getVariableStartToEndRegex(), $text, $matches );
        if ( $matchcount == 0 ) {
            return null;
        } else {
            # multiple matched parts (variable match); some will be empty because of
            # synonyms. The variable will be the second non-empty one so remove any
            # blank elements and re-sort the indices.
            # See also T8526
 
            $matches = array_values( array_filter( $matches ) );
 
            if ( count( $matches ) == 1 ) {
                return $matches[0];
            } else {
                return $matches[1];
            }
        }
    }
 
    public function matchAndRemove( &$text ) {
        $this->mFound = false;
        $text = preg_replace_callback(
            $this->getRegex(),
            [ $this, 'pregRemoveAndRecord' ],
            $text
        );
 
        return $this->mFound;
    }
 
    public function matchStartAndRemove( &$text ) {
        $this->mFound = false;
        $text = preg_replace_callback(
            $this->getRegexStart(),
            [ $this, 'pregRemoveAndRecord' ],
            $text
        );
 
        return $this->mFound;
    }
 
    public function pregRemoveAndRecord() {
        $this->mFound = true;
        return '';
    }
 
    public function replace( $replacement, $subject, $limit = -1 ) {
        $res = preg_replace(
            $this->getRegex(),
            StringUtils::escapeRegexReplacement( $replacement ),
            $subject,
            $limit
        );
        $this->mModified = $res !== $subject;
        return $res;
    }
 
    public function substituteCallback( $text, $callback ) {
        $res = preg_replace_callback( $this->getVariableRegex(), $callback, $text );
        $this->mModified = $res !== $text;
        return $res;
    }
 
    public function getVariableRegex() {
        if ( $this->mVariableRegex == '' ) {
            $this->initRegex();
        }
        return $this->mVariableRegex;
    }
 
    public function getVariableStartToEndRegex() {
        if ( $this->mVariableStartToEndRegex == '' ) {
            $this->initRegex();
        }
        return $this->mVariableStartToEndRegex;
    }
 
    public function getSynonym( $i ) {
        return $this->mSynonyms[$i];
    }
 
    public function getSynonyms() {
        return $this->mSynonyms;
    }
 
    public function getWasModified() {
        return $this->mModified;
    }
 
    public function addToArray( &$array, $value ) {
        foreach ( $this->mSynonyms as $syn ) {
            $array[$this->contLang->lc( $syn )] = $value;
        }
    }
 
    public function isCaseSensitive() {
        return $this->mCaseSensitive;
    }
 
    public function getId() {
        return $this->mId;
    }
}