includes/api/ApiParse.php

   1 <?php
   2 /**
   3  * Copyright © 2007 Yuri Astrakhan "<Firstname><Lastname>@gmail.com"
   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  * @file
  21  */
  22
  23 use MediaWiki\MediaWikiServices;
  24
  25 /**
  26  * @ingroup API
  27  */
  28 class ApiParse extends ApiBase {
  29
  30         /** @var string $section */
  31         private $section = null;
  32
  33         /** @var Content $content */
  34         private $content = null;
  35
  36         /** @var Content $pstContent */
  37         private $pstContent = null;
  38
  39         /** @var bool */
  40         private $contentIsDeleted = false, $contentIsSuppressed = false;
  41
  42         public function execute() {
  43                 // The data is hot but user-dependent, like page views, so we set vary cookies
  44                 $this->getMain()->setCacheMode( 'anon-public-user-private' );
  45
  46                 // Get parameters
  47                 $params = $this->extractRequestParams();
  48
  49                 // No easy way to say that text and title or revid are allowed together
  50                 // while the rest aren't, so just do it in three calls.
  51                 $this->requireMaxOneParameter( $params, 'page', 'pageid', 'oldid', 'text' );
  52                 $this->requireMaxOneParameter( $params, 'page', 'pageid', 'oldid', 'title' );
  53                 $this->requireMaxOneParameter( $params, 'page', 'pageid', 'oldid', 'revid' );
  54
  55                 $text = $params['text'];
  56                 $title = $params['title'];
  57                 if ( $title === null ) {
  58                         $titleProvided = false;
  59                         // A title is needed for parsing, so arbitrarily choose one
  60                         $title = 'API';
  61                 } else {
  62                         $titleProvided = true;
  63                 }
  64
  65                 $page = $params['page'];
  66                 $pageid = $params['pageid'];
  67                 $oldid = $params['oldid'];
  68
  69                 $model = $params['contentmodel'];
  70                 $format = $params['contentformat'];
  71
  72                 $prop = array_flip( $params['prop'] );
  73
  74                 if ( isset( $params['section'] ) ) {
  75                         $this->section = $params['section'];
  76                         if ( !preg_match( '/^((T-)?\d+|new)$/', $this->section ) ) {
  77                                 $this->dieWithError( 'apierror-invalidsection' );
  78                         }
  79                 } else {
  80                         $this->section = false;
  81                 }
  82
  83                 // The parser needs $wgTitle to be set, apparently the
  84                 // $title parameter in Parser::parse isn't enough *sigh*
  85                 // TODO: Does this still need $wgTitle?
  86                 global $wgParser, $wgTitle;
  87
  88                 $redirValues = null;
  89
  90                 $needContent = isset( $prop['wikitext'] ) ||
  91                         isset( $prop['parsetree'] ) || $params['generatexml'];
  92
  93                 // Return result
  94                 $result = $this->getResult();
  95
  96                 if ( !is_null( $oldid ) || !is_null( $pageid ) || !is_null( $page ) ) {
  97                         if ( $this->section === 'new' ) {
  98                                 $this->dieWithError( 'apierror-invalidparammix-parse-new-section', 'invalidparammix' );
  99                         }
 100                         if ( !is_null( $oldid ) ) {
 101                                 // Don't use the parser cache
 102                                 $rev = Revision::newFromId( $oldid );
 103                                 if ( !$rev ) {
 104                                         $this->dieWithError( [ 'apierror-nosuchrevid', $oldid ] );
 105                                 }
 106
 107                                 $this->checkTitleUserPermissions( $rev->getTitle(), 'read' );
 108                                 if ( !$rev->userCan( Revision::DELETED_TEXT, $this->getUser() ) ) {
 109                                         $this->dieWithError(
 110                                                 [ 'apierror-permissiondenied', $this->msg( 'action-deletedtext' ) ]
 111                                         );
 112                                 }
 113
 114                                 $titleObj = $rev->getTitle();
 115                                 $wgTitle = $titleObj;
 116                                 $pageObj = WikiPage::factory( $titleObj );
 117                                 list( $popts, $reset, $suppressCache ) = $this->makeParserOptions( $pageObj, $params );
 118                                 $p_result = $this->getParsedContent(
 119                                         $pageObj, $popts, $suppressCache, $pageid, $rev, $needContent
 120                                 );
 121                         } else { // Not $oldid, but $pageid or $page
 122                                 if ( $params['redirects'] ) {
 123                                         $reqParams = [
 124                                                 'redirects' => '',
 125                                         ];
 126                                         if ( !is_null( $pageid ) ) {
 127                                                 $reqParams['pageids'] = $pageid;
 128                                         } else { // $page
 129                                                 $reqParams['titles'] = $page;
 130                                         }
 131                                         $req = new FauxRequest( $reqParams );
 132                                         $main = new ApiMain( $req );
 133                                         $pageSet = new ApiPageSet( $main );
 134                                         $pageSet->execute();
 135                                         $redirValues = $pageSet->getRedirectTitlesAsResult( $this->getResult() );
 136
 137                                         $to = $page;
 138                                         foreach ( $pageSet->getRedirectTitles() as $title ) {
 139                                                 $to = $title->getFullText();
 140                                         }
 141                                         $pageParams = [ 'title' => $to ];
 142                                 } elseif ( !is_null( $pageid ) ) {
 143                                         $pageParams = [ 'pageid' => $pageid ];
 144                                 } else { // $page
 145                                         $pageParams = [ 'title' => $page ];
 146                                 }
 147
 148                                 $pageObj = $this->getTitleOrPageId( $pageParams, 'fromdb' );
 149                                 $titleObj = $pageObj->getTitle();
 150                                 if ( !$titleObj || !$titleObj->exists() ) {
 151                                         $this->dieWithError( 'apierror-missingtitle' );
 152                                 }
 153
 154                                 $this->checkTitleUserPermissions( $titleObj, 'read' );
 155                                 $wgTitle = $titleObj;
 156
 157                                 if ( isset( $prop['revid'] ) ) {
 158                                         $oldid = $pageObj->getLatest();
 159                                 }
 160
 161                                 list( $popts, $reset, $suppressCache ) = $this->makeParserOptions( $pageObj, $params );
 162                                 $p_result = $this->getParsedContent(
 163                                         $pageObj, $popts, $suppressCache, $pageid, null, $needContent
 164                                 );
 165                         }
 166                 } else { // Not $oldid, $pageid, $page. Hence based on $text
 167                         $titleObj = Title::newFromText( $title );
 168                         if ( !$titleObj || $titleObj->isExternal() ) {
 169                                 $this->dieWithError( [ 'apierror-invalidtitle', wfEscapeWikiText( $title ) ] );
 170                         }
 171                         $revid = $params['revid'];
 172                         if ( $revid !== null ) {
 173                                 $rev = Revision::newFromId( $revid );
 174                                 if ( !$rev ) {
 175                                         $this->dieWithError( [ 'apierror-nosuchrevid', $revid ] );
 176                                 }
 177                                 $pTitleObj = $titleObj;
 178                                 $titleObj = $rev->getTitle();
 179                                 if ( $titleProvided ) {
 180                                         if ( !$titleObj->equals( $pTitleObj ) ) {
 181                                                 $this->addWarning( [ 'apierror-revwrongpage', $rev->getId(),
 182                                                         wfEscapeWikiText( $pTitleObj->getPrefixedText() ) ] );
 183                                         }
 184                                 } else {
 185                                         // Consider the title derived from the revid as having
 186                                         // been provided.
 187                                         $titleProvided = true;
 188                                 }
 189                         }
 190                         $wgTitle = $titleObj;
 191                         if ( $titleObj->canExist() ) {
 192                                 $pageObj = WikiPage::factory( $titleObj );
 193                         } else {
 194                                 // Do like MediaWiki::initializeArticle()
 195                                 $article = Article::newFromTitle( $titleObj, $this->getContext() );
 196                                 $pageObj = $article->getPage();
 197                         }
 198
 199                         list( $popts, $reset ) = $this->makeParserOptions( $pageObj, $params );
 200                         $textProvided = !is_null( $text );
 201
 202                         if ( !$textProvided ) {
 203                                 if ( $titleProvided && ( $prop || $params['generatexml'] ) ) {
 204                                         if ( $revid !== null ) {
 205                                                 $this->addWarning( 'apiwarn-parse-revidwithouttext' );
 206                                         } else {
 207                                                 $this->addWarning( 'apiwarn-parse-titlewithouttext' );
 208                                         }
 209                                 }
 210                                 // Prevent warning from ContentHandler::makeContent()
 211                                 $text = '';
 212                         }
 213
 214                         // If we are parsing text, do not use the content model of the default
 215                         // API title, but default to wikitext to keep BC.
 216                         if ( $textProvided && !$titleProvided && is_null( $model ) ) {
 217                                 $model = CONTENT_MODEL_WIKITEXT;
 218                                 $this->addWarning( [ 'apiwarn-parse-nocontentmodel', $model ] );
 219                         }
 220
 221                         try {
 222                                 $this->content = ContentHandler::makeContent( $text, $titleObj, $model, $format );
 223                         } catch ( MWContentSerializationException $ex ) {
 224                                 $this->dieWithException( $ex, [
 225                                         'wrap' => ApiMessage::create( 'apierror-contentserializationexception', 'parseerror' )
 226                                 ] );
 227                         }
 228
 229                         if ( $this->section !== false ) {
 230                                 if ( $this->section === 'new' ) {
 231                                         // Insert the section title above the content.
 232                                         if ( !is_null( $params['sectiontitle'] ) && $params['sectiontitle'] !== '' ) {
 233                                                 $this->content = $this->content->addSectionHeader( $params['sectiontitle'] );
 234                                         }
 235                                 } else {
 236                                         $this->content = $this->getSectionContent( $this->content, $titleObj->getPrefixedText() );
 237                                 }
 238                         }
 239
 240                         if ( $params['pst'] || $params['onlypst'] ) {
 241                                 $this->pstContent = $this->content->preSaveTransform( $titleObj, $this->getUser(), $popts );
 242                         }
 243                         if ( $params['onlypst'] ) {
 244                                 // Build a result and bail out
 245                                 $result_array = [];
 246                                 $result_array['text'] = $this->pstContent->serialize( $format );
 247                                 $result_array[ApiResult::META_BC_SUBELEMENTS][] = 'text';
 248                                 if ( isset( $prop['wikitext'] ) ) {
 249                                         $result_array['wikitext'] = $this->content->serialize( $format );
 250                                         $result_array[ApiResult::META_BC_SUBELEMENTS][] = 'wikitext';
 251                                 }
 252                                 if ( !is_null( $params['summary'] ) ||
 253                                         ( !is_null( $params['sectiontitle'] ) && $this->section === 'new' )
 254                                 ) {
 255                                         $result_array['parsedsummary'] = $this->formatSummary( $titleObj, $params );
 256                                         $result_array[ApiResult::META_BC_SUBELEMENTS][] = 'parsedsummary';
 257                                 }
 258
 259                                 $result->addValue( null, $this->getModuleName(), $result_array );
 260
 261                                 return;
 262                         }
 263
 264                         // Not cached (save or load)
 265                         if ( $params['pst'] ) {
 266                                 $p_result = $this->pstContent->getParserOutput( $titleObj, $revid, $popts );
 267                         } else {
 268                                 $p_result = $this->content->getParserOutput( $titleObj, $revid, $popts );
 269                         }
 270                 }
 271
 272                 $result_array = [];
 273
 274                 $result_array['title'] = $titleObj->getPrefixedText();
 275                 $result_array['pageid'] = $pageid ?: $pageObj->getId();
 276                 if ( $this->contentIsDeleted ) {
 277                         $result_array['textdeleted'] = true;
 278                 }
 279                 if ( $this->contentIsSuppressed ) {
 280                         $result_array['textsuppressed'] = true;
 281                 }
 282
 283                 if ( isset( $params['useskin'] ) ) {
 284                         $factory = MediaWikiServices::getInstance()->getSkinFactory();
 285                         $skin = $factory->makeSkin( Skin::normalizeKey( $params['useskin'] ) );
 286                 } else {
 287                         $skin = null;
 288                 }
 289
 290                 $outputPage = null;
 291                 if ( $skin || isset( $prop['headhtml'] ) || isset( $prop['categorieshtml'] ) ) {
 292                         // Enabling the skin via 'useskin', 'headhtml', or 'categorieshtml'
 293                         // gets OutputPage and Skin involved, which (among others) applies
 294                         // these hooks:
 295                         // - ParserOutputHooks
 296                         // - Hook: LanguageLinks
 297                         // - Hook: OutputPageParserOutput
 298                         // - Hook: OutputPageMakeCategoryLinks
 299                         $context = new DerivativeContext( $this->getContext() );
 300                         $context->setTitle( $titleObj );
 301                         $context->setWikiPage( $pageObj );
 302
 303                         if ( $skin ) {
 304                                 // Use the skin specified by 'useskin'
 305                                 $context->setSkin( $skin );
 306                                 // Context clones the skin, refetch to stay in sync. (T166022)
 307                                 $skin = $context->getSkin();
 308                         } else {
 309                                 // Make sure the context's skin refers to the context. Without this,
 310                                 // $outputPage->getSkin()->getOutput() !== $outputPage which
 311                                 // confuses some of the output.
 312                                 $context->setSkin( $context->getSkin() );
 313                         }
 314
 315                         $outputPage = new OutputPage( $context );
 316                         $outputPage->addParserOutputMetadata( $p_result );
 317                         $context->setOutput( $outputPage );
 318
 319                         if ( $skin ) {
 320                                 // Based on OutputPage::headElement()
 321                                 $skin->setupSkinUserCss( $outputPage );
 322                                 // Based on OutputPage::output()
 323                                 foreach ( $skin->getDefaultModules() as $group ) {
 324                                         $outputPage->addModules( $group );
 325                                 }
 326                         }
 327                 }
 328
 329                 if ( !is_null( $oldid ) ) {
 330                         $result_array['revid'] = intval( $oldid );
 331                 }
 332
 333                 if ( $params['redirects'] && !is_null( $redirValues ) ) {
 334                         $result_array['redirects'] = $redirValues;
 335                 }
 336
 337                 if ( isset( $prop['text'] ) ) {
 338                         $result_array['text'] = $p_result->getText( [
 339                                 'allowTOC' => !$params['disabletoc'],
 340                                 'enableSectionEditLinks' => !$params['disableeditsection'],
 341                                 'unwrap' => $params['wrapoutputclass'] === '',
 342                                 'deduplicateStyles' => !$params['disablestylededuplication'],
 343                         ] );
 344                         $result_array[ApiResult::META_BC_SUBELEMENTS][] = 'text';
 345                 }
 346
 347                 if ( !is_null( $params['summary'] ) ||
 348                         ( !is_null( $params['sectiontitle'] ) && $this->section === 'new' )
 349                 ) {
 350                         $result_array['parsedsummary'] = $this->formatSummary( $titleObj, $params );
 351                         $result_array[ApiResult::META_BC_SUBELEMENTS][] = 'parsedsummary';
 352                 }
 353
 354                 if ( isset( $prop['langlinks'] ) ) {
 355                         if ( $skin ) {
 356                                 $langlinks = $outputPage->getLanguageLinks();
 357                         } else {
 358                                 $langlinks = $p_result->getLanguageLinks();
 359                                 // The deprecated 'effectivelanglinks' option depredates OutputPage
 360                                 // support via 'useskin'. If not already applied, then run just this
 361                                 // one hook of OutputPage::addParserOutputMetadata here.
 362                                 if ( $params['effectivelanglinks'] ) {
 363                                         $linkFlags = [];
 364                                         Hooks::run( 'LanguageLinks', [ $titleObj, &$langlinks, &$linkFlags ] );
 365                                 }
 366                         }
 367
 368                         $result_array['langlinks'] = $this->formatLangLinks( $langlinks );
 369                 }
 370                 if ( isset( $prop['categories'] ) ) {
 371                         $result_array['categories'] = $this->formatCategoryLinks( $p_result->getCategories() );
 372                 }
 373                 if ( isset( $prop['categorieshtml'] ) ) {
 374                         $result_array['categorieshtml'] = $outputPage->getSkin()->getCategories();
 375                         $result_array[ApiResult::META_BC_SUBELEMENTS][] = 'categorieshtml';
 376                 }
 377                 if ( isset( $prop['links'] ) ) {
 378                         $result_array['links'] = $this->formatLinks( $p_result->getLinks() );
 379                 }
 380                 if ( isset( $prop['templates'] ) ) {
 381                         $result_array['templates'] = $this->formatLinks( $p_result->getTemplates() );
 382                 }
 383                 if ( isset( $prop['images'] ) ) {
 384                         $result_array['images'] = array_keys( $p_result->getImages() );
 385                 }
 386                 if ( isset( $prop['externallinks'] ) ) {
 387                         $result_array['externallinks'] = array_keys( $p_result->getExternalLinks() );
 388                 }
 389                 if ( isset( $prop['sections'] ) ) {
 390                         $result_array['sections'] = $p_result->getSections();
 391                 }
 392                 if ( isset( $prop['parsewarnings'] ) ) {
 393                         $result_array['parsewarnings'] = $p_result->getWarnings();
 394                 }
 395
 396                 if ( isset( $prop['displaytitle'] ) ) {
 397                         $result_array['displaytitle'] = $p_result->getDisplayTitle() !== false
 398                                 ? $p_result->getDisplayTitle() : $titleObj->getPrefixedText();
 399                 }
 400
 401                 if ( isset( $prop['headitems'] ) ) {
 402                         if ( $skin ) {
 403                                 $result_array['headitems'] = $this->formatHeadItems( $outputPage->getHeadItemsArray() );
 404                         } else {
 405                                 $result_array['headitems'] = $this->formatHeadItems( $p_result->getHeadItems() );
 406                         }
 407                 }
 408
 409                 if ( isset( $prop['headhtml'] ) ) {
 410                         $result_array['headhtml'] = $outputPage->headElement( $context->getSkin() );
 411                         $result_array[ApiResult::META_BC_SUBELEMENTS][] = 'headhtml';
 412                 }
 413
 414                 if ( isset( $prop['modules'] ) ) {
 415                         if ( $skin ) {
 416                                 $result_array['modules'] = $outputPage->getModules();
 417                                 $result_array['modulescripts'] = $outputPage->getModuleScripts();
 418                                 $result_array['modulestyles'] = $outputPage->getModuleStyles();
 419                         } else {
 420                                 $result_array['modules'] = array_values( array_unique( $p_result->getModules() ) );
 421                                 $result_array['modulescripts'] = array_values( array_unique( $p_result->getModuleScripts() ) );
 422                                 $result_array['modulestyles'] = array_values( array_unique( $p_result->getModuleStyles() ) );
 423                         }
 424                 }
 425
 426                 if ( isset( $prop['jsconfigvars'] ) ) {
 427                         $jsconfigvars = $skin ? $outputPage->getJsConfigVars() : $p_result->getJsConfigVars();
 428                         $result_array['jsconfigvars'] = ApiResult::addMetadataToResultVars( $jsconfigvars );
 429                 }
 430
 431                 if ( isset( $prop['encodedjsconfigvars'] ) ) {
 432                         $jsconfigvars = $skin ? $outputPage->getJsConfigVars() : $p_result->getJsConfigVars();
 433                         $result_array['encodedjsconfigvars'] = FormatJson::encode(
 434                                 $jsconfigvars,
 435                                 false,
 436                                 FormatJson::ALL_OK
 437                         );
 438                         $result_array[ApiResult::META_SUBELEMENTS][] = 'encodedjsconfigvars';
 439                 }
 440
 441                 if ( isset( $prop['modules'] ) &&
 442                         !isset( $prop['jsconfigvars'] ) && !isset( $prop['encodedjsconfigvars'] ) ) {
 443                         $this->addWarning( 'apiwarn-moduleswithoutvars' );
 444                 }
 445
 446                 if ( isset( $prop['indicators'] ) ) {
 447                         if ( $skin ) {
 448                                 $result_array['indicators'] = (array)$outputPage->getIndicators();
 449                         } else {
 450                                 $result_array['indicators'] = (array)$p_result->getIndicators();
 451                         }
 452                         ApiResult::setArrayType( $result_array['indicators'], 'BCkvp', 'name' );
 453                 }
 454
 455                 if ( isset( $prop['iwlinks'] ) ) {
 456                         $result_array['iwlinks'] = $this->formatIWLinks( $p_result->getInterwikiLinks() );
 457                 }
 458
 459                 if ( isset( $prop['wikitext'] ) ) {
 460                         $result_array['wikitext'] = $this->content->serialize( $format );
 461                         $result_array[ApiResult::META_BC_SUBELEMENTS][] = 'wikitext';
 462                         if ( !is_null( $this->pstContent ) ) {
 463                                 $result_array['psttext'] = $this->pstContent->serialize( $format );
 464                                 $result_array[ApiResult::META_BC_SUBELEMENTS][] = 'psttext';
 465                         }
 466                 }
 467                 if ( isset( $prop['properties'] ) ) {
 468                         $result_array['properties'] = (array)$p_result->getProperties();
 469                         ApiResult::setArrayType( $result_array['properties'], 'BCkvp', 'name' );
 470                 }
 471
 472                 if ( isset( $prop['limitreportdata'] ) ) {
 473                         $result_array['limitreportdata'] =
 474                                 $this->formatLimitReportData( $p_result->getLimitReportData() );
 475                 }
 476                 if ( isset( $prop['limitreporthtml'] ) ) {
 477                         $result_array['limitreporthtml'] = EditPage::getPreviewLimitReport( $p_result );
 478                         $result_array[ApiResult::META_BC_SUBELEMENTS][] = 'limitreporthtml';
 479                 }
 480
 481                 if ( isset( $prop['parsetree'] ) || $params['generatexml'] ) {
 482                         if ( $this->content->getModel() != CONTENT_MODEL_WIKITEXT ) {
 483                                 $this->dieWithError( 'apierror-parsetree-notwikitext', 'notwikitext' );
 484                         }
 485
 486                         $wgParser->startExternalParse( $titleObj, $popts, Parser::OT_PREPROCESS );
 487                         $xml = $wgParser->preprocessToDom( $this->content->getNativeData() )->__toString();
 488                         $result_array['parsetree'] = $xml;
 489                         $result_array[ApiResult::META_BC_SUBELEMENTS][] = 'parsetree';
 490                 }
 491
 492                 $result_mapping = [
 493                         'redirects' => 'r',
 494                         'langlinks' => 'll',
 495                         'categories' => 'cl',
 496                         'links' => 'pl',
 497                         'templates' => 'tl',
 498                         'images' => 'img',
 499                         'externallinks' => 'el',
 500                         'iwlinks' => 'iw',
 501                         'sections' => 's',
 502                         'headitems' => 'hi',
 503                         'modules' => 'm',
 504                         'indicators' => 'ind',
 505                         'modulescripts' => 'm',
 506                         'modulestyles' => 'm',
 507                         'properties' => 'pp',
 508                         'limitreportdata' => 'lr',
 509                         'parsewarnings' => 'pw'
 510                 ];
 511                 $this->setIndexedTagNames( $result_array, $result_mapping );
 512                 $result->addValue( null, $this->getModuleName(), $result_array );
 513         }
 514
 515         /**
 516          * Constructs a ParserOptions object
 517          *
 518          * @param WikiPage $pageObj
 519          * @param array $params
 520          *
 521          * @return array [ ParserOptions, ScopedCallback, bool $suppressCache ]
 522          */
 523         protected function makeParserOptions( WikiPage $pageObj, array $params ) {
 524                 $popts = $pageObj->makeParserOptions( $this->getContext() );
 525                 $popts->enableLimitReport( !$params['disablepp'] && !$params['disablelimitreport'] );
 526                 $popts->setIsPreview( $params['preview'] || $params['sectionpreview'] );
 527                 $popts->setIsSectionPreview( $params['sectionpreview'] );
 528                 if ( $params['disabletidy'] ) {
 529                         $popts->setTidy( false );
 530                 }
 531                 if ( $params['wrapoutputclass'] !== '' ) {
 532                         $popts->setWrapOutputClass( $params['wrapoutputclass'] );
 533                 }
 534
 535                 $reset = null;
 536                 $suppressCache = false;
 537                 Hooks::run( 'ApiMakeParserOptions',
 538                         [ $popts, $pageObj->getTitle(), $params, $this, &$reset, &$suppressCache ] );
 539
 540                 // Force cache suppression when $popts aren't cacheable.
 541                 $suppressCache = $suppressCache || !$popts->isSafeToCache();
 542
 543                 return [ $popts, $reset, $suppressCache ];
 544         }
 545
 546         /**
 547          * @param WikiPage $page
 548          * @param ParserOptions $popts
 549          * @param bool $suppressCache
 550          * @param int $pageId
 551          * @param Revision|null $rev
 552          * @param bool $getContent
 553          * @return ParserOutput
 554          */
 555         private function getParsedContent(
 556                 WikiPage $page, $popts, $suppressCache, $pageId, $rev, $getContent
 557         ) {
 558                 $revId = $rev ? $rev->getId() : null;
 559                 $isDeleted = $rev && $rev->isDeleted( Revision::DELETED_TEXT );
 560
 561                 if ( $getContent || $this->section !== false || $isDeleted ) {
 562                         if ( $rev ) {
 563                                 $this->content = $rev->getContent( Revision::FOR_THIS_USER, $this->getUser() );
 564                                 if ( !$this->content ) {
 565                                         $this->dieWithError( [ 'apierror-missingcontent-revid', $revId ] );
 566                                 }
 567                         } else {
 568                                 $this->content = $page->getContent( Revision::FOR_THIS_USER, $this->getUser() );
 569                                 if ( !$this->content ) {
 570                                         $this->dieWithError( [ 'apierror-missingcontent-pageid', $page->getId() ] );
 571                                 }
 572                         }
 573                         $this->contentIsDeleted = $isDeleted;
 574                         $this->contentIsSuppressed = $rev &&
 575                                 $rev->isDeleted( Revision::DELETED_TEXT | Revision::DELETED_RESTRICTED );
 576                 }
 577
 578                 if ( $this->section !== false ) {
 579                         $this->content = $this->getSectionContent(
 580                                 $this->content,
 581                                 $pageId === null ? $page->getTitle()->getPrefixedText() : $this->msg( 'pageid', $pageId )
 582                         );
 583                         return $this->content->getParserOutput( $page->getTitle(), $revId, $popts );
 584                 }
 585
 586                 if ( $isDeleted ) {
 587                         // getParserOutput can't do revdeled revisions
 588                         $pout = $this->content->getParserOutput( $page->getTitle(), $revId, $popts );
 589                 } else {
 590                         // getParserOutput will save to Parser cache if able
 591                         $pout = $page->getParserOutput( $popts, $revId, $suppressCache );
 592                 }
 593                 if ( !$pout ) {
 594                         $this->dieWithError( [ 'apierror-nosuchrevid', $revId ?: $page->getLatest() ] ); // @codeCoverageIgnore
 595                 }
 596
 597                 return $pout;
 598         }
 599
 600         /**
 601          * Extract the requested section from the given Content
 602          *
 603          * @param Content $content
 604          * @param string|Message $what Identifies the content in error messages, e.g. page title.
 605          * @return Content
 606          */
 607         private function getSectionContent( Content $content, $what ) {
 608                 // Not cached (save or load)
 609                 $section = $content->getSection( $this->section );
 610                 if ( $section === false ) {
 611                         $this->dieWithError( [ 'apierror-nosuchsection-what', $this->section, $what ], 'nosuchsection' );
 612                 }
 613                 if ( $section === null ) {
 614                         $this->dieWithError( [ 'apierror-sectionsnotsupported-what', $what ], 'nosuchsection' );
 615                         $section = false;
 616                 }
 617
 618                 return $section;
 619         }
 620
 621         /**
 622          * This mimicks the behavior of EditPage in formatting a summary
 623          *
 624          * @param Title $title of the page being parsed
 625          * @param Array $params the API parameters of the request
 626          * @return Content|bool
 627          */
 628         private function formatSummary( $title, $params ) {
 629                 global $wgParser;
 630                 $summary = !is_null( $params['summary'] ) ? $params['summary'] : '';
 631                 $sectionTitle = !is_null( $params['sectiontitle'] ) ? $params['sectiontitle'] : '';
 632
 633                 if ( $this->section === 'new' && ( $sectionTitle === '' || $summary === '' ) ) {
 634                         if ( $sectionTitle !== '' ) {
 635                                 $summary = $params['sectiontitle'];
 636                         }
 637                         if ( $summary !== '' ) {
 638                                 $summary = wfMessage( 'newsectionsummary' )
 639                                         ->rawParams( $wgParser->stripSectionName( $summary ) )
 640                                                 ->inContentLanguage()->text();
 641                         }
 642                 }
 643                 return Linker::formatComment( $summary, $title, $this->section === 'new' );
 644         }
 645
 646         private function formatLangLinks( $links ) {
 647                 $result = [];
 648                 foreach ( $links as $link ) {
 649                         $entry = [];
 650                         $bits = explode( ':', $link, 2 );
 651                         $title = Title::newFromText( $link );
 652
 653                         $entry['lang'] = $bits[0];
 654                         if ( $title ) {
 655                                 $entry['url'] = wfExpandUrl( $title->getFullURL(), PROTO_CURRENT );
 656                                 // localised language name in 'uselang' language
 657                                 $entry['langname'] = Language::fetchLanguageName(
 658                                         $title->getInterwiki(),
 659                                         $this->getLanguage()->getCode()
 660                                 );
 661
 662                                 // native language name
 663                                 $entry['autonym'] = Language::fetchLanguageName( $title->getInterwiki() );
 664                         }
 665                         ApiResult::setContentValue( $entry, 'title', $bits[1] );
 666                         $result[] = $entry;
 667                 }
 668
 669                 return $result;
 670         }
 671
 672         private function formatCategoryLinks( $links ) {
 673                 $result = [];
 674
 675                 if ( !$links ) {
 676                         return $result;
 677                 }
 678
 679                 // Fetch hiddencat property
 680                 $lb = new LinkBatch;
 681                 $lb->setArray( [ NS_CATEGORY => $links ] );
 682                 $db = $this->getDB();
 683                 $res = $db->select( [ 'page', 'page_props' ],
 684                         [ 'page_title', 'pp_propname' ],
 685                         $lb->constructSet( 'page', $db ),
 686                         __METHOD__,
 687                         [],
 688                         [ 'page_props' => [
 689                                 'LEFT JOIN', [ 'pp_propname' => 'hiddencat', 'pp_page = page_id' ]
 690                         ] ]
 691                 );
 692                 $hiddencats = [];
 693                 foreach ( $res as $row ) {
 694                         $hiddencats[$row->page_title] = isset( $row->pp_propname );
 695                 }
 696
 697                 $linkCache = LinkCache::singleton();
 698
 699                 foreach ( $links as $link => $sortkey ) {
 700                         $entry = [];
 701                         $entry['sortkey'] = $sortkey;
 702                         // array keys will cast numeric category names to ints, so cast back to string
 703                         ApiResult::setContentValue( $entry, 'category', (string)$link );
 704                         if ( !isset( $hiddencats[$link] ) ) {
 705                                 $entry['missing'] = true;
 706
 707                                 // We already know the link doesn't exist in the database, so
 708                                 // tell LinkCache that before calling $title->isKnown().
 709                                 $title = Title::makeTitle( NS_CATEGORY, $link );
 710                                 $linkCache->addBadLinkObj( $title );
 711                                 if ( $title->isKnown() ) {
 712                                         $entry['known'] = true;
 713                                 }
 714                         } elseif ( $hiddencats[$link] ) {
 715                                 $entry['hidden'] = true;
 716                         }
 717                         $result[] = $entry;
 718                 }
 719
 720                 return $result;
 721         }
 722
 723         private function formatLinks( $links ) {
 724                 $result = [];
 725                 foreach ( $links as $ns => $nslinks ) {
 726                         foreach ( $nslinks as $title => $id ) {
 727                                 $entry = [];
 728                                 $entry['ns'] = $ns;
 729                                 ApiResult::setContentValue( $entry, 'title', Title::makeTitle( $ns, $title )->getFullText() );
 730                                 $entry['exists'] = $id != 0;
 731                                 $result[] = $entry;
 732                         }
 733                 }
 734
 735                 return $result;
 736         }
 737
 738         private function formatIWLinks( $iw ) {
 739                 $result = [];
 740                 foreach ( $iw as $prefix => $titles ) {
 741                         foreach ( array_keys( $titles ) as $title ) {
 742                                 $entry = [];
 743                                 $entry['prefix'] = $prefix;
 744
 745                                 $title = Title::newFromText( "{$prefix}:{$title}" );
 746                                 if ( $title ) {
 747                                         $entry['url'] = wfExpandUrl( $title->getFullURL(), PROTO_CURRENT );
 748                                 }
 749
 750                                 ApiResult::setContentValue( $entry, 'title', $title->getFullText() );
 751                                 $result[] = $entry;
 752                         }
 753                 }
 754
 755                 return $result;
 756         }
 757
 758         private function formatHeadItems( $headItems ) {
 759                 $result = [];
 760                 foreach ( $headItems as $tag => $content ) {
 761                         $entry = [];
 762                         $entry['tag'] = $tag;
 763                         ApiResult::setContentValue( $entry, 'content', $content );
 764                         $result[] = $entry;
 765                 }
 766
 767                 return $result;
 768         }
 769
 770         private function formatLimitReportData( $limitReportData ) {
 771                 $result = [];
 772
 773                 foreach ( $limitReportData as $name => $value ) {
 774                         $entry = [];
 775                         $entry['name'] = $name;
 776                         if ( !is_array( $value ) ) {
 777                                 $value = [ $value ];
 778                         }
 779                         ApiResult::setIndexedTagNameRecursive( $value, 'param' );
 780                         $entry = array_merge( $entry, $value );
 781                         $result[] = $entry;
 782                 }
 783
 784                 return $result;
 785         }
 786
 787         private function setIndexedTagNames( &$array, $mapping ) {
 788                 foreach ( $mapping as $key => $name ) {
 789                         if ( isset( $array[$key] ) ) {
 790                                 ApiResult::setIndexedTagName( $array[$key], $name );
 791                         }
 792                 }
 793         }
 794
 795         public function getAllowedParams() {
 796                 return [
 797                         'title' => null,
 798                         'text' => [
 799                                 ApiBase::PARAM_TYPE => 'text',
 800                         ],
 801                         'revid' => [
 802                                 ApiBase::PARAM_TYPE => 'integer',
 803                         ],
 804                         'summary' => null,
 805                         'page' => null,
 806                         'pageid' => [
 807                                 ApiBase::PARAM_TYPE => 'integer',
 808                         ],
 809                         'redirects' => false,
 810                         'oldid' => [
 811                                 ApiBase::PARAM_TYPE => 'integer',
 812                         ],
 813                         'prop' => [
 814                                 ApiBase::PARAM_DFLT => 'text|langlinks|categories|links|templates|' .
 815                                         'images|externallinks|sections|revid|displaytitle|iwlinks|' .
 816                                         'properties|parsewarnings',
 817                                 ApiBase::PARAM_ISMULTI => true,
 818                                 ApiBase::PARAM_TYPE => [
 819                                         'text',
 820                                         'langlinks',
 821                                         'categories',
 822                                         'categorieshtml',
 823                                         'links',
 824                                         'templates',
 825                                         'images',
 826                                         'externallinks',
 827                                         'sections',
 828                                         'revid',
 829                                         'displaytitle',
 830                                         'headhtml',
 831                                         'modules',
 832                                         'jsconfigvars',
 833                                         'encodedjsconfigvars',
 834                                         'indicators',
 835                                         'iwlinks',
 836                                         'wikitext',
 837                                         'properties',
 838                                         'limitreportdata',
 839                                         'limitreporthtml',
 840                                         'parsetree',
 841                                         'parsewarnings',
 842                                         'headitems',
 843                                 ],
 844                                 ApiBase::PARAM_HELP_MSG_PER_VALUE => [
 845                                         'parsetree' => [ 'apihelp-parse-paramvalue-prop-parsetree', CONTENT_MODEL_WIKITEXT ],
 846                                 ],
 847                                 ApiBase::PARAM_DEPRECATED_VALUES => [
 848                                         'headitems' => 'apiwarn-deprecation-parse-headitems',
 849                                 ],
 850                         ],
 851                         'wrapoutputclass' => 'mw-parser-output',
 852                         'pst' => false,
 853                         'onlypst' => false,
 854                         'effectivelanglinks' => [
 855                                 ApiBase::PARAM_DFLT => false,
 856                                 ApiBase::PARAM_DEPRECATED => true,
 857                         ],
 858                         'section' => null,
 859                         'sectiontitle' => [
 860                                 ApiBase::PARAM_TYPE => 'string',
 861                         ],
 862                         'disablepp' => [
 863                                 ApiBase::PARAM_DFLT => false,
 864                                 ApiBase::PARAM_DEPRECATED => true,
 865                         ],
 866                         'disablelimitreport' => false,
 867                         'disableeditsection' => false,
 868                         'disabletidy' => false,
 869                         'disablestylededuplication' => false,
 870                         'generatexml' => [
 871                                 ApiBase::PARAM_DFLT => false,
 872                                 ApiBase::PARAM_HELP_MSG => [
 873                                         'apihelp-parse-param-generatexml', CONTENT_MODEL_WIKITEXT
 874                                 ],
 875                                 ApiBase::PARAM_DEPRECATED => true,
 876                         ],
 877                         'preview' => false,
 878                         'sectionpreview' => false,
 879                         'disabletoc' => false,
 880                         'useskin' => [
 881                                 ApiBase::PARAM_TYPE => array_keys( Skin::getAllowedSkins() ),
 882                         ],
 883                         'contentformat' => [
 884                                 ApiBase::PARAM_TYPE => ContentHandler::getAllContentFormats(),
 885                         ],
 886                         'contentmodel' => [
 887                                 ApiBase::PARAM_TYPE => ContentHandler::getContentModels(),
 888                         ]
 889                 ];
 890         }
 891
 892         protected function getExamplesMessages() {
 893                 return [
 894                         'action=parse&page=Project:Sandbox'
 895                                 => 'apihelp-parse-example-page',
 896                         'action=parse&text={{Project:Sandbox}}&contentmodel=wikitext'
 897                                 => 'apihelp-parse-example-text',
 898                         'action=parse&text={{PAGENAME}}&title=Test'
 899                                 => 'apihelp-parse-example-texttitle',
 900                         'action=parse&summary=Some+[[link]]&prop='
 901                                 => 'apihelp-parse-example-summary',
 902                 ];
 903         }
 904
 905         public function getHelpUrls() {
 906                 return 'https://www.mediawiki.org/wiki/Special:MyLanguage/API:Parsing_wikitext#parse';
 907         }
 908 }