ParserOptions.php

Go to the documentation of this file.

<?php
class ParserOptions {

    public $mInterwikiMagic;

    public $mAllowExternalImages;

    public $mAllowExternalImagesFrom;

    public $mEnableImageWhitelist;

    public $mDateFormat = null;

    public $mEditSection = true;

    public $mAllowSpecialInclusion;

    public $mTidy = false;

    public $mInterfaceMessage = false;

    public $mTargetLanguage = null;

    public $mMaxIncludeSize;

    public $mMaxPPNodeCount;

    public $mMaxGeneratedPPNodeCount;

    public $mMaxPPExpandDepth;

    public $mMaxTemplateDepth;

    public $mExpensiveParserFunctionLimit;

    public $mRemoveComments = true;

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

    public $mEnableLimitReport = false;

    public $mTimestamp;

    public $mExternalLinkTarget;

    public $mCleanSignatures;

    public $mPreSaveTransform = true;

    public $mDisableContentConversion;

    public $mDisableTitleConversion;

    public $mNumberHeadings;

    public $mThumbSize;

    private $mStubThreshold;

    public $mUserLang;

    public $mUser;

    public $mIsPreview = false;

    public $mIsSectionPreview = false;

    public $mIsPrintable = false;

    public $mExtraKey = '';

    protected $onAccessCallback = null;

    private $redirectTarget = null;

    public function getInterwikiMagic() {
        return $this->mInterwikiMagic;
    }

    public function getAllowExternalImages() {
        return $this->mAllowExternalImages;
    }

    public function getAllowExternalImagesFrom() {
        return $this->mAllowExternalImagesFrom;
    }

    public function getEnableImageWhitelist() {
        return $this->mEnableImageWhitelist;
    }

    public function getEditSection() {
        return $this->mEditSection;
    }

    public function getNumberHeadings() {
        $this->optionUsed( 'numberheadings' );

        return $this->mNumberHeadings;
    }

    public function getAllowSpecialInclusion() {
        return $this->mAllowSpecialInclusion;
    }

    public function getTidy() {
        return $this->mTidy;
    }

    public function getInterfaceMessage() {
        return $this->mInterfaceMessage;
    }

    public function getTargetLanguage() {
        return $this->mTargetLanguage;
    }

    public function getMaxIncludeSize() {
        return $this->mMaxIncludeSize;
    }

    public function getMaxPPNodeCount() {
        return $this->mMaxPPNodeCount;
    }

    public function getMaxGeneratedPPNodeCount() {
        return $this->mMaxGeneratedPPNodeCount;
    }

    public function getMaxPPExpandDepth() {
        return $this->mMaxPPExpandDepth;
    }

    public function getMaxTemplateDepth() {
        return $this->mMaxTemplateDepth;
    }

    /* @since 1.20 */
    public function getExpensiveParserFunctionLimit() {
        return $this->mExpensiveParserFunctionLimit;
    }

    public function getRemoveComments() {
        return $this->mRemoveComments;
    }

    public function getTemplateCallback() {
        return $this->mTemplateCallback;
    }

    public function getEnableLimitReport() {
        return $this->mEnableLimitReport;
    }

    public function getCleanSignatures() {
        return $this->mCleanSignatures;
    }

    public function getExternalLinkTarget() {
        return $this->mExternalLinkTarget;
    }

    public function getDisableContentConversion() {
        return $this->mDisableContentConversion;
    }

    public function getDisableTitleConversion() {
        return $this->mDisableTitleConversion;
    }

    public function getThumbSize() {
        $this->optionUsed( 'thumbsize' );

        return $this->mThumbSize;
    }

    public function getStubThreshold() {
        $this->optionUsed( 'stubthreshold' );

        return $this->mStubThreshold;
    }

    public function getIsPreview() {
        return $this->mIsPreview;
    }

    public function getIsSectionPreview() {
        return $this->mIsSectionPreview;
    }

    public function getIsPrintable() {
        $this->optionUsed( 'printable' );

        return $this->mIsPrintable;
    }

    public function getUser() {
        return $this->mUser;
    }

    public function getPreSaveTransform() {
        return $this->mPreSaveTransform;
    }

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

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

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

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

    public function setInterwikiMagic( $x ) {
        return wfSetVar( $this->mInterwikiMagic, $x );
    }

    public function setAllowExternalImages( $x ) {
        return wfSetVar( $this->mAllowExternalImages, $x );
    }

    public function setAllowExternalImagesFrom( $x ) {
        return wfSetVar( $this->mAllowExternalImagesFrom, $x );
    }

    public function setEnableImageWhitelist( $x ) {
        return wfSetVar( $this->mEnableImageWhitelist, $x );
    }

    public function setDateFormat( $x ) {
        return wfSetVar( $this->mDateFormat, $x );
    }

    public function setEditSection( $x ) {
        return wfSetVar( $this->mEditSection, $x );
    }

    public function setNumberHeadings( $x ) {
        return wfSetVar( $this->mNumberHeadings, $x );
    }

    public function setAllowSpecialInclusion( $x ) {
        return wfSetVar( $this->mAllowSpecialInclusion, $x );
    }

    public function setTidy( $x ) {
        return wfSetVar( $this->mTidy, $x );
    }

    public function setInterfaceMessage( $x ) {
        return wfSetVar( $this->mInterfaceMessage, $x );
    }

    public function setTargetLanguage( $x ) {
        return wfSetVar( $this->mTargetLanguage, $x, true );
    }

    public function setMaxIncludeSize( $x ) {
        return wfSetVar( $this->mMaxIncludeSize, $x );
    }

    public function setMaxPPNodeCount( $x ) {
        return wfSetVar( $this->mMaxPPNodeCount, $x );
    }

    public function setMaxGeneratedPPNodeCount( $x ) {
        return wfSetVar( $this->mMaxGeneratedPPNodeCount, $x );
    }

    public function setMaxTemplateDepth( $x ) {
        return wfSetVar( $this->mMaxTemplateDepth, $x );
    }

    /* @since 1.20 */
    public function setExpensiveParserFunctionLimit( $x ) {
        return wfSetVar( $this->mExpensiveParserFunctionLimit, $x );
    }

    public function setRemoveComments( $x ) {
        return wfSetVar( $this->mRemoveComments, $x );
    }

    public function setTemplateCallback( $x ) {
        return wfSetVar( $this->mTemplateCallback, $x );
    }

    public function enableLimitReport( $x = true ) {
        return wfSetVar( $this->mEnableLimitReport, $x );
    }

    public function setTimestamp( $x ) {
        return wfSetVar( $this->mTimestamp, $x );
    }

    public function setCleanSignatures( $x ) {
        return wfSetVar( $this->mCleanSignatures, $x );
    }

    public function setExternalLinkTarget( $x ) {
        return wfSetVar( $this->mExternalLinkTarget, $x );
    }

    public function disableContentConversion( $x = true ) {
        return wfSetVar( $this->mDisableContentConversion, $x );
    }

    public function disableTitleConversion( $x = true ) {
        return wfSetVar( $this->mDisableTitleConversion, $x );
    }

    public function setUserLang( $x ) {
        if ( is_string( $x ) ) {
            $x = Language::factory( $x );
        }

        return wfSetVar( $this->mUserLang, $x );
    }

    public function setThumbSize( $x ) {
        return wfSetVar( $this->mThumbSize, $x );
    }

    public function setStubThreshold( $x ) {
        return wfSetVar( $this->mStubThreshold, $x );
    }

    public function setPreSaveTransform( $x ) {
        return wfSetVar( $this->mPreSaveTransform, $x );
    }

    public function setIsPreview( $x ) {
        return wfSetVar( $this->mIsPreview, $x );
    }

    public function setIsSectionPreview( $x ) {
        return wfSetVar( $this->mIsSectionPreview, $x );
    }

    public function setIsPrintable( $x ) {
        return wfSetVar( $this->mIsPrintable, $x );
    }

    function setRedirectTarget( $title ) {
        $this->redirectTarget = $title;
    }

    function getRedirectTarget() {
        return $this->redirectTarget;
    }

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

    public 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->mThumbSize = $user->getOption( 'thumbsize' );
        $this->mStubThreshold = $user->getStubThreshold();
        $this->mUserLang = $lang;

        wfProfileOut( __METHOD__ );
    }

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

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

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

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

        // FIXME: Once the cache key is reorganized this argument
        // can be dropped. It was used when the math extension was
        // part of core.
        $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, $this->getUser(), &$forOptions ) );

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

        return $confstr;
    }
}