ParserOptions.php

Go to the documentation of this file.

<?php
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 $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;
    }

    /* @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 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 );
    }

    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;

        // *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->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 );
        } );
    }
}