ParserOptions.php

Go to the documentation of this file.

<?php
use Wikimedia\ScopedCallback;
 
class ParserOptions {
 
    private $mInterwikiMagic;
 
    private $mAllowExternalImages;
 
    private $mAllowExternalImagesFrom;
 
    private $mEnableImageWhitelist;
 
    private $mDateFormat = null;
 
    private $mEditSection = true;
 
    private $mAllowSpecialInclusion;
 
    private $mTidy = false;
 
    private $mInterfaceMessage = false;
 
    private $mTargetLanguage = null;
 
    private $mMaxIncludeSize;
 
    private $mMaxPPNodeCount;
 
    private $mMaxGeneratedPPNodeCount;
 
    private $mMaxPPExpandDepth;
 
    private $mMaxTemplateDepth;
 
    private $mExpensiveParserFunctionLimit;
 
    private $mRemoveComments = true;
 
    private $mCurrentRevisionCallback =
        [ 'Parser', 'statelessFetchRevision' ];
 
    private $mTemplateCallback =
        [ 'Parser', 'statelessFetchTemplate' ];
 
    private $mSpeculativeRevIdCallback;
 
    private $mEnableLimitReport = false;
 
    private $mTimestamp;
 
    private $mExternalLinkTarget;
 
    private $mCleanSignatures;
 
    private $mPreSaveTransform = true;
 
    private $mDisableContentConversion;
 
    private $mDisableTitleConversion;
 
    private $mNumberHeadings;
 
    private $mThumbSize;
 
    private $mStubThreshold;
 
    private $mUserLang;
 
    private $mUser;
 
    private $mIsPreview = false;
 
    private $mIsSectionPreview = false;
 
    private $mIsPrintable = false;
 
    private $mExtraKey = '';
 
    private $mMagicISBNLinks = true;
 
    private $mMagicPMIDLinks = true;
 
    private $mMagicRFCLinks = true;
 
    private $onAccessCallback = null;
 
    private $redirectTarget = null;
 
    private $allowUnsafeRawHtml = true;
 
    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;
    }
 
    /* @since 1.24 */
    public function getCurrentRevisionCallback() {
        return $this->mCurrentRevisionCallback;
    }
 
    public function getTemplateCallback() {
        return $this->mTemplateCallback;
    }
 
    public function getSpeculativeRevIdCallback() {
        return $this->mSpeculativeRevIdCallback;
    }
 
    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 getMagicISBNLinks() {
        return $this->mMagicISBNLinks;
    }
 
    public function getMagicPMIDLinks() {
        return $this->mMagicPMIDLinks;
    }
    public function getMagicRFCLinks() {
        return $this->mMagicRFCLinks;
    }
 
    public function getAllowUnsafeRawHtml() {
        return $this->allowUnsafeRawHtml;
    }
 
    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 );
    }
 
    /* @since 1.24 */
    public function setCurrentRevisionCallback( $x ) {
        return wfSetVar( $this->mCurrentRevisionCallback, $x );
    }
 
    public function setSpeculativeRevIdCallback( $x ) {
        return wfSetVar( $this->mSpeculativeRevIdCallback, $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 );
    }
 
    public function setAllowUnsafeRawHtml( $x ) {
        return wfSetVar( $this->allowUnsafeRawHtml, $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 newFromAnon() {
        global $wgContLang;
        return new ParserOptions( new User, $wgContLang );
    }
 
    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,
            $wgEnableMagicLinks;
 
        // *UPDATE* ParserOptions::matches() if any of this changes as needed
        $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->mMagicISBNLinks = $wgEnableMagicLinks['ISBN'];
        $this->mMagicPMIDLinks = $wgEnableMagicLinks['PMID'];
        $this->mMagicRFCLinks = $wgEnableMagicLinks['RFC'];
 
        $this->mUser = $user;
        $this->mNumberHeadings = $user->getOption( 'numberheadings' );
        $this->mThumbSize = $user->getOption( 'thumbsize' );
        $this->mStubThreshold = $user->getStubThreshold();
        $this->mUserLang = $lang;
 
    }
 
    public function matches( ParserOptions $other ) {
        $fields = array_keys( get_class_vars( __CLASS__ ) );
        $fields = array_diff( $fields, [
            'mEnableLimitReport', // only effects HTML comments
            'onAccessCallback', // only used for ParserOutput option tracking
        ] );
        foreach ( $fields as $field ) {
            if ( !is_object( $this->$field ) && $this->$field !== $other->$field ) {
                return false;
            }
        }
        // Check the object and lazy-loaded options
        return (
            $this->mUserLang->equals( $other->mUserLang ) &&
            $this->getDateFormat() === $other->getDateFormat()
        );
    }
 
    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 [
            '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;
 
        // @note: as of Feb 2015, core never sets the editsection flag, since it uses
        // <mw:editsection> tags to inject editsections on the fly. However, extensions
        // may be using it by calling ParserOption::optionUsed resp. ParserOutput::registerOption
        // directly. At least Wikibase does at this point in time.
        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.
        Hooks::run( 'PageRenderingHash', [ &$confstr, $this->getUser(), &$forOptions ] );
 
        // Make it a valid memcached key fragment
        $confstr = str_replace( ' ', '_', $confstr );
 
        return $confstr;
    }
 
    public function setupFakeRevision( $title, $content, $user ) {
        $oldCallback = $this->setCurrentRevisionCallback(
            function (
                $titleToCheck, $parser = false ) use ( $title, $content, $user, &$oldCallback
            ) {
                if ( $titleToCheck->equals( $title ) ) {
                    return new Revision( [
                        'page' => $title->getArticleID(),
                        'user_text' => $user->getName(),
                        'user' => $user->getId(),
                        'parent_id' => $title->getLatestRevID(),
                        'title' => $title,
                        'content' => $content
                    ] );
                } else {
                    return call_user_func( $oldCallback, $titleToCheck, $parser );
                }
            }
        );
 
        global $wgHooks;
        $wgHooks['TitleExists'][] =
            function ( $titleToCheck, &$exists ) use ( $title ) {
                if ( $titleToCheck->equals( $title ) ) {
                    $exists = true;
                }
            };
        end( $wgHooks['TitleExists'] );
        $key = key( $wgHooks['TitleExists'] );
        LinkCache::singleton()->clearBadLink( $title->getPrefixedDBkey() );
        return new ScopedCallback( function () use ( $title, $key ) {
            global $wgHooks;
            unset( $wgHooks['TitleExists'][$key] );
            LinkCache::singleton()->clearLink( $title );
        } );
    }
}