ParserOptions.php

Go to the documentation of this file.

<?php
class ParserOptions {

    var $mInterwikiMagic;

    var $mAllowExternalImages;

    var $mAllowExternalImagesFrom;

    var $mEnableImageWhitelist;

    var $mDateFormat = null;

    var $mEditSection = true;

    var $mAllowSpecialInclusion;

    var $mTidy = false;

    var $mInterfaceMessage = false;

    var $mTargetLanguage = null;

    var $mMaxIncludeSize;

    var $mMaxPPNodeCount;

    var $mMaxGeneratedPPNodeCount;

    var $mMaxPPExpandDepth;

    var $mMaxTemplateDepth;

    var $mExpensiveParserFunctionLimit;

    var $mRemoveComments = true;

    var $mTemplateCallback =
        array( 'Parser', 'statelessFetchTemplate' );

    var $mEnableLimitReport = false;

    var $mTimestamp;

    var $mExternalLinkTarget;

    var $mCleanSignatures;

    var $mPreSaveTransform = true;

    var $mDisableContentConversion;

    var $mDisableTitleConversion;

    var $mNumberHeadings;

    var $mMath;

    var $mThumbSize;

    private $mStubThreshold;

    var $mUserLang;

    var $mUser;

    var $mIsPreview = false;

    var $mIsSectionPreview = false;

    var $mIsPrintable = false;

    var $mExtraKey = '';

    protected $onAccessCallback = null;

    function getInterwikiMagic()                { return $this->mInterwikiMagic; }
    function getAllowExternalImages()           { return $this->mAllowExternalImages; }
    function getAllowExternalImagesFrom()       { return $this->mAllowExternalImagesFrom; }
    function getEnableImageWhitelist()          { return $this->mEnableImageWhitelist; }
    function getEditSection()                   { return $this->mEditSection; }
    function getNumberHeadings()                { $this->optionUsed( 'numberheadings' );
                                                  return $this->mNumberHeadings; }
    function getAllowSpecialInclusion()         { return $this->mAllowSpecialInclusion; }
    function getTidy()                          { return $this->mTidy; }
    function getInterfaceMessage()              { return $this->mInterfaceMessage; }
    function getTargetLanguage()                { return $this->mTargetLanguage; }
    function getMaxIncludeSize()                { return $this->mMaxIncludeSize; }
    function getMaxPPNodeCount()                { return $this->mMaxPPNodeCount; }
    function getMaxGeneratedPPNodeCount()       { return $this->mMaxGeneratedPPNodeCount; }
    function getMaxPPExpandDepth()              { return $this->mMaxPPExpandDepth; }
    function getMaxTemplateDepth()              { return $this->mMaxTemplateDepth; }
    /* @since 1.20 */
    function getExpensiveParserFunctionLimit()  { return $this->mExpensiveParserFunctionLimit; }
    function getRemoveComments()                { return $this->mRemoveComments; }
    function getTemplateCallback()              { return $this->mTemplateCallback; }
    function getEnableLimitReport()             { return $this->mEnableLimitReport; }
    function getCleanSignatures()               { return $this->mCleanSignatures; }
    function getExternalLinkTarget()            { return $this->mExternalLinkTarget; }
    function getDisableContentConversion()      { return $this->mDisableContentConversion; }
    function getDisableTitleConversion()        { return $this->mDisableTitleConversion; }
    function getMath()                          { $this->optionUsed( 'math' );
                                                  return $this->mMath; }
    function getThumbSize()                     { $this->optionUsed( 'thumbsize' );
                                                  return $this->mThumbSize; }
    function getStubThreshold()                 { $this->optionUsed( 'stubthreshold' );
                                                  return $this->mStubThreshold; }

    function getIsPreview()                     { return $this->mIsPreview; }
    function getIsSectionPreview()              { return $this->mIsSectionPreview; }
    function getIsPrintable()                   { $this->optionUsed( 'printable' );
                                                  return $this->mIsPrintable; }
    function getUser()                          { return $this->mUser; }
    function getPreSaveTransform()              { return $this->mPreSaveTransform; }

    function getSkin( $title = null ) {
        wfDeprecated( __METHOD__, '1.18' );
        return new DummyLinker;
    }

    function getDateFormat() {
        $this->optionUsed( 'dateformat' );
        if ( !isset( $this->mDateFormat ) ) {
            $this->mDateFormat = $this->mUser->getDatePreference();
        }
        return $this->mDateFormat;
    }

    function getTimestamp() {
        if ( !isset( $this->mTimestamp ) ) {
            $this->mTimestamp = wfTimestampNow();
        }
        return $this->mTimestamp;
    }

    function getUserLangObj() {
        $this->optionUsed( 'userlang' );
        return $this->mUserLang;
    }

    function getUserLang() {
        return $this->getUserLangObj()->getCode();
    }

    function setInterwikiMagic( $x )            { return wfSetVar( $this->mInterwikiMagic, $x ); }
    function setAllowExternalImages( $x )       { return wfSetVar( $this->mAllowExternalImages, $x ); }
    function setAllowExternalImagesFrom( $x )   { return wfSetVar( $this->mAllowExternalImagesFrom, $x ); }
    function setEnableImageWhitelist( $x )      { return wfSetVar( $this->mEnableImageWhitelist, $x ); }
    function setDateFormat( $x )                { return wfSetVar( $this->mDateFormat, $x ); }
    function setEditSection( $x )               { return wfSetVar( $this->mEditSection, $x ); }
    function setNumberHeadings( $x )            { return wfSetVar( $this->mNumberHeadings, $x ); }
    function setAllowSpecialInclusion( $x )     { return wfSetVar( $this->mAllowSpecialInclusion, $x ); }
    function setTidy( $x )                      { return wfSetVar( $this->mTidy, $x ); }

    function setSkin( $x )                      { wfDeprecated( __METHOD__, '1.19' ); }
    function setInterfaceMessage( $x )          { return wfSetVar( $this->mInterfaceMessage, $x ); }
    function setTargetLanguage( $x )            { return wfSetVar( $this->mTargetLanguage, $x, true ); }
    function setMaxIncludeSize( $x )            { return wfSetVar( $this->mMaxIncludeSize, $x ); }
    function setMaxPPNodeCount( $x )            { return wfSetVar( $this->mMaxPPNodeCount, $x ); }
    function setMaxGeneratedPPNodeCount( $x )   { return wfSetVar( $this->mMaxGeneratedPPNodeCount, $x ); }
    function setMaxTemplateDepth( $x )          { return wfSetVar( $this->mMaxTemplateDepth, $x ); }
    /* @since 1.20 */
    function setExpensiveParserFunctionLimit( $x ) { return wfSetVar( $this->mExpensiveParserFunctionLimit, $x ); }
    function setRemoveComments( $x )            { return wfSetVar( $this->mRemoveComments, $x ); }
    function setTemplateCallback( $x )          { return wfSetVar( $this->mTemplateCallback, $x ); }
    function enableLimitReport( $x = true )     { return wfSetVar( $this->mEnableLimitReport, $x ); }
    function setTimestamp( $x )                 { return wfSetVar( $this->mTimestamp, $x ); }
    function setCleanSignatures( $x )           { return wfSetVar( $this->mCleanSignatures, $x ); }
    function setExternalLinkTarget( $x )        { return wfSetVar( $this->mExternalLinkTarget, $x ); }
    function disableContentConversion( $x = true ) { return wfSetVar( $this->mDisableContentConversion, $x ); }
    function disableTitleConversion( $x = true ) { return wfSetVar( $this->mDisableTitleConversion, $x ); }
    function setMath( $x )                      { return wfSetVar( $this->mMath, $x ); }
    function setUserLang( $x )                  {
        if ( is_string( $x ) ) {
            $x = Language::factory( $x );
        }
        return wfSetVar( $this->mUserLang, $x );
    }
    function setThumbSize( $x )                 { return wfSetVar( $this->mThumbSize, $x ); }
    function setStubThreshold( $x )             { return wfSetVar( $this->mStubThreshold, $x ); }
    function setPreSaveTransform( $x )          { return wfSetVar( $this->mPreSaveTransform, $x ); }

    function setIsPreview( $x )                 { return wfSetVar( $this->mIsPreview, $x ); }
    function setIsSectionPreview( $x )          { return wfSetVar( $this->mIsSectionPreview, $x ); }
    function setIsPrintable( $x )               { return wfSetVar( $this->mIsPrintable, $x ); }

    function addExtraKey( $key ) {
        $this->mExtraKey .= '!' . $key;
    }

    function __construct( $user = null, $lang = null ) {
        if ( $user === null ) {
            global $wgUser;
            if ( $wgUser === null ) {
                $user = new User;
            } else {
                $user = $wgUser;
            }
        }
        if ( $lang === null ) {
            global $wgLang;
            if ( !StubObject::isRealObject( $wgLang ) ) {
                $wgLang->_unstub();
            }
            $lang = $wgLang;
        }
        $this->initialiseFromUser( $user, $lang );
    }

    public static function newFromUser( $user ) {
        return new ParserOptions( $user );
    }

    public static function newFromUserAndLang( User $user, Language $lang ) {
        return new ParserOptions( $user, $lang );
    }

    public static function newFromContext( IContextSource $context ) {
        return new ParserOptions( $context->getUser(), $context->getLanguage() );
    }

    private function initialiseFromUser( $user, $lang ) {
        global $wgInterwikiMagic, $wgAllowExternalImages,
            $wgAllowExternalImagesFrom, $wgEnableImageWhitelist, $wgAllowSpecialInclusion,
            $wgMaxArticleSize, $wgMaxPPNodeCount, $wgMaxTemplateDepth, $wgMaxPPExpandDepth,
            $wgCleanSignatures, $wgExternalLinkTarget, $wgExpensiveParserFunctionLimit,
            $wgMaxGeneratedPPNodeCount, $wgDisableLangConversion, $wgDisableTitleConversion;

        wfProfileIn( __METHOD__ );

        $this->mInterwikiMagic = $wgInterwikiMagic;
        $this->mAllowExternalImages = $wgAllowExternalImages;
        $this->mAllowExternalImagesFrom = $wgAllowExternalImagesFrom;
        $this->mEnableImageWhitelist = $wgEnableImageWhitelist;
        $this->mAllowSpecialInclusion = $wgAllowSpecialInclusion;
        $this->mMaxIncludeSize = $wgMaxArticleSize * 1024;
        $this->mMaxPPNodeCount = $wgMaxPPNodeCount;
        $this->mMaxGeneratedPPNodeCount = $wgMaxGeneratedPPNodeCount;
        $this->mMaxPPExpandDepth = $wgMaxPPExpandDepth;
        $this->mMaxTemplateDepth = $wgMaxTemplateDepth;
        $this->mExpensiveParserFunctionLimit = $wgExpensiveParserFunctionLimit;
        $this->mCleanSignatures = $wgCleanSignatures;
        $this->mExternalLinkTarget = $wgExternalLinkTarget;
        $this->mDisableContentConversion = $wgDisableLangConversion;
        $this->mDisableTitleConversion = $wgDisableLangConversion || $wgDisableTitleConversion;

        $this->mUser = $user;
        $this->mNumberHeadings = $user->getOption( 'numberheadings' );
        $this->mMath = $user->getOption( 'math' );
        $this->mThumbSize = $user->getOption( 'thumbsize' );
        $this->mStubThreshold = $user->getStubThreshold();
        $this->mUserLang = $lang;

        wfProfileOut( __METHOD__ );
    }

    function registerWatcher( $callback ) {
        $this->onAccessCallback = $callback;
    }

    protected function optionUsed( $optionName ) {
        if ( $this->onAccessCallback ) {
            call_user_func( $this->onAccessCallback, $optionName );
        }
    }

    public static function legacyOptions() {
        return array( 'math', 'stubthreshold', 'numberheadings', 'userlang', 'thumbsize', 'editsection', 'printable' );
    }

    public function optionsHash( $forOptions, $title = null ) {
        global $wgRenderHashAppend;

        $confstr = '';

        if ( in_array( 'math', $forOptions ) ) {
            $confstr .= $this->mMath;
        } else {
            $confstr .= '*';
        }

        // Space assigned for the stubthreshold but unused
        // since it disables the parser cache, its value will always
        // be 0 when this function is called by parsercache.
        if ( in_array( 'stubthreshold', $forOptions ) ) {
            $confstr .= '!' . $this->mStubThreshold;
        } else {
            $confstr .= '!*';
        }

        if ( in_array( 'dateformat', $forOptions ) ) {
            $confstr .= '!' . $this->getDateFormat();
        }

        if ( in_array( 'numberheadings', $forOptions ) ) {
            $confstr .= '!' . ( $this->mNumberHeadings ? '1' : '' );
        } else {
            $confstr .= '!*';
        }

        if ( in_array( 'userlang', $forOptions ) ) {
            $confstr .= '!' . $this->mUserLang->getCode();
        } else {
            $confstr .= '!*';
        }

        if ( in_array( 'thumbsize', $forOptions ) ) {
            $confstr .= '!' . $this->mThumbSize;
        } else {
            $confstr .= '!*';
        }

        // add in language specific options, if any
        // @todo FIXME: This is just a way of retrieving the url/user preferred variant
        if ( !is_null( $title ) ) {
            $confstr .= $title->getPageLanguage()->getExtraHashOptions();
        } else {
            global $wgContLang;
            $confstr .= $wgContLang->getExtraHashOptions();
        }

        $confstr .= $wgRenderHashAppend;

        if ( !in_array( 'editsection', $forOptions ) ) {
            $confstr .= '!*';
        } elseif ( !$this->mEditSection ) {
            $confstr .= '!edit=0';
        }

        if ( $this->mIsPrintable && in_array( 'printable', $forOptions ) ) {
            $confstr .= '!printable=1';
        }

        if ( $this->mExtraKey != '' ) {
            $confstr .= $this->mExtraKey;
        }

        // Give a chance for extensions to modify the hash, if they have
        // extra options or other effects on the parser cache.
        wfRunHooks( 'PageRenderingHash', array( &$confstr ) );

        // Make it a valid memcached key fragment
        $confstr = str_replace( ' ', '_', $confstr );

        return $confstr;
    }
}