MagicWord.php

Go to the documentation of this file.

<?php
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;
 
    public static $mVariableIDsInitialised = false;
    public static $mVariableIDs = [
        '!',
        'currentmonth',
        'currentmonth1',
        'currentmonthname',
        'currentmonthnamegen',
        'currentmonthabbrev',
        'currentday',
        'currentday2',
        'currentdayname',
        'currentyear',
        'currenttime',
        'currenthour',
        'localmonth',
        'localmonth1',
        'localmonthname',
        'localmonthnamegen',
        'localmonthabbrev',
        'localday',
        'localday2',
        'localdayname',
        'localyear',
        'localtime',
        'localhour',
        'numberofarticles',
        'numberoffiles',
        'numberofedits',
        'articlepath',
        'pageid',
        'sitename',
        'server',
        'servername',
        'scriptpath',
        'stylepath',
        'pagename',
        'pagenamee',
        'fullpagename',
        'fullpagenamee',
        'namespace',
        'namespacee',
        'namespacenumber',
        'currentweek',
        'currentdow',
        'localweek',
        'localdow',
        'revisionid',
        'revisionday',
        'revisionday2',
        'revisionmonth',
        'revisionmonth1',
        'revisionyear',
        'revisiontimestamp',
        'revisionuser',
        'revisionsize',
        'subpagename',
        'subpagenamee',
        'talkspace',
        'talkspacee',
        'subjectspace',
        'subjectspacee',
        'talkpagename',
        'talkpagenamee',
        'subjectpagename',
        'subjectpagenamee',
        'numberofusers',
        'numberofactiveusers',
        'numberofpages',
        'currentversion',
        'rootpagename',
        'rootpagenamee',
        'basepagename',
        'basepagenamee',
        'currenttimestamp',
        'localtimestamp',
        'directionmark',
        'contentlanguage',
        'numberofadmins',
        'cascadingsources',
    ];
 
    /* Array of caching hints for ParserCache */
    public static $mCacheTTLs = [
        'currentmonth' => 86400,
        'currentmonth1' => 86400,
        'currentmonthname' => 86400,
        'currentmonthnamegen' => 86400,
        'currentmonthabbrev' => 86400,
        'currentday' => 3600,
        'currentday2' => 3600,
        'currentdayname' => 3600,
        'currentyear' => 86400,
        'currenttime' => 3600,
        'currenthour' => 3600,
        'localmonth' => 86400,
        'localmonth1' => 86400,
        'localmonthname' => 86400,
        'localmonthnamegen' => 86400,
        'localmonthabbrev' => 86400,
        'localday' => 3600,
        'localday2' => 3600,
        'localdayname' => 3600,
        'localyear' => 86400,
        'localtime' => 3600,
        'localhour' => 3600,
        'numberofarticles' => 3600,
        'numberoffiles' => 3600,
        'numberofedits' => 3600,
        'currentweek' => 3600,
        'currentdow' => 3600,
        'localweek' => 3600,
        'localdow' => 3600,
        'numberofusers' => 3600,
        'numberofactiveusers' => 3600,
        'numberofpages' => 3600,
        'currentversion' => 86400,
        'currenttimestamp' => 3600,
        'localtimestamp' => 3600,
        'pagesinnamespace' => 3600,
        'numberofadmins' => 3600,
        'numberingroup' => 3600,
    ];
 
    public static $mDoubleUnderscoreIDs = [
        'notoc',
        'nogallery',
        'forcetoc',
        'toc',
        'noeditsection',
        'newsectionlink',
        'nonewsectionlink',
        'hiddencat',
        'index',
        'noindex',
        'staticredirect',
        'notitleconvert',
        'nocontentconvert',
    ];
 
    public static $mSubstIDs = [
        'subst',
        'safesubst',
    ];
 
    public static $mObjects = [];
    public static $mDoubleUnderscoreArray = null;
 
    public function __construct( $id = 0, $syn = [], $cs = false ) {
        $this->mId = $id;
        $this->mSynonyms = (array)$syn;
        $this->mCaseSensitive = $cs;
    }
 
    public static function &get( $id ) {
        if ( !isset( self::$mObjects[$id] ) ) {
            $mw = new MagicWord();
            $mw->load( $id );
            self::$mObjects[$id] = $mw;
        }
        return self::$mObjects[$id];
    }
 
    public static function getVariableIDs() {
        if ( !self::$mVariableIDsInitialised ) {
            # Get variable IDs
            Hooks::run( 'MagicWordwgVariableIDs', [ &self::$mVariableIDs ] );
            self::$mVariableIDsInitialised = true;
        }
        return self::$mVariableIDs;
    }
 
    public static function getSubstIDs() {
        return self::$mSubstIDs;
    }
 
    public static function getCacheTTL( $id ) {
        if ( array_key_exists( $id, self::$mCacheTTLs ) ) {
            return self::$mCacheTTLs[$id];
        } else {
            return -1;
        }
    }
 
    public static function getDoubleUnderscoreArray() {
        if ( is_null( self::$mDoubleUnderscoreArray ) ) {
            Hooks::run( 'GetDoubleUnderscoreIDs', [ &self::$mDoubleUnderscoreIDs ] );
            self::$mDoubleUnderscoreArray = new MagicWordArray( self::$mDoubleUnderscoreIDs );
        }
        return self::$mDoubleUnderscoreArray;
    }
 
    public static function clearCache() {
        self::$mObjects = [];
    }
 
    public function load( $id ) {
        global $wgContLang;
        $this->mId = $id;
        $wgContLang->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 );
        if ( $l1 < $l2 ) {
            return 1;
        } elseif ( $l1 > $l2 ) {
            return -1;
        } else {
            return 0;
        }
    }
 
    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 bug 6526
 
            $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 replaceMultiple( $magicarr, $subject, &$result ) {
        wfDeprecated( __METHOD__, '1.25' );
        $search = [];
        $replace = [];
        foreach ( $magicarr as $id => $replacement ) {
            $mw = MagicWord::get( $id );
            $search[] = $mw->getRegex();
            $replace[] = $replacement;
        }
 
        $result = preg_replace( $search, $replace, $subject );
        return $result !== $subject;
    }
 
    public function addToArray( &$array, $value ) {
        global $wgContLang;
        foreach ( $this->mSynonyms as $syn ) {
            $array[$wgContLang->lc( $syn )] = $value;
        }
    }
 
    public function isCaseSensitive() {
        return $this->mCaseSensitive;
    }
 
    public function getId() {
        return $this->mId;
    }
}