includes/content/WikitextContent.php

   1 <?php
   2 /**
   3  * Content object for wiki text pages.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @since 1.21
  21  *
  22  * @file
  23  * @ingroup Content
  24  *
  25  * @author Daniel Kinzler
  26  */
  27
  28 use MediaWiki\Logger\LoggerFactory;
  29 use MediaWiki\MediaWikiServices;
  30
  31 /**
  32  * Content object for wiki text pages.
  33  *
  34  * @ingroup Content
  35  */
  36 class WikitextContent extends TextContent {
  37         private $redirectTargetAndText = null;
  38
  39         /**
  40          * @var bool Tracks if the parser set the user-signature flag when creating this content, which
  41          *   would make it expire faster in ApiStashEdit.
  42          */
  43         private $hadSignature = false;
  44
  45         /**
  46          * @var array|null Stack trace of the previous parse
  47          */
  48         private $previousParseStackTrace = null;
  49
  50         public function __construct( $text ) {
  51                 parent::__construct( $text, CONTENT_MODEL_WIKITEXT );
  52         }
  53
  54         /**
  55          * @param string|int $sectionId
  56          *
  57          * @return Content|bool|null
  58          *
  59          * @see Content::getSection()
  60          */
  61         public function getSection( $sectionId ) {
  62                 $text = $this->getText();
  63                 $sect = MediaWikiServices::getInstance()->getParser()
  64                         ->getSection( $text, $sectionId, false );
  65
  66                 if ( $sect === false ) {
  67                         return false;
  68                 } else {
  69                         return new static( $sect );
  70                 }
  71         }
  72
  73         /**
  74          * @param string|int|null|bool $sectionId
  75          * @param Content $with
  76          * @param string $sectionTitle
  77          *
  78          * @throws MWException
  79          * @return Content
  80          *
  81          * @see Content::replaceSection()
  82          */
  83         public function replaceSection( $sectionId, Content $with, $sectionTitle = '' ) {
  84                 $myModelId = $this->getModel();
  85                 $sectionModelId = $with->getModel();
  86
  87                 if ( $sectionModelId != $myModelId ) {
  88                         throw new MWException( "Incompatible content model for section: " .
  89                                 "document uses $myModelId but " .
  90                                 "section uses $sectionModelId." );
  91                 }
  92                 /** @var self $with $oldtext */
  93                 '@phan-var self $with';
  94
  95                 $oldtext = $this->getText();
  96                 $text = $with->getText();
  97
  98                 if ( strval( $sectionId ) === '' ) {
  99                         return $with; # XXX: copy first?
 100                 }
 101
 102                 if ( $sectionId === 'new' ) {
 103                         # Inserting a new section
 104                         $subject = $sectionTitle ? wfMessage( 'newsectionheaderdefaultlevel' )
 105                                         ->plaintextParams( $sectionTitle )->inContentLanguage()->text() . "\n\n" : '';
 106                         if ( Hooks::run( 'PlaceNewSection', [ $this, $oldtext, $subject, &$text ] ) ) {
 107                                 $text = strlen( trim( $oldtext ) ) > 0
 108                                         ? "{$oldtext}\n\n{$subject}{$text}"
 109                                         : "{$subject}{$text}";
 110                         }
 111                 } else {
 112                         # Replacing an existing section; roll out the big guns
 113                         $text = MediaWikiServices::getInstance()->getParser()
 114                                 ->replaceSection( $oldtext, $sectionId, $text );
 115                 }
 116
 117                 $newContent = new static( $text );
 118
 119                 return $newContent;
 120         }
 121
 122         /**
 123          * Returns a new WikitextContent object with the given section heading
 124          * prepended.
 125          *
 126          * @param string $header
 127          *
 128          * @return Content
 129          */
 130         public function addSectionHeader( $header ) {
 131                 $text = wfMessage( 'newsectionheaderdefaultlevel' )
 132                         ->rawParams( $header )->inContentLanguage()->text();
 133                 $text .= "\n\n";
 134                 $text .= $this->getText();
 135
 136                 return new static( $text );
 137         }
 138
 139         /**
 140          * Returns a Content object with pre-save transformations applied using
 141          * Parser::preSaveTransform().
 142          *
 143          * @param Title $title
 144          * @param User $user
 145          * @param ParserOptions $popts
 146          *
 147          * @return Content
 148          */
 149         public function preSaveTransform( Title $title, User $user, ParserOptions $popts ) {
 150                 $text = $this->getText();
 151
 152                 $parser = MediaWikiServices::getInstance()->getParser();
 153                 $pst = $parser->preSaveTransform( $text, $title, $user, $popts );
 154
 155                 if ( $text === $pst ) {
 156                         return $this;
 157                 }
 158
 159                 $ret = new static( $pst );
 160
 161                 if ( $parser->getOutput()->getFlag( 'user-signature' ) ) {
 162                         $ret->hadSignature = true;
 163                 }
 164
 165                 return $ret;
 166         }
 167
 168         /**
 169          * Returns a Content object with preload transformations applied (or this
 170          * object if no transformations apply).
 171          *
 172          * @param Title $title
 173          * @param ParserOptions $popts
 174          * @param array $params
 175          *
 176          * @return Content
 177          */
 178         public function preloadTransform( Title $title, ParserOptions $popts, $params = [] ) {
 179                 $text = $this->getText();
 180                 $plt = MediaWikiServices::getInstance()->getParser()
 181                         ->getPreloadText( $text, $title, $popts, $params );
 182
 183                 return new static( $plt );
 184         }
 185
 186         /**
 187          * Extract the redirect target and the remaining text on the page.
 188          *
 189          * @note migrated here from Title::newFromRedirectInternal()
 190          *
 191          * @since 1.23
 192          *
 193          * @return array List of two elements: Title|null and string.
 194          */
 195         protected function getRedirectTargetAndText() {
 196                 global $wgMaxRedirects;
 197
 198                 if ( $this->redirectTargetAndText !== null ) {
 199                         return $this->redirectTargetAndText;
 200                 }
 201
 202                 if ( $wgMaxRedirects < 1 ) {
 203                         // redirects are disabled, so quit early
 204                         $this->redirectTargetAndText = [ null, $this->getText() ];
 205                         return $this->redirectTargetAndText;
 206                 }
 207
 208                 $redir = MediaWikiServices::getInstance()->getMagicWordFactory()->get( 'redirect' );
 209                 $text = ltrim( $this->getText() );
 210                 if ( $redir->matchStartAndRemove( $text ) ) {
 211                         // Extract the first link and see if it's usable
 212                         // Ensure that it really does come directly after #REDIRECT
 213                         // Some older redirects included a colon, so don't freak about that!
 214                         $m = [];
 215                         if ( preg_match( '!^\s*:?\s*\[{2}(.*?)(?:\|.*?)?\]{2}\s*!', $text, $m ) ) {
 216                                 // Strip preceding colon used to "escape" categories, etc.
 217                                 // and URL-decode links
 218                                 if ( strpos( $m[1], '%' ) !== false ) {
 219                                         // Match behavior of inline link parsing here;
 220                                         $m[1] = rawurldecode( ltrim( $m[1], ':' ) );
 221                                 }
 222                                 $title = Title::newFromText( $m[1] );
 223                                 // If the title is a redirect to bad special pages or is invalid, return null
 224                                 if ( !$title instanceof Title || !$title->isValidRedirectTarget() ) {
 225                                         $this->redirectTargetAndText = [ null, $this->getText() ];
 226                                         return $this->redirectTargetAndText;
 227                                 }
 228
 229                                 $this->redirectTargetAndText = [ $title, substr( $text, strlen( $m[0] ) ) ];
 230                                 return $this->redirectTargetAndText;
 231                         }
 232                 }
 233
 234                 $this->redirectTargetAndText = [ null, $this->getText() ];
 235                 return $this->redirectTargetAndText;
 236         }
 237
 238         /**
 239          * Implement redirect extraction for wikitext.
 240          *
 241          * @return Title|null
 242          *
 243          * @see Content::getRedirectTarget
 244          */
 245         public function getRedirectTarget() {
 246                 list( $title, ) = $this->getRedirectTargetAndText();
 247
 248                 return $title;
 249         }
 250
 251         /**
 252          * This implementation replaces the first link on the page with the given new target
 253          * if this Content object is a redirect. Otherwise, this method returns $this.
 254          *
 255          * @since 1.21
 256          *
 257          * @param Title $target
 258          *
 259          * @return Content
 260          *
 261          * @see Content::updateRedirect()
 262          */
 263         public function updateRedirect( Title $target ) {
 264                 if ( !$this->isRedirect() ) {
 265                         return $this;
 266                 }
 267
 268                 # Fix the text
 269                 # Remember that redirect pages can have categories, templates, etc.,
 270                 # so the regex has to be fairly general
 271                 $newText = preg_replace( '/ \[ \[  [^\]]*  \] \] /x',
 272                         '[[' . $target->getFullText() . ']]',
 273                         $this->getText(), 1 );
 274
 275                 return new static( $newText );
 276         }
 277
 278         /**
 279          * Returns true if this content is not a redirect, and this content's text
 280          * is countable according to the criteria defined by $wgArticleCountMethod.
 281          *
 282          * @param bool|null $hasLinks If it is known whether this content contains
 283          *    links, provide this information here, to avoid redundant parsing to
 284          *    find out (default: null).
 285          * @param Title|null $title Optional title, defaults to the title from the current main request.
 286          *
 287          * @return bool
 288          */
 289         public function isCountable( $hasLinks = null, Title $title = null ) {
 290                 global $wgArticleCountMethod;
 291
 292                 if ( $this->isRedirect() ) {
 293                         return false;
 294                 }
 295
 296                 if ( $wgArticleCountMethod === 'link' ) {
 297                         if ( $hasLinks === null ) { # not known, find out
 298                                 if ( !$title ) {
 299                                         $context = RequestContext::getMain();
 300                                         $title = $context->getTitle();
 301                                 }
 302
 303                                 $po = $this->getParserOutput( $title, null, null, false );
 304                                 $links = $po->getLinks();
 305                                 $hasLinks = !empty( $links );
 306                         }
 307
 308                         return $hasLinks;
 309                 }
 310
 311                 return true;
 312         }
 313
 314         /**
 315          * @param int $maxlength
 316          * @return string
 317          */
 318         public function getTextForSummary( $maxlength = 250 ) {
 319                 $truncatedtext = parent::getTextForSummary( $maxlength );
 320
 321                 # clean up unfinished links
 322                 # XXX: make this optional? wasn't there in autosummary, but required for
 323                 # deletion summary.
 324                 $truncatedtext = preg_replace( '/\[\[([^\]]*)\]?$/', '$1', $truncatedtext );
 325
 326                 return $truncatedtext;
 327         }
 328
 329         /**
 330          * Returns a ParserOutput object resulting from parsing the content's text
 331          * using the global Parser service.
 332          *
 333          * @param Title $title
 334          * @param int|null $revId ID of the revision being rendered.
 335          *  See Parser::parse() for the ramifications. (default: null)
 336          * @param ParserOptions $options (default: null)
 337          * @param bool $generateHtml (default: true)
 338          * @param ParserOutput &$output ParserOutput representing the HTML form of the text,
 339          *           may be manipulated or replaced.
 340          */
 341         protected function fillParserOutput( Title $title, $revId,
 342                         ParserOptions $options, $generateHtml, ParserOutput &$output
 343         ) {
 344                 $stackTrace = ( new RuntimeException() )->getTraceAsString();
 345                 if ( $this->previousParseStackTrace ) {
 346                         // NOTE: there may be legitimate changes to re-parse the same WikiText content,
 347                         // e.g. if predicted revision ID for the REVISIONID magic word mismatched.
 348                         // But that should be rare.
 349                         $logger = LoggerFactory::getInstance( 'DuplicateParse' );
 350                         $logger->debug(
 351                                 __METHOD__ . ': Possibly redundant parse!',
 352                                 [
 353                                         'title' => $title->getPrefixedDBkey(),
 354                                         'rev' => $revId,
 355                                         'options-hash' => $options->optionsHash(
 356                                                 ParserOptions::allCacheVaryingOptions(),
 357                                                 $title
 358                                         ),
 359                                         'trace' => $stackTrace,
 360                                         'previous-trace' => $this->previousParseStackTrace,
 361                                 ]
 362                         );
 363                 }
 364                 $this->previousParseStackTrace = $stackTrace;
 365
 366                 list( $redir, $text ) = $this->getRedirectTargetAndText();
 367                 $output = MediaWikiServices::getInstance()->getParser()
 368                         ->parse( $text, $title, $options, true, true, $revId );
 369
 370                 // Add redirect indicator at the top
 371                 if ( $redir ) {
 372                         // Make sure to include the redirect link in pagelinks
 373                         $output->addLink( $redir );
 374                         if ( $generateHtml ) {
 375                                 $chain = $this->getRedirectChain();
 376                                 $output->setText(
 377                                         Article::getRedirectHeaderHtml( $title->getPageLanguage(), $chain, false ) .
 378                                         $output->getRawText()
 379                                 );
 380                                 $output->addModuleStyles( 'mediawiki.action.view.redirectPage' );
 381                         }
 382                 }
 383
 384                 // Pass along user-signature flag
 385                 if ( $this->hadSignature ) {
 386                         $output->setFlag( 'user-signature' );
 387                 }
 388         }
 389
 390         /**
 391          * @throws MWException
 392          */
 393         protected function getHtml() {
 394                 throw new MWException(
 395                         "getHtml() not implemented for wikitext. "
 396                                 . "Use getParserOutput()->getText()."
 397                 );
 398         }
 399
 400         /**
 401          * This implementation calls $word->match() on the this TextContent object's text.
 402          *
 403          * @param MagicWord $word
 404          *
 405          * @return bool
 406          *
 407          * @see Content::matchMagicWord()
 408          */
 409         public function matchMagicWord( MagicWord $word ) {
 410                 return $word->match( $this->getText() );
 411         }
 412
 413 }