MagicWord.php

Go to the documentation of this file.

<?php
class MagicWord {
    var $mId, $mSynonyms, $mCaseSensitive;
    var $mRegex = '';
    var $mRegexStart = '';
    var $mBaseRegex = '';
    var $mVariableRegex = '';
    var $mVariableStartToEndRegex = '';
    var $mModified = false;
    var $mFound = false;

    static public $mVariableIDsInitialised = false;
    static public $mVariableIDs = array(
        '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',
        'numberofviews',
    );

    /* Array of caching hints for ParserCache */
    static public $mCacheTTLs = array(
        '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,
        'numberofviews' => 3600,
        'numberingroup' => 3600,
        );

    static public $mDoubleUnderscoreIDs = array(
        'notoc',
        'nogallery',
        'forcetoc',
        'toc',
        'noeditsection',
        'newsectionlink',
        'nonewsectionlink',
        'hiddencat',
        'index',
        'noindex',
        'staticredirect',
        'notitleconvert',
        'nocontentconvert',
    );

    static public $mSubstIDs = array(
        'subst',
        'safesubst',
    );

    static public $mObjects = array();
    static public $mDoubleUnderscoreArray = null;

    function __construct( $id = 0, $syn = array(), $cs = false ) {
        $this->mId = $id;
        $this->mSynonyms = (array)$syn;
        $this->mCaseSensitive = $cs;
    }

    static function &get( $id ) {
        if ( !isset( self::$mObjects[$id] ) ) {
            $mw = new MagicWord();
            $mw->load( $id );
            self::$mObjects[$id] = $mw;
        }
        return self::$mObjects[$id];
    }

    static function getVariableIDs() {
        if ( !self::$mVariableIDsInitialised ) {
            # Get variable IDs
            wfRunHooks( 'MagicWordwgVariableIDs', array( &self::$mVariableIDs ) );
            self::$mVariableIDsInitialised = true;
        }
        return self::$mVariableIDs;
    }

    static function getSubstIDs() {
        return self::$mSubstIDs;
    }

    static function getCacheTTL( $id ) {
        if ( array_key_exists( $id, self::$mCacheTTLs ) ) {
            return self::$mCacheTTLs[$id];
        } else {
            return -1;
        }
    }

    static function getDoubleUnderscoreArray() {
        if ( is_null( self::$mDoubleUnderscoreArray ) ) {
            wfRunHooks( 'GetDoubleUnderscoreIDs', array( &self::$mDoubleUnderscoreIDs ) );
            self::$mDoubleUnderscoreArray = new MagicWordArray( self::$mDoubleUnderscoreIDs );
        }
        return self::$mDoubleUnderscoreArray;
    }

    public static function clearCache() {
        self::$mObjects = array();
    }

    function load( $id ) {
        global $wgContLang;
        wfProfileIn( __METHOD__ );
        $this->mId = $id;
        $wgContLang->getMagic( $this );
        if ( !$this->mSynonyms ) {
            $this->mSynonyms = array( 'brionmademeputthishere' );
            wfProfileOut( __METHOD__ );
            throw new MWException( "Error: invalid magic word '$id'" );
        }
        wfProfileOut( __METHOD__ );
    }

    function initRegex() {
        // Sort the synonyms by length, descending, so that the longest synonym
        // matches in precedence to the shortest
        $synonyms = $this->mSynonyms;
        usort( $synonyms, array( $this, 'compareStringLength' ) );

        $escSyn = array();
        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->mVariableRegex = str_replace( "\\$1", "(.*?)", $this->mRegex );
        $this->mVariableStartToEndRegex = str_replace( "\\$1", "(.*?)",
            "/^(?:{$this->mBaseRegex})$/{$case}" );
    }

    function compareStringLength( $s1, $s2 ) {
        $l1 = strlen( $s1 );
        $l2 = strlen( $s2 );
        if ( $l1 < $l2 ) {
            return 1;
        } elseif ( $l1 > $l2 ) {
            return -1;
        } else {
            return 0;
        }
    }

    function getRegex() {
        if ( $this->mRegex == '' ) {
            $this->initRegex();
        }
        return $this->mRegex;
    }

    function getRegexCase() {
        if ( $this->mRegex === '' ) {
            $this->initRegex();
        }

        return $this->mCaseSensitive ? '' : 'iu';
    }

    function getRegexStart() {
        if ( $this->mRegex == '' ) {
            $this->initRegex();
        }
        return $this->mRegexStart;
    }

    function getBaseRegex() {
        if ( $this->mRegex == '' ) {
            $this->initRegex();
        }
        return $this->mBaseRegex;
    }

    function match( $text ) {
        return (bool)preg_match( $this->getRegex(), $text );
    }

    function matchStart( $text ) {
        return (bool)preg_match( $this->getRegexStart(), $text );
    }

    function matchVariableStartToEnd( $text ) {
        $matches = array();
        $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];
            }
        }
    }

    function matchAndRemove( &$text ) {
        $this->mFound = false;
        $text = preg_replace_callback( $this->getRegex(), array( &$this, 'pregRemoveAndRecord' ), $text );
        return $this->mFound;
    }

    function matchStartAndRemove( &$text ) {
        $this->mFound = false;
        $text = preg_replace_callback( $this->getRegexStart(), array( &$this, 'pregRemoveAndRecord' ), $text );
        return $this->mFound;
    }

    function pregRemoveAndRecord() {
        $this->mFound = true;
        return '';
    }

    function replace( $replacement, $subject, $limit = -1 ) {
        $res = preg_replace( $this->getRegex(), StringUtils::escapeRegexReplacement( $replacement ), $subject, $limit );
        $this->mModified = $res !== $subject;
        return $res;
    }

    function substituteCallback( $text, $callback ) {
        $res = preg_replace_callback( $this->getVariableRegex(), $callback, $text );
        $this->mModified = $res !== $text;
        return $res;
    }

    function getVariableRegex() {
        if ( $this->mVariableRegex == '' ) {
            $this->initRegex();
        }
        return $this->mVariableRegex;
    }

    function getVariableStartToEndRegex() {
        if ( $this->mVariableStartToEndRegex == '' ) {
            $this->initRegex();
        }
        return $this->mVariableStartToEndRegex;
    }

    function getSynonym( $i ) {
        return $this->mSynonyms[$i];
    }

    function getSynonyms() {
        return $this->mSynonyms;
    }

    function getWasModified() {
        return $this->mModified;
    }

    function replaceMultiple( $magicarr, $subject, &$result ) {
        $search = array();
        $replace = array();
        foreach ( $magicarr as $id => $replacement ) {
            $mw = MagicWord::get( $id );
            $search[] = $mw->getRegex();
            $replace[] = $replacement;
        }

        $result = preg_replace( $search, $replace, $subject );
        return $result !== $subject;
    }

    function addToArray( &$array, $value ) {
        global $wgContLang;
        foreach ( $this->mSynonyms as $syn ) {
            $array[$wgContLang->lc( $syn )] = $value;
        }
    }

    function isCaseSensitive() {
        return $this->mCaseSensitive;
    }

    function getId() {
        return $this->mId;
    }
}

class MagicWordArray {
    var $names = array();
    var $hash;
    var $baseRegex, $regex;
    var $matches;

    function __construct( $names = array() ) {
        $this->names = $names;
    }

    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;
    }

    function getHash() {
        if ( is_null( $this->hash ) ) {
            global $wgContLang;
            $this->hash = array( 0 => array(), 1 => array() );
            foreach ( $this->names as $name ) {
                $magic = MagicWord::get( $name );
                $case = intval( $magic->isCaseSensitive() );
                foreach ( $magic->getSynonyms() as $syn ) {
                    if ( !$case ) {
                        $syn = $wgContLang->lc( $syn );
                    }
                    $this->hash[$case][$syn] = $name;
                }
            }
        }
        return $this->hash;
    }

    function getBaseRegex() {
        if ( is_null( $this->baseRegex ) ) {
            $this->baseRegex = array( 0 => '', 1 => '' );
            foreach ( $this->names as $name ) {
                $magic = MagicWord::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' );
                    $group = "(?P<{$it}_{$name}>" . preg_quote( $syn, '/' ) . ')';
                    if ( $this->baseRegex[$case] === '' ) {
                        $this->baseRegex[$case] = $group;
                    } else {
                        $this->baseRegex[$case] .= '|' . $group;
                    }
                }
            }
        }
        return $this->baseRegex;
    }

    function getRegex() {
        if ( is_null( $this->regex ) ) {
            $base = $this->getBaseRegex();
            $this->regex = array( '', '' );
            if ( $this->baseRegex[0] !== '' ) {
                $this->regex[0] = "/{$base[0]}/iuS";
            }
            if ( $this->baseRegex[1] !== '' ) {
                $this->regex[1] = "/{$base[1]}/S";
            }
        }
        return $this->regex;
    }

    function getVariableRegex() {
        return str_replace( "\\$1", "(.*?)", $this->getRegex() );
    }

    function getRegexStart() {
        $base = $this->getBaseRegex();
        $newRegex = array( '', '' );
        if ( $base[0] !== '' ) {
            $newRegex[0] = "/^(?:{$base[0]})/iuS";
        }
        if ( $base[1] !== '' ) {
            $newRegex[1] = "/^(?:{$base[1]})/S";
        }
        return $newRegex;
    }

    function getVariableStartToEndRegex() {
        $base = $this->getBaseRegex();
        $newRegex = array( '', '' );
        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;
    }

    function parseMatch( $m ) {
        reset( $m );
        while ( list( $key, $value ) = each( $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 array( $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 = array();
                if ( preg_match( $regex, $text, $m ) ) {
                    return $this->parseMatch( $m );
                }
            }
        }
        return array( false, false );
    }

    public function matchStartToEnd( $text ) {
        $hash = $this->getHash();
        if ( isset( $hash[1][$text] ) ) {
            return $hash[1][$text];
        }
        global $wgContLang;
        $lc = $wgContLang->lc( $text );
        if ( isset( $hash[0][$lc] ) ) {
            return $hash[0][$lc];
        }
        return false;
    }

    public function matchAndRemove( &$text ) {
        $found = array();
        $regexes = $this->getRegex();
        foreach ( $regexes as $regex ) {
            if ( $regex === '' ) {
                continue;
            }
            preg_match_all( $regex, $text, $matches, PREG_SET_ORDER );
            foreach ( $matches as $m ) {
                list( $name, $param ) = $this->parseMatch( $m );
                $found[$name] = $param;
            }
            $text = preg_replace( $regex, '', $text );
        }
        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;
    }
}