ParserOptions.php

Go to the documentation of this file.

<?php
class ParserOptions {
        
        var $mUseDynamicDates;
        
        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 getUseDynamicDates()               { return $this->mUseDynamicDates; }
        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 setUseDynamicDates( $x )           { return wfSetVar( $this->mUseDynamicDates, $x ); }
        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 $wgUseDynamicDates, $wgInterwikiMagic, $wgAllowExternalImages,
                        $wgAllowExternalImagesFrom, $wgEnableImageWhitelist, $wgAllowSpecialInclusion,
                        $wgMaxArticleSize, $wgMaxPPNodeCount, $wgMaxTemplateDepth, $wgMaxPPExpandDepth,
                        $wgCleanSignatures, $wgExternalLinkTarget, $wgExpensiveParserFunctionLimit,
                        $wgMaxGeneratedPPNodeCount, $wgDisableLangConversion, $wgDisableTitleConversion;

                wfProfileIn( __METHOD__ );

                $this->mUseDynamicDates = $wgUseDynamicDates;
                $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() {
                global $wgUseDynamicDates;
                $legacyOpts = array( 'math', 'stubthreshold', 'numberheadings', 'userlang', 'thumbsize', 'editsection', 'printable' );
                if ( $wgUseDynamicDates ) {
                        $legacyOpts[] = 'dateformat';
                }
                return $legacyOpts;
        }

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