Merge "(bug 40257) action=info no longer shows subpages where disabled"
[lhc/web/wiklou.git] / includes / parser / ParserOptions.php
index 56d6f7d..ff9f7ef 100644 (file)
 /**
  * Options for the PHP parser
  *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * http://www.gnu.org/copyleft/gpl.html
+ *
  * @file
  * @ingroup Parser
  */
 
 /**
- * Set options of the Parser
- * @todo document
+ * \brief Set options of the Parser
+ *
+ * All member variables are supposed to be private in theory, although in practise this is not the case.
+ *
  * @ingroup Parser
  */
 class ParserOptions {
-       # All variables are supposed to be private in theory, although in practise this is not the case.
-       var $mUseDynamicDates;           # Use DateFormatter to format dates
-       var $mInterwikiMagic;            # Interlanguage links are removed and returned in an array
-       var $mAllowExternalImages;       # Allow external images inline
-       var $mAllowExternalImagesFrom;   # If not, any exception?
-       var $mEnableImageWhitelist;      # If not or it doesn't match, should we check an on-wiki whitelist? 
-       var $mDateFormat = null;         # Date format index
-       var $mEditSection = true;        # Create "edit section" links
-       var $mAllowSpecialInclusion;     # Allow inclusion of special pages
-       var $mTidy = false;              # Ask for tidy cleanup
-       var $mInterfaceMessage = false;  # Which lang to call for PLURAL and GRAMMAR
-       var $mTargetLanguage = null;     # Overrides above setting with arbitrary language
-       var $mMaxIncludeSize;            # Maximum size of template expansions, in bytes
-       var $mMaxPPNodeCount;            # Maximum number of nodes touched by PPFrame::expand()
-       var $mMaxPPExpandDepth;          # Maximum recursion depth in PPFrame::expand()
-       var $mMaxTemplateDepth;          # Maximum recursion depth for templates within templates
-       var $mRemoveComments = true;     # Remove HTML comments. ONLY APPLIES TO PREPROCESS OPERATIONS
-       var $mTemplateCallback =         # Callback for template fetching
+       
+       /**
+        * Use DateFormatter to format dates
+        */
+       var $mUseDynamicDates;
+       
+       /**
+        * Interlanguage links are removed and returned in an array
+        */
+       var $mInterwikiMagic;
+       
+       /**
+        * Allow external images inline?
+        */
+       var $mAllowExternalImages;
+       
+       /**
+        * If not, any exception?
+        */
+       var $mAllowExternalImagesFrom;
+       
+       /**
+        * If not or it doesn't match, should we check an on-wiki whitelist?
+        */
+       var $mEnableImageWhitelist;
+       
+       /**
+        * Date format index
+        */
+       var $mDateFormat = null;
+       
+       /**
+        * Create "edit section" links?
+        */
+       var $mEditSection = true;
+       
+       /**
+        * Allow inclusion of special pages?
+        */
+       var $mAllowSpecialInclusion;
+       
+       /**
+        * Use tidy to cleanup output HTML?
+        */
+       var $mTidy = false;
+       
+       /**
+        * Which lang to call for PLURAL and GRAMMAR
+        */
+       var $mInterfaceMessage = false;
+       
+       /**
+        * Overrides $mInterfaceMessage with arbitrary language
+        */
+       var $mTargetLanguage = null;
+       
+       /**
+        * Maximum size of template expansions, in bytes
+        */
+       var $mMaxIncludeSize;
+       
+       /**
+        * Maximum number of nodes touched by PPFrame::expand()
+        */
+       var $mMaxPPNodeCount;
+
+       /**
+        * Maximum number of nodes generated by Preprocessor::preprocessToObj()
+        */
+       var $mMaxGeneratedPPNodeCount;
+       
+       /**
+        * Maximum recursion depth in PPFrame::expand()
+        */
+       var $mMaxPPExpandDepth;
+       
+       /**
+        * Maximum recursion depth for templates within templates
+        */
+       var $mMaxTemplateDepth;
+       
+       /**
+        * Maximum number of calls per parse to expensive parser functions
+        */
+       var $mExpensiveParserFunctionLimit;
+       
+       /**
+        * Remove HTML comments. ONLY APPLIES TO PREPROCESS OPERATIONS
+        */
+       var $mRemoveComments = true;
+       
+       /**
+        * Callback for template fetching. Used as first argument to call_user_func().
+        */
+       var $mTemplateCallback =
                array( 'Parser', 'statelessFetchTemplate' );
-       var $mEnableLimitReport = false; # Enable limit report in an HTML comment on output
-       var $mTimestamp;                 # Timestamp used for {{CURRENTDAY}} etc.
-       var $mExternalLinkTarget;        # Target attribute for external links
-       var $mCleanSignatures;           #
-       var $mPreSaveTransform = true;   # Transform wiki markup when saving the page.
+               
+       /**
+        * Enable limit report in an HTML comment on output
+        */
+       var $mEnableLimitReport = false;
+       
+       /**
+        * Timestamp used for {{CURRENTDAY}} etc.
+        */
+       var $mTimestamp;
+       
+       /**
+        * Target attribute for external links
+        */
+       var $mExternalLinkTarget;
+       
+       /**
+        * Clean up signature texts? 
+        *
+        * 1) Strip ~~~, ~~~~ and ~~~~~ out of signatures
+        * 2) Substitute all transclusions
+        */
+       var $mCleanSignatures;
+       
+       /**
+        * Transform wiki markup when saving the page?
+        */
+       var $mPreSaveTransform = true;
 
-       var $mNumberHeadings;            # Automatically number headings
-       var $mMath;                      # User math preference (as integer)
-       var $mThumbSize;                 # Thumb size preferred by the user.
-       private $mStubThreshold;         # Maximum article size of an article to be marked as "stub"
-       var $mUserLang;                  # Language code of the User language.
+       /**
+        * Automatically number headings?
+        */
+       var $mNumberHeadings;
+       
+       /**
+        * User math preference (as integer). Not used (1.19)
+        */
+       var $mMath;
+       
+       /**
+        * Thumb size preferred by the user.
+        */
+       var $mThumbSize;
+       
+       /**
+        * Maximum article size of an article to be marked as "stub"
+        */
+       private $mStubThreshold;
+       
+       /**
+        * Language object of the User language.
+        */
+       var $mUserLang;
 
        /**
-        * @var User
+        * @var User 
+        * Stored user object
+        */
+       var $mUser;
+       
+       /**
+        * Parsing the page for a "preview" operation?
+        */
+       var $mIsPreview = false;
+       
+       /**
+        * Parsing the page for a "preview" operation on a single section?
+        */
+       var $mIsSectionPreview = false;
+       
+       /**
+        * Parsing the printable version of the page?
         */
-       var $mUser;                      # Stored user object
-       var $mIsPreview = false;         # Parsing the page for a "preview" operation
-       var $mIsSectionPreview = false;  # Parsing the page for a "preview" operation on a single section
-       var $mIsPrintable = false;       # Parsing the printable version of the page
+       var $mIsPrintable = false;
 
-       var $mExtraKey = '';             # Extra key that should be present in the caching key.
+       /**
+        * Extra key that should be present in the caching key.
+        */
+       var $mExtraKey = '';
 
+       /**
+        * Function to be called when an option is accessed.
+        */
        protected $onAccessCallback = null;
 
        function getUseDynamicDates()               { return $this->mUseDynamicDates; }
@@ -61,7 +216,7 @@ class ParserOptions {
        function getAllowExternalImagesFrom()       { return $this->mAllowExternalImagesFrom; }
        function getEnableImageWhitelist()          { return $this->mEnableImageWhitelist; }
        function getEditSection()                   { return $this->mEditSection; }
-       function getNumberHeadings()                { $this->optionUsed('numberheadings');
+       function getNumberHeadings()                { $this->optionUsed( 'numberheadings' );
                                                                                                  return $this->mNumberHeadings; }
        function getAllowSpecialInclusion()         { return $this->mAllowSpecialInclusion; }
        function getTidy()                          { return $this->mTidy; }
@@ -69,39 +224,42 @@ class ParserOptions {
        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 getMath()                          { $this->optionUsed('math');
+       function getMath()                          { $this->optionUsed( 'math' );
                                                                                                  return $this->mMath; }
-       function getThumbSize()                     { $this->optionUsed('thumbsize');
+       function getThumbSize()                     { $this->optionUsed( 'thumbsize' );
                                                                                                  return $this->mThumbSize; }
-       function getStubThreshold()                 { $this->optionUsed('stubthreshold');
+       function getStubThreshold()                 { $this->optionUsed( 'stubthreshold' );
                                                                                                  return $this->mStubThreshold; }
 
        function getIsPreview()                     { return $this->mIsPreview; }
        function getIsSectionPreview()              { return $this->mIsSectionPreview; }
-       function getIsPrintable()                   { $this->optionUsed('printable');
+       function getIsPrintable()                   { $this->optionUsed( 'printable' );
                                                                                                  return $this->mIsPrintable; }
        function getUser()                          { return $this->mUser; }
        function getPreSaveTransform()              { return $this->mPreSaveTransform; }
 
-       /**      
-        * @param $title Title   
-        * @return Skin          
-        * @deprecated Use Linker::* instead     
-        */      
-       function getSkin( $title = null ) {      
-               wfDeprecated( __METHOD__ );
+       /**
+        * @param $title Title
+        * @return Skin
+        * @deprecated since 1.18 Use Linker::* instead
+        */
+       function getSkin( $title = null ) {
+               wfDeprecated( __METHOD__, '1.18' );
                return new DummyLinker;
        }
 
        function getDateFormat() {
-               $this->optionUsed('dateformat');
+               $this->optionUsed( 'dateformat' );
                if ( !isset( $this->mDateFormat ) ) {
                        $this->mDateFormat = $this->mUser->getDatePreference();
                }
@@ -119,12 +277,25 @@ class ParserOptions {
         * You shouldn't use this. Really. $parser->getFunctionLang() is all you need.
         * Using this fragments the cache and is discouraged. Yes, {{int: }} uses this,
         * producing inconsistent tables (Bug 14404).
+        *
+        * @return Language object
+        * @since 1.19
         */
-       function getUserLang() {
-               $this->optionUsed('userlang');
+       function getUserLangObj() {
+               $this->optionUsed( 'userlang' );
                return $this->mUserLang;
        }
 
+       /**
+        * Same as getUserLangObj() but returns a string instead.
+        *
+        * @return String   Language code
+        * @since 1.17
+        */
+       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 ); }
@@ -134,13 +305,18 @@ class ParserOptions {
        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 )                      { $this->mSkin = $x; }
-       function setInterfaceMessage( $x )          { return wfSetVar( $this->mInterfaceMessage, $x); }
-       function setTargetLanguage( $x )            { return wfSetVar( $this->mTargetLanguage, $x); }
+       function setTidy( $x )                      { return wfSetVar( $this->mTidy, $x ); }
+
+       /** @deprecated in 1.19; will be removed in 1.20 */
+       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 ); }
@@ -148,7 +324,12 @@ class ParserOptions {
        function setCleanSignatures( $x )           { return wfSetVar( $this->mCleanSignatures, $x ); }
        function setExternalLinkTarget( $x )        { return wfSetVar( $this->mExternalLinkTarget, $x ); }
        function setMath( $x )                      { return wfSetVar( $this->mMath, $x ); }
-       function setUserLang( $x )                  { return wfSetVar( $this->mUserLang, $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 ); }
@@ -164,41 +345,76 @@ class ParserOptions {
                $this->mExtraKey .= '!' . $key;
        }
 
-       function __construct( $user = null ) {
-               $this->initialiseFromUser( $user );
+       /**
+        * Constructor
+        * @param $user User object
+        * @param $lang Language object
+        */
+       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 );
        }
 
        /**
-        * Get parser options
+        * Get a ParserOptions object from a given user.
+        * Language will be taken from $wgLang.
         *
         * @param $user User object
         * @return ParserOptions object
         */
-       static function newFromUser( $user ) {
+       public static function newFromUser( $user ) {
                return new ParserOptions( $user );
        }
 
-       /** Get user options */
-       function initialiseFromUser( $userInput ) {
-               global $wgUseDynamicDates, $wgInterwikiMagic, $wgAllowExternalImages;
-               global $wgAllowExternalImagesFrom, $wgEnableImageWhitelist, $wgAllowSpecialInclusion, $wgMaxArticleSize;
-               global $wgMaxPPNodeCount, $wgMaxTemplateDepth, $wgMaxPPExpandDepth, $wgCleanSignatures;
-               global $wgExternalLinkTarget, $wgLang;
+       /**
+        * Get a ParserOptions object from a given user and language
+        *
+        * @param $user User object
+        * @param $lang Language object
+        * @return ParserOptions object
+        */
+       public static function newFromUserAndLang( User $user, Language $lang ) {
+               return new ParserOptions( $user, $lang );
+       }
 
-               wfProfileIn( __METHOD__ );
+       /**
+        * Get a ParserOptions object from a IContextSource object
+        *
+        * @param $context IContextSource object
+        * @return ParserOptions object
+        */
+       public static function newFromContext( IContextSource $context ) {
+               return new ParserOptions( $context->getUser(), $context->getLanguage() );
+       }
 
-               if ( !$userInput ) {
-                       global $wgUser;
-                       if ( isset( $wgUser ) ) {
-                               $user = $wgUser;
-                       } else {
-                               $user = new User;
-                       }
-               } else {
-                       $user =& $userInput;
-               }
+       /** 
+        * Get user options 
+        *
+        * @param $user User object
+        * @param $lang Language object
+        */
+       private function initialiseFromUser( $user, $lang ) {
+               global $wgUseDynamicDates, $wgInterwikiMagic, $wgAllowExternalImages,
+                       $wgAllowExternalImagesFrom, $wgEnableImageWhitelist, $wgAllowSpecialInclusion,
+                       $wgMaxArticleSize, $wgMaxPPNodeCount, $wgMaxTemplateDepth, $wgMaxPPExpandDepth,
+                       $wgCleanSignatures, $wgExternalLinkTarget, $wgExpensiveParserFunctionLimit,
+                       $wgMaxGeneratedPPNodeCount;
 
-               $this->mUser = $user;
+               wfProfileIn( __METHOD__ );
 
                $this->mUseDynamicDates = $wgUseDynamicDates;
                $this->mInterwikiMagic = $wgInterwikiMagic;
@@ -208,16 +424,19 @@ class ParserOptions {
                $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->mUser = $user;
                $this->mNumberHeadings = $user->getOption( 'numberheadings' );
                $this->mMath = $user->getOption( 'math' );
                $this->mThumbSize = $user->getOption( 'thumbsize' );
                $this->mStubThreshold = $user->getStubThreshold();
-               $this->mUserLang = $wgLang->getCode();
+               $this->mUserLang = $lang;
 
                wfProfileOut( __METHOD__ );
        }
@@ -243,6 +462,7 @@ class ParserOptions {
         * Returns the full array of options that would have been used by
         * in 1.16.
         * Used to get the old parser cache entries when available.
+        * @return array
         */
        public static function legacyOptions() {
                global $wgUseDynamicDates;
@@ -267,48 +487,61 @@ class ParserOptions {
         * settings.
         *
         * @since 1.17
-        * @return \string Page rendering hash
+        * @param $forOptions Array
+        * @param $title Title: used to get the content language of the page (since r97636)
+        * @return string Page rendering hash
         */
-       public function optionsHash( $forOptions ) {
-               global $wgContLang, $wgRenderHashAppend;
+       public function optionsHash( $forOptions, $title = null ) {
+               global $wgRenderHashAppend;
 
                $confstr = '';
 
-               if ( in_array( 'math', $forOptions ) )
+               if ( in_array( 'math', $forOptions ) ) {
                        $confstr .= $this->mMath;
-               else
+               } 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 ) )
+               if ( in_array( 'stubthreshold', $forOptions ) ) {
                        $confstr .= '!' . $this->mStubThreshold;
-               else
+               } else {
                        $confstr .= '!*' ;
+               }
 
-               if ( in_array( 'dateformat', $forOptions ) )
+               if ( in_array( 'dateformat', $forOptions ) ) {
                        $confstr .= '!' . $this->getDateFormat();
+               }
 
-               if ( in_array( 'numberheadings', $forOptions ) )
+               if ( in_array( 'numberheadings', $forOptions ) ) {
                        $confstr .= '!' . ( $this->mNumberHeadings ? '1' : '' );
-               else
+               } else {
                        $confstr .= '!*';
+               }
 
-               if ( in_array( 'userlang', $forOptions ) )
-                       $confstr .= '!' . $this->mUserLang;
-               else
+               if ( in_array( 'userlang', $forOptions ) ) {
+                       $confstr .= '!' . $this->mUserLang->getCode();
+               } else {
                        $confstr .= '!*';
+               }
 
-               if ( in_array( 'thumbsize', $forOptions ) )
+               if ( in_array( 'thumbsize', $forOptions ) ) {
                        $confstr .= '!' . $this->mThumbSize;
-               else
+               } else {
                        $confstr .= '!*';
+               }
 
                // add in language specific options, if any
-               // FIXME: This is just a way of retrieving the url/user preferred variant
-               $confstr .= $wgContLang->getExtraHashOptions();
+               // @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;
 
@@ -317,9 +550,10 @@ class ParserOptions {
                } elseif ( !$this->mEditSection ) {
                        $confstr .= '!edit=0';
                }
-               
-               if (  $this->mIsPrintable && in_array( 'printable', $forOptions ) )
+
+               if ( $this->mIsPrintable && in_array( 'printable', $forOptions ) ) {
                        $confstr .= '!printable=1';
+               }
 
                if ( $this->mExtraKey != '' )
                        $confstr .= $this->mExtraKey;