Only pretty-print the parser report JS vars
[lhc/web/wiklou.git] / includes / OutputPage.php
1 <?php
2 /**
3 * Preparation for the final page rendering.
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\Logger\LoggerFactory;
24 use MediaWiki\Session\SessionManager;
25 use WrappedString\WrappedString;
26 use WrappedString\WrappedStringList;
27
28 /**
29 * This class should be covered by a general architecture document which does
30 * not exist as of January 2011. This is one of the Core classes and should
31 * be read at least once by any new developers.
32 *
33 * This class is used to prepare the final rendering. A skin is then
34 * applied to the output parameters (links, javascript, html, categories ...).
35 *
36 * @todo FIXME: Another class handles sending the whole page to the client.
37 *
38 * Some comments comes from a pairing session between Zak Greant and Antoine Musso
39 * in November 2010.
40 *
41 * @todo document
42 */
43 class OutputPage extends ContextSource {
44 /** @var array Should be private. Used with addMeta() which adds "<meta>" */
45 protected $mMetatags = [];
46
47 /** @var array */
48 protected $mLinktags = [];
49
50 /** @var bool */
51 protected $mCanonicalUrl = false;
52
53 /**
54 * @var array Additional stylesheets. Looks like this is for extensions.
55 * Might be replaced by ResourceLoader.
56 */
57 protected $mExtStyles = [];
58
59 /**
60 * @var string Should be private - has getter and setter. Contains
61 * the HTML title */
62 public $mPagetitle = '';
63
64 /**
65 * @var string Contains all of the "<body>" content. Should be private we
66 * got set/get accessors and the append() method.
67 */
68 public $mBodytext = '';
69
70 /**
71 * Holds the debug lines that will be output as comments in page source if
72 * $wgDebugComments is enabled. See also $wgShowDebug.
73 * @deprecated since 1.20; use MWDebug class instead.
74 */
75 public $mDebugtext = '';
76
77 /** @var string Stores contents of "<title>" tag */
78 private $mHTMLtitle = '';
79
80 /**
81 * @var bool Is the displayed content related to the source of the
82 * corresponding wiki article.
83 */
84 private $mIsarticle = false;
85
86 /** @var bool Stores "article flag" toggle. */
87 private $mIsArticleRelated = true;
88
89 /**
90 * @var bool We have to set isPrintable(). Some pages should
91 * never be printed (ex: redirections).
92 */
93 private $mPrintable = false;
94
95 /**
96 * @var array Contains the page subtitle. Special pages usually have some
97 * links here. Don't confuse with site subtitle added by skins.
98 */
99 private $mSubtitle = [];
100
101 /** @var string */
102 public $mRedirect = '';
103
104 /** @var int */
105 protected $mStatusCode;
106
107 /**
108 * @var string Used for sending cache control.
109 * The whole caching system should probably be moved into its own class.
110 */
111 protected $mLastModified = '';
112
113 /** @var array */
114 protected $mCategoryLinks = [];
115
116 /** @var array */
117 protected $mCategories = [];
118
119 /** @var array */
120 protected $mIndicators = [];
121
122 /** @var array Array of Interwiki Prefixed (non DB key) Titles (e.g. 'fr:Test page') */
123 private $mLanguageLinks = [];
124
125 /**
126 * Used for JavaScript (predates ResourceLoader)
127 * @todo We should split JS / CSS.
128 * mScripts content is inserted as is in "<head>" by Skin. This might
129 * contain either a link to a stylesheet or inline CSS.
130 */
131 private $mScripts = '';
132
133 /** @var string Inline CSS styles. Use addInlineStyle() sparingly */
134 protected $mInlineStyles = '';
135
136 /**
137 * @var string Used by skin template.
138 * Example: $tpl->set( 'displaytitle', $out->mPageLinkTitle );
139 */
140 public $mPageLinkTitle = '';
141
142 /** @var array Array of elements in "<head>". Parser might add its own headers! */
143 protected $mHeadItems = [];
144
145 /** @var array */
146 protected $mModules = [];
147
148 /** @var array */
149 protected $mModuleScripts = [];
150
151 /** @var array */
152 protected $mModuleStyles = [];
153
154 /** @var ResourceLoader */
155 protected $mResourceLoader;
156
157 /** @var array */
158 protected $mJsConfigVars = [];
159
160 /** @var array */
161 protected $mTemplateIds = [];
162
163 /** @var array */
164 protected $mImageTimeKeys = [];
165
166 /** @var string */
167 public $mRedirectCode = '';
168
169 protected $mFeedLinksAppendQuery = null;
170
171 /** @var array
172 * What level of 'untrustworthiness' is allowed in CSS/JS modules loaded on this page?
173 * @see ResourceLoaderModule::$origin
174 * ResourceLoaderModule::ORIGIN_ALL is assumed unless overridden;
175 */
176 protected $mAllowedModules = [
177 ResourceLoaderModule::TYPE_COMBINED => ResourceLoaderModule::ORIGIN_ALL,
178 ];
179
180 /** @var bool Whether output is disabled. If this is true, the 'output' method will do nothing. */
181 protected $mDoNothing = false;
182
183 // Parser related.
184
185 /** @var int */
186 protected $mContainsNewMagic = 0;
187
188 /**
189 * lazy initialised, use parserOptions()
190 * @var ParserOptions
191 */
192 protected $mParserOptions = null;
193
194 /**
195 * Handles the Atom / RSS links.
196 * We probably only support Atom in 2011.
197 * @see $wgAdvertisedFeedTypes
198 */
199 private $mFeedLinks = [];
200
201 // Gwicke work on squid caching? Roughly from 2003.
202 protected $mEnableClientCache = true;
203
204 /** @var bool Flag if output should only contain the body of the article. */
205 private $mArticleBodyOnly = false;
206
207 /** @var bool */
208 protected $mNewSectionLink = false;
209
210 /** @var bool */
211 protected $mHideNewSectionLink = false;
212
213 /**
214 * @var bool Comes from the parser. This was probably made to load CSS/JS
215 * only if we had "<gallery>". Used directly in CategoryPage.php.
216 * Looks like ResourceLoader can replace this.
217 */
218 public $mNoGallery = false;
219
220 /** @var string */
221 private $mPageTitleActionText = '';
222
223 /** @var int Cache stuff. Looks like mEnableClientCache */
224 protected $mCdnMaxage = 0;
225 /** @var int Upper limit on mCdnMaxage */
226 protected $mCdnMaxageLimit = INF;
227
228 /**
229 * @var bool Controls if anti-clickjacking / frame-breaking headers will
230 * be sent. This should be done for pages where edit actions are possible.
231 * Setters: $this->preventClickjacking() and $this->allowClickjacking().
232 */
233 protected $mPreventClickjacking = true;
234
235 /** @var int To include the variable {{REVISIONID}} */
236 private $mRevisionId = null;
237
238 /** @var string */
239 private $mRevisionTimestamp = null;
240
241 /** @var array */
242 protected $mFileVersion = null;
243
244 /**
245 * @var array An array of stylesheet filenames (relative from skins path),
246 * with options for CSS media, IE conditions, and RTL/LTR direction.
247 * For internal use; add settings in the skin via $this->addStyle()
248 *
249 * Style again! This seems like a code duplication since we already have
250 * mStyles. This is what makes Open Source amazing.
251 */
252 protected $styles = [];
253
254 private $mIndexPolicy = 'index';
255 private $mFollowPolicy = 'follow';
256 private $mVaryHeader = [
257 'Accept-Encoding' => [ 'match=gzip' ],
258 ];
259
260 /**
261 * If the current page was reached through a redirect, $mRedirectedFrom contains the Title
262 * of the redirect.
263 *
264 * @var Title
265 */
266 private $mRedirectedFrom = null;
267
268 /**
269 * Additional key => value data
270 */
271 private $mProperties = [];
272
273 /**
274 * @var string|null ResourceLoader target for load.php links. If null, will be omitted
275 */
276 private $mTarget = null;
277
278 /**
279 * @var bool Whether parser output should contain table of contents
280 */
281 private $mEnableTOC = true;
282
283 /**
284 * @var bool Whether parser output should contain section edit links
285 */
286 private $mEnableSectionEditLinks = true;
287
288 /**
289 * @var string|null The URL to send in a <link> element with rel=copyright
290 */
291 private $copyrightUrl;
292
293 /** @var array Profiling data */
294 private $limitReportData = [];
295
296 /**
297 * Constructor for OutputPage. This should not be called directly.
298 * Instead a new RequestContext should be created and it will implicitly create
299 * a OutputPage tied to that context.
300 * @param IContextSource|null $context
301 */
302 function __construct( IContextSource $context = null ) {
303 if ( $context === null ) {
304 # Extensions should use `new RequestContext` instead of `new OutputPage` now.
305 wfDeprecated( __METHOD__, '1.18' );
306 } else {
307 $this->setContext( $context );
308 }
309 }
310
311 /**
312 * Redirect to $url rather than displaying the normal page
313 *
314 * @param string $url URL
315 * @param string $responsecode HTTP status code
316 */
317 public function redirect( $url, $responsecode = '302' ) {
318 # Strip newlines as a paranoia check for header injection in PHP<5.1.2
319 $this->mRedirect = str_replace( "\n", '', $url );
320 $this->mRedirectCode = $responsecode;
321 }
322
323 /**
324 * Get the URL to redirect to, or an empty string if not redirect URL set
325 *
326 * @return string
327 */
328 public function getRedirect() {
329 return $this->mRedirect;
330 }
331
332 /**
333 * Set the copyright URL to send with the output.
334 * Empty string to omit, null to reset.
335 *
336 * @since 1.26
337 *
338 * @param string|null $url
339 */
340 public function setCopyrightUrl( $url ) {
341 $this->copyrightUrl = $url;
342 }
343
344 /**
345 * Set the HTTP status code to send with the output.
346 *
347 * @param int $statusCode
348 */
349 public function setStatusCode( $statusCode ) {
350 $this->mStatusCode = $statusCode;
351 }
352
353 /**
354 * Add a new "<meta>" tag
355 * To add an http-equiv meta tag, precede the name with "http:"
356 *
357 * @param string $name Tag name
358 * @param string $val Tag value
359 */
360 function addMeta( $name, $val ) {
361 array_push( $this->mMetatags, [ $name, $val ] );
362 }
363
364 /**
365 * Returns the current <meta> tags
366 *
367 * @since 1.25
368 * @return array
369 */
370 public function getMetaTags() {
371 return $this->mMetatags;
372 }
373
374 /**
375 * Add a new \<link\> tag to the page header.
376 *
377 * Note: use setCanonicalUrl() for rel=canonical.
378 *
379 * @param array $linkarr Associative array of attributes.
380 */
381 function addLink( array $linkarr ) {
382 array_push( $this->mLinktags, $linkarr );
383 }
384
385 /**
386 * Returns the current <link> tags
387 *
388 * @since 1.25
389 * @return array
390 */
391 public function getLinkTags() {
392 return $this->mLinktags;
393 }
394
395 /**
396 * Add a new \<link\> with "rel" attribute set to "meta"
397 *
398 * @param array $linkarr Associative array mapping attribute names to their
399 * values, both keys and values will be escaped, and the
400 * "rel" attribute will be automatically added
401 */
402 function addMetadataLink( array $linkarr ) {
403 $linkarr['rel'] = $this->getMetadataAttribute();
404 $this->addLink( $linkarr );
405 }
406
407 /**
408 * Set the URL to be used for the <link rel=canonical>. This should be used
409 * in preference to addLink(), to avoid duplicate link tags.
410 * @param string $url
411 */
412 function setCanonicalUrl( $url ) {
413 $this->mCanonicalUrl = $url;
414 }
415
416 /**
417 * Returns the URL to be used for the <link rel=canonical> if
418 * one is set.
419 *
420 * @since 1.25
421 * @return bool|string
422 */
423 public function getCanonicalUrl() {
424 return $this->mCanonicalUrl;
425 }
426
427 /**
428 * Get the value of the "rel" attribute for metadata links
429 *
430 * @return string
431 */
432 public function getMetadataAttribute() {
433 # note: buggy CC software only reads first "meta" link
434 static $haveMeta = false;
435 if ( $haveMeta ) {
436 return 'alternate meta';
437 } else {
438 $haveMeta = true;
439 return 'meta';
440 }
441 }
442
443 /**
444 * Add raw HTML to the list of scripts (including \<script\> tag, etc.)
445 * Internal use only. Use OutputPage::addModules() or OutputPage::addJsConfigVars()
446 * if possible.
447 *
448 * @param string $script Raw HTML
449 */
450 function addScript( $script ) {
451 $this->mScripts .= $script;
452 }
453
454 /**
455 * Register and add a stylesheet from an extension directory.
456 *
457 * @deprecated since 1.27 use addModuleStyles() or addStyle() instead
458 * @param string $url Path to sheet. Provide either a full url (beginning
459 * with 'http', etc) or a relative path from the document root
460 * (beginning with '/'). Otherwise it behaves identically to
461 * addStyle() and draws from the /skins folder.
462 */
463 public function addExtensionStyle( $url ) {
464 wfDeprecated( __METHOD__, '1.27' );
465 array_push( $this->mExtStyles, $url );
466 }
467
468 /**
469 * Get all styles added by extensions
470 *
471 * @deprecated since 1.27
472 * @return array
473 */
474 function getExtStyle() {
475 wfDeprecated( __METHOD__, '1.27' );
476 return $this->mExtStyles;
477 }
478
479 /**
480 * Add a JavaScript file out of skins/common, or a given relative path.
481 * Internal use only. Use OutputPage::addModules() if possible.
482 *
483 * @param string $file Filename in skins/common or complete on-server path
484 * (/foo/bar.js)
485 * @param string $version Style version of the file. Defaults to $wgStyleVersion
486 */
487 public function addScriptFile( $file, $version = null ) {
488 // See if $file parameter is an absolute URL or begins with a slash
489 if ( substr( $file, 0, 1 ) == '/' || preg_match( '#^[a-z]*://#i', $file ) ) {
490 $path = $file;
491 } else {
492 $path = $this->getConfig()->get( 'StylePath' ) . "/common/{$file}";
493 }
494 if ( is_null( $version ) ) {
495 $version = $this->getConfig()->get( 'StyleVersion' );
496 }
497 $this->addScript( Html::linkedScript( wfAppendQuery( $path, $version ) ) );
498 }
499
500 /**
501 * Add a self-contained script tag with the given contents
502 * Internal use only. Use OutputPage::addModules() if possible.
503 *
504 * @param string $script JavaScript text, no "<script>" tags
505 */
506 public function addInlineScript( $script ) {
507 $this->mScripts .= Html::inlineScript( $script );
508 }
509
510 /**
511 * Filter an array of modules to remove insufficiently trustworthy members, and modules
512 * which are no longer registered (eg a page is cached before an extension is disabled)
513 * @param array $modules
514 * @param string|null $position If not null, only return modules with this position
515 * @param string $type
516 * @return array
517 */
518 protected function filterModules( array $modules, $position = null,
519 $type = ResourceLoaderModule::TYPE_COMBINED
520 ) {
521 $resourceLoader = $this->getResourceLoader();
522 $filteredModules = [];
523 foreach ( $modules as $val ) {
524 $module = $resourceLoader->getModule( $val );
525 if ( $module instanceof ResourceLoaderModule
526 && $module->getOrigin() <= $this->getAllowedModules( $type )
527 && ( is_null( $position ) || $module->getPosition() == $position )
528 && ( !$this->mTarget || in_array( $this->mTarget, $module->getTargets() ) )
529 ) {
530 $filteredModules[] = $val;
531 }
532 }
533 return $filteredModules;
534 }
535
536 /**
537 * Get the list of modules to include on this page
538 *
539 * @param bool $filter Whether to filter out insufficiently trustworthy modules
540 * @param string|null $position If not null, only return modules with this position
541 * @param string $param
542 * @return array Array of module names
543 */
544 public function getModules( $filter = false, $position = null, $param = 'mModules' ) {
545 $modules = array_values( array_unique( $this->$param ) );
546 return $filter
547 ? $this->filterModules( $modules, $position )
548 : $modules;
549 }
550
551 /**
552 * Add one or more modules recognized by ResourceLoader. Modules added
553 * through this function will be loaded by ResourceLoader when the
554 * page loads.
555 *
556 * @param string|array $modules Module name (string) or array of module names
557 */
558 public function addModules( $modules ) {
559 $this->mModules = array_merge( $this->mModules, (array)$modules );
560 }
561
562 /**
563 * Get the list of module JS to include on this page
564 *
565 * @param bool $filter
566 * @param string|null $position
567 *
568 * @return array Array of module names
569 */
570 public function getModuleScripts( $filter = false, $position = null ) {
571 return $this->getModules( $filter, $position, 'mModuleScripts' );
572 }
573
574 /**
575 * Add only JS of one or more modules recognized by ResourceLoader. Module
576 * scripts added through this function will be loaded by ResourceLoader when
577 * the page loads.
578 *
579 * @param string|array $modules Module name (string) or array of module names
580 */
581 public function addModuleScripts( $modules ) {
582 $this->mModuleScripts = array_merge( $this->mModuleScripts, (array)$modules );
583 }
584
585 /**
586 * Get the list of module CSS to include on this page
587 *
588 * @param bool $filter
589 * @param string|null $position
590 *
591 * @return array Array of module names
592 */
593 public function getModuleStyles( $filter = false, $position = null ) {
594 return $this->getModules( $filter, $position, 'mModuleStyles' );
595 }
596
597 /**
598 * Add only CSS of one or more modules recognized by ResourceLoader.
599 *
600 * Module styles added through this function will be added using standard link CSS
601 * tags, rather than as a combined Javascript and CSS package. Thus, they will
602 * load when JavaScript is disabled (unless CSS also happens to be disabled).
603 *
604 * @param string|array $modules Module name (string) or array of module names
605 */
606 public function addModuleStyles( $modules ) {
607 $this->mModuleStyles = array_merge( $this->mModuleStyles, (array)$modules );
608 }
609
610 /**
611 * @return null|string ResourceLoader target
612 */
613 public function getTarget() {
614 return $this->mTarget;
615 }
616
617 /**
618 * Sets ResourceLoader target for load.php links. If null, will be omitted
619 *
620 * @param string|null $target
621 */
622 public function setTarget( $target ) {
623 $this->mTarget = $target;
624 }
625
626 /**
627 * Get an array of head items
628 *
629 * @return array
630 */
631 function getHeadItemsArray() {
632 return $this->mHeadItems;
633 }
634
635 /**
636 * Add or replace an header item to the output
637 *
638 * Whenever possible, use more specific options like ResourceLoader modules,
639 * OutputPage::addLink(), OutputPage::addMetaLink() and OutputPage::addFeedLink()
640 * Fallback options for those are: OutputPage::addStyle, OutputPage::addScript(),
641 * OutputPage::addInlineScript() and OutputPage::addInlineStyle()
642 * This would be your very LAST fallback.
643 *
644 * @param string $name Item name
645 * @param string $value Raw HTML
646 */
647 public function addHeadItem( $name, $value ) {
648 $this->mHeadItems[$name] = $value;
649 }
650
651 /**
652 * Check if the header item $name is already set
653 *
654 * @param string $name Item name
655 * @return bool
656 */
657 public function hasHeadItem( $name ) {
658 return isset( $this->mHeadItems[$name] );
659 }
660
661 /**
662 * @deprecated since 1.28 Obsolete - wgUseETag experiment was removed.
663 * @param string $tag
664 */
665 public function setETag( $tag ) {
666 }
667
668 /**
669 * Set whether the output should only contain the body of the article,
670 * without any skin, sidebar, etc.
671 * Used e.g. when calling with "action=render".
672 *
673 * @param bool $only Whether to output only the body of the article
674 */
675 public function setArticleBodyOnly( $only ) {
676 $this->mArticleBodyOnly = $only;
677 }
678
679 /**
680 * Return whether the output will contain only the body of the article
681 *
682 * @return bool
683 */
684 public function getArticleBodyOnly() {
685 return $this->mArticleBodyOnly;
686 }
687
688 /**
689 * Set an additional output property
690 * @since 1.21
691 *
692 * @param string $name
693 * @param mixed $value
694 */
695 public function setProperty( $name, $value ) {
696 $this->mProperties[$name] = $value;
697 }
698
699 /**
700 * Get an additional output property
701 * @since 1.21
702 *
703 * @param string $name
704 * @return mixed Property value or null if not found
705 */
706 public function getProperty( $name ) {
707 if ( isset( $this->mProperties[$name] ) ) {
708 return $this->mProperties[$name];
709 } else {
710 return null;
711 }
712 }
713
714 /**
715 * checkLastModified tells the client to use the client-cached page if
716 * possible. If successful, the OutputPage is disabled so that
717 * any future call to OutputPage->output() have no effect.
718 *
719 * Side effect: sets mLastModified for Last-Modified header
720 *
721 * @param string $timestamp
722 *
723 * @return bool True if cache-ok headers was sent.
724 */
725 public function checkLastModified( $timestamp ) {
726 if ( !$timestamp || $timestamp == '19700101000000' ) {
727 wfDebug( __METHOD__ . ": CACHE DISABLED, NO TIMESTAMP\n" );
728 return false;
729 }
730 $config = $this->getConfig();
731 if ( !$config->get( 'CachePages' ) ) {
732 wfDebug( __METHOD__ . ": CACHE DISABLED\n" );
733 return false;
734 }
735
736 $timestamp = wfTimestamp( TS_MW, $timestamp );
737 $modifiedTimes = [
738 'page' => $timestamp,
739 'user' => $this->getUser()->getTouched(),
740 'epoch' => $config->get( 'CacheEpoch' )
741 ];
742 if ( $config->get( 'UseSquid' ) ) {
743 // bug 44570: the core page itself may not change, but resources might
744 $modifiedTimes['sepoch'] = wfTimestamp( TS_MW, time() - $config->get( 'SquidMaxage' ) );
745 }
746 Hooks::run( 'OutputPageCheckLastModified', [ &$modifiedTimes, $this ] );
747
748 $maxModified = max( $modifiedTimes );
749 $this->mLastModified = wfTimestamp( TS_RFC2822, $maxModified );
750
751 $clientHeader = $this->getRequest()->getHeader( 'If-Modified-Since' );
752 if ( $clientHeader === false ) {
753 wfDebug( __METHOD__ . ": client did not send If-Modified-Since header", 'private' );
754 return false;
755 }
756
757 # IE sends sizes after the date like this:
758 # Wed, 20 Aug 2003 06:51:19 GMT; length=5202
759 # this breaks strtotime().
760 $clientHeader = preg_replace( '/;.*$/', '', $clientHeader );
761
762 MediaWiki\suppressWarnings(); // E_STRICT system time bitching
763 $clientHeaderTime = strtotime( $clientHeader );
764 MediaWiki\restoreWarnings();
765 if ( !$clientHeaderTime ) {
766 wfDebug( __METHOD__
767 . ": unable to parse the client's If-Modified-Since header: $clientHeader\n" );
768 return false;
769 }
770 $clientHeaderTime = wfTimestamp( TS_MW, $clientHeaderTime );
771
772 # Make debug info
773 $info = '';
774 foreach ( $modifiedTimes as $name => $value ) {
775 if ( $info !== '' ) {
776 $info .= ', ';
777 }
778 $info .= "$name=" . wfTimestamp( TS_ISO_8601, $value );
779 }
780
781 wfDebug( __METHOD__ . ": client sent If-Modified-Since: " .
782 wfTimestamp( TS_ISO_8601, $clientHeaderTime ), 'private' );
783 wfDebug( __METHOD__ . ": effective Last-Modified: " .
784 wfTimestamp( TS_ISO_8601, $maxModified ), 'private' );
785 if ( $clientHeaderTime < $maxModified ) {
786 wfDebug( __METHOD__ . ": STALE, $info", 'private' );
787 return false;
788 }
789
790 # Not modified
791 # Give a 304 Not Modified response code and disable body output
792 wfDebug( __METHOD__ . ": NOT MODIFIED, $info", 'private' );
793 ini_set( 'zlib.output_compression', 0 );
794 $this->getRequest()->response()->statusHeader( 304 );
795 $this->sendCacheControl();
796 $this->disable();
797
798 // Don't output a compressed blob when using ob_gzhandler;
799 // it's technically against HTTP spec and seems to confuse
800 // Firefox when the response gets split over two packets.
801 wfClearOutputBuffers();
802
803 return true;
804 }
805
806 /**
807 * Override the last modified timestamp
808 *
809 * @param string $timestamp New timestamp, in a format readable by
810 * wfTimestamp()
811 */
812 public function setLastModified( $timestamp ) {
813 $this->mLastModified = wfTimestamp( TS_RFC2822, $timestamp );
814 }
815
816 /**
817 * Set the robot policy for the page: <http://www.robotstxt.org/meta.html>
818 *
819 * @param string $policy The literal string to output as the contents of
820 * the meta tag. Will be parsed according to the spec and output in
821 * standardized form.
822 * @return null
823 */
824 public function setRobotPolicy( $policy ) {
825 $policy = Article::formatRobotPolicy( $policy );
826
827 if ( isset( $policy['index'] ) ) {
828 $this->setIndexPolicy( $policy['index'] );
829 }
830 if ( isset( $policy['follow'] ) ) {
831 $this->setFollowPolicy( $policy['follow'] );
832 }
833 }
834
835 /**
836 * Set the index policy for the page, but leave the follow policy un-
837 * touched.
838 *
839 * @param string $policy Either 'index' or 'noindex'.
840 * @return null
841 */
842 public function setIndexPolicy( $policy ) {
843 $policy = trim( $policy );
844 if ( in_array( $policy, [ 'index', 'noindex' ] ) ) {
845 $this->mIndexPolicy = $policy;
846 }
847 }
848
849 /**
850 * Set the follow policy for the page, but leave the index policy un-
851 * touched.
852 *
853 * @param string $policy Either 'follow' or 'nofollow'.
854 * @return null
855 */
856 public function setFollowPolicy( $policy ) {
857 $policy = trim( $policy );
858 if ( in_array( $policy, [ 'follow', 'nofollow' ] ) ) {
859 $this->mFollowPolicy = $policy;
860 }
861 }
862
863 /**
864 * Set the new value of the "action text", this will be added to the
865 * "HTML title", separated from it with " - ".
866 *
867 * @param string $text New value of the "action text"
868 */
869 public function setPageTitleActionText( $text ) {
870 $this->mPageTitleActionText = $text;
871 }
872
873 /**
874 * Get the value of the "action text"
875 *
876 * @return string
877 */
878 public function getPageTitleActionText() {
879 return $this->mPageTitleActionText;
880 }
881
882 /**
883 * "HTML title" means the contents of "<title>".
884 * It is stored as plain, unescaped text and will be run through htmlspecialchars in the skin file.
885 *
886 * @param string|Message $name
887 */
888 public function setHTMLTitle( $name ) {
889 if ( $name instanceof Message ) {
890 $this->mHTMLtitle = $name->setContext( $this->getContext() )->text();
891 } else {
892 $this->mHTMLtitle = $name;
893 }
894 }
895
896 /**
897 * Return the "HTML title", i.e. the content of the "<title>" tag.
898 *
899 * @return string
900 */
901 public function getHTMLTitle() {
902 return $this->mHTMLtitle;
903 }
904
905 /**
906 * Set $mRedirectedFrom, the Title of the page which redirected us to the current page.
907 *
908 * @param Title $t
909 */
910 public function setRedirectedFrom( $t ) {
911 $this->mRedirectedFrom = $t;
912 }
913
914 /**
915 * "Page title" means the contents of \<h1\>. It is stored as a valid HTML
916 * fragment. This function allows good tags like \<sup\> in the \<h1\> tag,
917 * but not bad tags like \<script\>. This function automatically sets
918 * \<title\> to the same content as \<h1\> but with all tags removed. Bad
919 * tags that were escaped in \<h1\> will still be escaped in \<title\>, and
920 * good tags like \<i\> will be dropped entirely.
921 *
922 * @param string|Message $name
923 */
924 public function setPageTitle( $name ) {
925 if ( $name instanceof Message ) {
926 $name = $name->setContext( $this->getContext() )->text();
927 }
928
929 # change "<script>foo&bar</script>" to "&lt;script&gt;foo&amp;bar&lt;/script&gt;"
930 # but leave "<i>foobar</i>" alone
931 $nameWithTags = Sanitizer::normalizeCharReferences( Sanitizer::removeHTMLtags( $name ) );
932 $this->mPagetitle = $nameWithTags;
933
934 # change "<i>foo&amp;bar</i>" to "foo&bar"
935 $this->setHTMLTitle(
936 $this->msg( 'pagetitle' )->rawParams( Sanitizer::stripAllTags( $nameWithTags ) )
937 ->inContentLanguage()
938 );
939 }
940
941 /**
942 * Return the "page title", i.e. the content of the \<h1\> tag.
943 *
944 * @return string
945 */
946 public function getPageTitle() {
947 return $this->mPagetitle;
948 }
949
950 /**
951 * Set the Title object to use
952 *
953 * @param Title $t
954 */
955 public function setTitle( Title $t ) {
956 $this->getContext()->setTitle( $t );
957 }
958
959 /**
960 * Replace the subtitle with $str
961 *
962 * @param string|Message $str New value of the subtitle. String should be safe HTML.
963 */
964 public function setSubtitle( $str ) {
965 $this->clearSubtitle();
966 $this->addSubtitle( $str );
967 }
968
969 /**
970 * Add $str to the subtitle
971 *
972 * @param string|Message $str String or Message to add to the subtitle. String should be safe HTML.
973 */
974 public function addSubtitle( $str ) {
975 if ( $str instanceof Message ) {
976 $this->mSubtitle[] = $str->setContext( $this->getContext() )->parse();
977 } else {
978 $this->mSubtitle[] = $str;
979 }
980 }
981
982 /**
983 * Build message object for a subtitle containing a backlink to a page
984 *
985 * @param Title $title Title to link to
986 * @param array $query Array of additional parameters to include in the link
987 * @return Message
988 * @since 1.25
989 */
990 public static function buildBacklinkSubtitle( Title $title, $query = [] ) {
991 if ( $title->isRedirect() ) {
992 $query['redirect'] = 'no';
993 }
994 return wfMessage( 'backlinksubtitle' )
995 ->rawParams( Linker::link( $title, null, [], $query ) );
996 }
997
998 /**
999 * Add a subtitle containing a backlink to a page
1000 *
1001 * @param Title $title Title to link to
1002 * @param array $query Array of additional parameters to include in the link
1003 */
1004 public function addBacklinkSubtitle( Title $title, $query = [] ) {
1005 $this->addSubtitle( self::buildBacklinkSubtitle( $title, $query ) );
1006 }
1007
1008 /**
1009 * Clear the subtitles
1010 */
1011 public function clearSubtitle() {
1012 $this->mSubtitle = [];
1013 }
1014
1015 /**
1016 * Get the subtitle
1017 *
1018 * @return string
1019 */
1020 public function getSubtitle() {
1021 return implode( "<br />\n\t\t\t\t", $this->mSubtitle );
1022 }
1023
1024 /**
1025 * Set the page as printable, i.e. it'll be displayed with all
1026 * print styles included
1027 */
1028 public function setPrintable() {
1029 $this->mPrintable = true;
1030 }
1031
1032 /**
1033 * Return whether the page is "printable"
1034 *
1035 * @return bool
1036 */
1037 public function isPrintable() {
1038 return $this->mPrintable;
1039 }
1040
1041 /**
1042 * Disable output completely, i.e. calling output() will have no effect
1043 */
1044 public function disable() {
1045 $this->mDoNothing = true;
1046 }
1047
1048 /**
1049 * Return whether the output will be completely disabled
1050 *
1051 * @return bool
1052 */
1053 public function isDisabled() {
1054 return $this->mDoNothing;
1055 }
1056
1057 /**
1058 * Show an "add new section" link?
1059 *
1060 * @return bool
1061 */
1062 public function showNewSectionLink() {
1063 return $this->mNewSectionLink;
1064 }
1065
1066 /**
1067 * Forcibly hide the new section link?
1068 *
1069 * @return bool
1070 */
1071 public function forceHideNewSectionLink() {
1072 return $this->mHideNewSectionLink;
1073 }
1074
1075 /**
1076 * Add or remove feed links in the page header
1077 * This is mainly kept for backward compatibility, see OutputPage::addFeedLink()
1078 * for the new version
1079 * @see addFeedLink()
1080 *
1081 * @param bool $show True: add default feeds, false: remove all feeds
1082 */
1083 public function setSyndicated( $show = true ) {
1084 if ( $show ) {
1085 $this->setFeedAppendQuery( false );
1086 } else {
1087 $this->mFeedLinks = [];
1088 }
1089 }
1090
1091 /**
1092 * Add default feeds to the page header
1093 * This is mainly kept for backward compatibility, see OutputPage::addFeedLink()
1094 * for the new version
1095 * @see addFeedLink()
1096 *
1097 * @param string $val Query to append to feed links or false to output
1098 * default links
1099 */
1100 public function setFeedAppendQuery( $val ) {
1101 $this->mFeedLinks = [];
1102
1103 foreach ( $this->getConfig()->get( 'AdvertisedFeedTypes' ) as $type ) {
1104 $query = "feed=$type";
1105 if ( is_string( $val ) ) {
1106 $query .= '&' . $val;
1107 }
1108 $this->mFeedLinks[$type] = $this->getTitle()->getLocalURL( $query );
1109 }
1110 }
1111
1112 /**
1113 * Add a feed link to the page header
1114 *
1115 * @param string $format Feed type, should be a key of $wgFeedClasses
1116 * @param string $href URL
1117 */
1118 public function addFeedLink( $format, $href ) {
1119 if ( in_array( $format, $this->getConfig()->get( 'AdvertisedFeedTypes' ) ) ) {
1120 $this->mFeedLinks[$format] = $href;
1121 }
1122 }
1123
1124 /**
1125 * Should we output feed links for this page?
1126 * @return bool
1127 */
1128 public function isSyndicated() {
1129 return count( $this->mFeedLinks ) > 0;
1130 }
1131
1132 /**
1133 * Return URLs for each supported syndication format for this page.
1134 * @return array Associating format keys with URLs
1135 */
1136 public function getSyndicationLinks() {
1137 return $this->mFeedLinks;
1138 }
1139
1140 /**
1141 * Will currently always return null
1142 *
1143 * @return null
1144 */
1145 public function getFeedAppendQuery() {
1146 return $this->mFeedLinksAppendQuery;
1147 }
1148
1149 /**
1150 * Set whether the displayed content is related to the source of the
1151 * corresponding article on the wiki
1152 * Setting true will cause the change "article related" toggle to true
1153 *
1154 * @param bool $v
1155 */
1156 public function setArticleFlag( $v ) {
1157 $this->mIsarticle = $v;
1158 if ( $v ) {
1159 $this->mIsArticleRelated = $v;
1160 }
1161 }
1162
1163 /**
1164 * Return whether the content displayed page is related to the source of
1165 * the corresponding article on the wiki
1166 *
1167 * @return bool
1168 */
1169 public function isArticle() {
1170 return $this->mIsarticle;
1171 }
1172
1173 /**
1174 * Set whether this page is related an article on the wiki
1175 * Setting false will cause the change of "article flag" toggle to false
1176 *
1177 * @param bool $v
1178 */
1179 public function setArticleRelated( $v ) {
1180 $this->mIsArticleRelated = $v;
1181 if ( !$v ) {
1182 $this->mIsarticle = false;
1183 }
1184 }
1185
1186 /**
1187 * Return whether this page is related an article on the wiki
1188 *
1189 * @return bool
1190 */
1191 public function isArticleRelated() {
1192 return $this->mIsArticleRelated;
1193 }
1194
1195 /**
1196 * Add new language links
1197 *
1198 * @param array $newLinkArray Associative array mapping language code to the page
1199 * name
1200 */
1201 public function addLanguageLinks( array $newLinkArray ) {
1202 $this->mLanguageLinks += $newLinkArray;
1203 }
1204
1205 /**
1206 * Reset the language links and add new language links
1207 *
1208 * @param array $newLinkArray Associative array mapping language code to the page
1209 * name
1210 */
1211 public function setLanguageLinks( array $newLinkArray ) {
1212 $this->mLanguageLinks = $newLinkArray;
1213 }
1214
1215 /**
1216 * Get the list of language links
1217 *
1218 * @return array Array of Interwiki Prefixed (non DB key) Titles (e.g. 'fr:Test page')
1219 */
1220 public function getLanguageLinks() {
1221 return $this->mLanguageLinks;
1222 }
1223
1224 /**
1225 * Add an array of categories, with names in the keys
1226 *
1227 * @param array $categories Mapping category name => sort key
1228 */
1229 public function addCategoryLinks( array $categories ) {
1230 global $wgContLang;
1231
1232 if ( !is_array( $categories ) || count( $categories ) == 0 ) {
1233 return;
1234 }
1235
1236 # Add the links to a LinkBatch
1237 $arr = [ NS_CATEGORY => $categories ];
1238 $lb = new LinkBatch;
1239 $lb->setArray( $arr );
1240
1241 # Fetch existence plus the hiddencat property
1242 $dbr = wfGetDB( DB_SLAVE );
1243 $fields = array_merge(
1244 LinkCache::getSelectFields(),
1245 [ 'page_namespace', 'page_title', 'pp_value' ]
1246 );
1247
1248 $res = $dbr->select( [ 'page', 'page_props' ],
1249 $fields,
1250 $lb->constructSet( 'page', $dbr ),
1251 __METHOD__,
1252 [],
1253 [ 'page_props' => [ 'LEFT JOIN', [
1254 'pp_propname' => 'hiddencat',
1255 'pp_page = page_id'
1256 ] ] ]
1257 );
1258
1259 # Add the results to the link cache
1260 $lb->addResultToCache( LinkCache::singleton(), $res );
1261
1262 # Set all the values to 'normal'.
1263 $categories = array_fill_keys( array_keys( $categories ), 'normal' );
1264
1265 # Mark hidden categories
1266 foreach ( $res as $row ) {
1267 if ( isset( $row->pp_value ) ) {
1268 $categories[$row->page_title] = 'hidden';
1269 }
1270 }
1271
1272 # Add the remaining categories to the skin
1273 if ( Hooks::run(
1274 'OutputPageMakeCategoryLinks',
1275 [ &$this, $categories, &$this->mCategoryLinks ] )
1276 ) {
1277 foreach ( $categories as $category => $type ) {
1278 // array keys will cast numeric category names to ints, so cast back to string
1279 $category = (string)$category;
1280 $origcategory = $category;
1281 $title = Title::makeTitleSafe( NS_CATEGORY, $category );
1282 if ( !$title ) {
1283 continue;
1284 }
1285 $wgContLang->findVariantLink( $category, $title, true );
1286 if ( $category != $origcategory && array_key_exists( $category, $categories ) ) {
1287 continue;
1288 }
1289 $text = $wgContLang->convertHtml( $title->getText() );
1290 $this->mCategories[] = $title->getText();
1291 $this->mCategoryLinks[$type][] = Linker::link( $title, $text );
1292 }
1293 }
1294 }
1295
1296 /**
1297 * Reset the category links (but not the category list) and add $categories
1298 *
1299 * @param array $categories Mapping category name => sort key
1300 */
1301 public function setCategoryLinks( array $categories ) {
1302 $this->mCategoryLinks = [];
1303 $this->addCategoryLinks( $categories );
1304 }
1305
1306 /**
1307 * Get the list of category links, in a 2-D array with the following format:
1308 * $arr[$type][] = $link, where $type is either "normal" or "hidden" (for
1309 * hidden categories) and $link a HTML fragment with a link to the category
1310 * page
1311 *
1312 * @return array
1313 */
1314 public function getCategoryLinks() {
1315 return $this->mCategoryLinks;
1316 }
1317
1318 /**
1319 * Get the list of category names this page belongs to
1320 *
1321 * @return array Array of strings
1322 */
1323 public function getCategories() {
1324 return $this->mCategories;
1325 }
1326
1327 /**
1328 * Add an array of indicators, with their identifiers as array
1329 * keys and HTML contents as values.
1330 *
1331 * In case of duplicate keys, existing values are overwritten.
1332 *
1333 * @param array $indicators
1334 * @since 1.25
1335 */
1336 public function setIndicators( array $indicators ) {
1337 $this->mIndicators = $indicators + $this->mIndicators;
1338 // Keep ordered by key
1339 ksort( $this->mIndicators );
1340 }
1341
1342 /**
1343 * Get the indicators associated with this page.
1344 *
1345 * The array will be internally ordered by item keys.
1346 *
1347 * @return array Keys: identifiers, values: HTML contents
1348 * @since 1.25
1349 */
1350 public function getIndicators() {
1351 return $this->mIndicators;
1352 }
1353
1354 /**
1355 * Adds help link with an icon via page indicators.
1356 * Link target can be overridden by a local message containing a wikilink:
1357 * the message key is: lowercase action or special page name + '-helppage'.
1358 * @param string $to Target MediaWiki.org page title or encoded URL.
1359 * @param bool $overrideBaseUrl Whether $url is a full URL, to avoid MW.o.
1360 * @since 1.25
1361 */
1362 public function addHelpLink( $to, $overrideBaseUrl = false ) {
1363 $this->addModuleStyles( 'mediawiki.helplink' );
1364 $text = $this->msg( 'helppage-top-gethelp' )->escaped();
1365
1366 if ( $overrideBaseUrl ) {
1367 $helpUrl = $to;
1368 } else {
1369 $toUrlencoded = wfUrlencode( str_replace( ' ', '_', $to ) );
1370 $helpUrl = "//www.mediawiki.org/wiki/Special:MyLanguage/$toUrlencoded";
1371 }
1372
1373 $link = Html::rawElement(
1374 'a',
1375 [
1376 'href' => $helpUrl,
1377 'target' => '_blank',
1378 'class' => 'mw-helplink',
1379 ],
1380 $text
1381 );
1382
1383 $this->setIndicators( [ 'mw-helplink' => $link ] );
1384 }
1385
1386 /**
1387 * Do not allow scripts which can be modified by wiki users to load on this page;
1388 * only allow scripts bundled with, or generated by, the software.
1389 * Site-wide styles are controlled by a config setting, since they can be
1390 * used to create a custom skin/theme, but not user-specific ones.
1391 *
1392 * @todo this should be given a more accurate name
1393 */
1394 public function disallowUserJs() {
1395 $this->reduceAllowedModules(
1396 ResourceLoaderModule::TYPE_SCRIPTS,
1397 ResourceLoaderModule::ORIGIN_CORE_INDIVIDUAL
1398 );
1399
1400 // Site-wide styles are controlled by a config setting, see bug 71621
1401 // for background on why. User styles are never allowed.
1402 if ( $this->getConfig()->get( 'AllowSiteCSSOnRestrictedPages' ) ) {
1403 $styleOrigin = ResourceLoaderModule::ORIGIN_USER_SITEWIDE;
1404 } else {
1405 $styleOrigin = ResourceLoaderModule::ORIGIN_CORE_INDIVIDUAL;
1406 }
1407 $this->reduceAllowedModules(
1408 ResourceLoaderModule::TYPE_STYLES,
1409 $styleOrigin
1410 );
1411 }
1412
1413 /**
1414 * Show what level of JavaScript / CSS untrustworthiness is allowed on this page
1415 * @see ResourceLoaderModule::$origin
1416 * @param string $type ResourceLoaderModule TYPE_ constant
1417 * @return int ResourceLoaderModule ORIGIN_ class constant
1418 */
1419 public function getAllowedModules( $type ) {
1420 if ( $type == ResourceLoaderModule::TYPE_COMBINED ) {
1421 return min( array_values( $this->mAllowedModules ) );
1422 } else {
1423 return isset( $this->mAllowedModules[$type] )
1424 ? $this->mAllowedModules[$type]
1425 : ResourceLoaderModule::ORIGIN_ALL;
1426 }
1427 }
1428
1429 /**
1430 * Limit the highest level of CSS/JS untrustworthiness allowed.
1431 *
1432 * If passed the same or a higher level than the current level of untrustworthiness set, the
1433 * level will remain unchanged.
1434 *
1435 * @param string $type
1436 * @param int $level ResourceLoaderModule class constant
1437 */
1438 public function reduceAllowedModules( $type, $level ) {
1439 $this->mAllowedModules[$type] = min( $this->getAllowedModules( $type ), $level );
1440 }
1441
1442 /**
1443 * Prepend $text to the body HTML
1444 *
1445 * @param string $text HTML
1446 */
1447 public function prependHTML( $text ) {
1448 $this->mBodytext = $text . $this->mBodytext;
1449 }
1450
1451 /**
1452 * Append $text to the body HTML
1453 *
1454 * @param string $text HTML
1455 */
1456 public function addHTML( $text ) {
1457 $this->mBodytext .= $text;
1458 }
1459
1460 /**
1461 * Shortcut for adding an Html::element via addHTML.
1462 *
1463 * @since 1.19
1464 *
1465 * @param string $element
1466 * @param array $attribs
1467 * @param string $contents
1468 */
1469 public function addElement( $element, array $attribs = [], $contents = '' ) {
1470 $this->addHTML( Html::element( $element, $attribs, $contents ) );
1471 }
1472
1473 /**
1474 * Clear the body HTML
1475 */
1476 public function clearHTML() {
1477 $this->mBodytext = '';
1478 }
1479
1480 /**
1481 * Get the body HTML
1482 *
1483 * @return string HTML
1484 */
1485 public function getHTML() {
1486 return $this->mBodytext;
1487 }
1488
1489 /**
1490 * Get/set the ParserOptions object to use for wikitext parsing
1491 *
1492 * @param ParserOptions|null $options Either the ParserOption to use or null to only get the
1493 * current ParserOption object
1494 * @return ParserOptions
1495 */
1496 public function parserOptions( $options = null ) {
1497 if ( $options !== null && !empty( $options->isBogus ) ) {
1498 // Someone is trying to set a bogus pre-$wgUser PO. Check if it has
1499 // been changed somehow, and keep it if so.
1500 $anonPO = ParserOptions::newFromAnon();
1501 $anonPO->setEditSection( false );
1502 if ( !$options->matches( $anonPO ) ) {
1503 wfLogWarning( __METHOD__ . ': Setting a changed bogus ParserOptions: ' . wfGetAllCallers( 5 ) );
1504 $options->isBogus = false;
1505 }
1506 }
1507
1508 if ( !$this->mParserOptions ) {
1509 if ( !$this->getContext()->getUser()->isSafeToLoad() ) {
1510 // $wgUser isn't unstubbable yet, so don't try to get a
1511 // ParserOptions for it. And don't cache this ParserOptions
1512 // either.
1513 $po = ParserOptions::newFromAnon();
1514 $po->setEditSection( false );
1515 $po->isBogus = true;
1516 if ( $options !== null ) {
1517 $this->mParserOptions = empty( $options->isBogus ) ? $options : null;
1518 }
1519 return $po;
1520 }
1521
1522 $this->mParserOptions = ParserOptions::newFromContext( $this->getContext() );
1523 $this->mParserOptions->setEditSection( false );
1524 }
1525
1526 if ( $options !== null && !empty( $options->isBogus ) ) {
1527 // They're trying to restore the bogus pre-$wgUser PO. Do the right
1528 // thing.
1529 return wfSetVar( $this->mParserOptions, null, true );
1530 } else {
1531 return wfSetVar( $this->mParserOptions, $options );
1532 }
1533 }
1534
1535 /**
1536 * Set the revision ID which will be seen by the wiki text parser
1537 * for things such as embedded {{REVISIONID}} variable use.
1538 *
1539 * @param int|null $revid An positive integer, or null
1540 * @return mixed Previous value
1541 */
1542 public function setRevisionId( $revid ) {
1543 $val = is_null( $revid ) ? null : intval( $revid );
1544 return wfSetVar( $this->mRevisionId, $val );
1545 }
1546
1547 /**
1548 * Get the displayed revision ID
1549 *
1550 * @return int
1551 */
1552 public function getRevisionId() {
1553 return $this->mRevisionId;
1554 }
1555
1556 /**
1557 * Set the timestamp of the revision which will be displayed. This is used
1558 * to avoid a extra DB call in Skin::lastModified().
1559 *
1560 * @param string|null $timestamp
1561 * @return mixed Previous value
1562 */
1563 public function setRevisionTimestamp( $timestamp ) {
1564 return wfSetVar( $this->mRevisionTimestamp, $timestamp );
1565 }
1566
1567 /**
1568 * Get the timestamp of displayed revision.
1569 * This will be null if not filled by setRevisionTimestamp().
1570 *
1571 * @return string|null
1572 */
1573 public function getRevisionTimestamp() {
1574 return $this->mRevisionTimestamp;
1575 }
1576
1577 /**
1578 * Set the displayed file version
1579 *
1580 * @param File|bool $file
1581 * @return mixed Previous value
1582 */
1583 public function setFileVersion( $file ) {
1584 $val = null;
1585 if ( $file instanceof File && $file->exists() ) {
1586 $val = [ 'time' => $file->getTimestamp(), 'sha1' => $file->getSha1() ];
1587 }
1588 return wfSetVar( $this->mFileVersion, $val, true );
1589 }
1590
1591 /**
1592 * Get the displayed file version
1593 *
1594 * @return array|null ('time' => MW timestamp, 'sha1' => sha1)
1595 */
1596 public function getFileVersion() {
1597 return $this->mFileVersion;
1598 }
1599
1600 /**
1601 * Get the templates used on this page
1602 *
1603 * @return array (namespace => dbKey => revId)
1604 * @since 1.18
1605 */
1606 public function getTemplateIds() {
1607 return $this->mTemplateIds;
1608 }
1609
1610 /**
1611 * Get the files used on this page
1612 *
1613 * @return array (dbKey => array('time' => MW timestamp or null, 'sha1' => sha1 or ''))
1614 * @since 1.18
1615 */
1616 public function getFileSearchOptions() {
1617 return $this->mImageTimeKeys;
1618 }
1619
1620 /**
1621 * Convert wikitext to HTML and add it to the buffer
1622 * Default assumes that the current page title will be used.
1623 *
1624 * @param string $text
1625 * @param bool $linestart Is this the start of a line?
1626 * @param bool $interface Is this text in the user interface language?
1627 * @throws MWException
1628 */
1629 public function addWikiText( $text, $linestart = true, $interface = true ) {
1630 $title = $this->getTitle(); // Work around E_STRICT
1631 if ( !$title ) {
1632 throw new MWException( 'Title is null' );
1633 }
1634 $this->addWikiTextTitle( $text, $title, $linestart, /*tidy*/false, $interface );
1635 }
1636
1637 /**
1638 * Add wikitext with a custom Title object
1639 *
1640 * @param string $text Wikitext
1641 * @param Title $title
1642 * @param bool $linestart Is this the start of a line?
1643 */
1644 public function addWikiTextWithTitle( $text, &$title, $linestart = true ) {
1645 $this->addWikiTextTitle( $text, $title, $linestart );
1646 }
1647
1648 /**
1649 * Add wikitext with a custom Title object and tidy enabled.
1650 *
1651 * @param string $text Wikitext
1652 * @param Title $title
1653 * @param bool $linestart Is this the start of a line?
1654 */
1655 function addWikiTextTitleTidy( $text, &$title, $linestart = true ) {
1656 $this->addWikiTextTitle( $text, $title, $linestart, true );
1657 }
1658
1659 /**
1660 * Add wikitext with tidy enabled
1661 *
1662 * @param string $text Wikitext
1663 * @param bool $linestart Is this the start of a line?
1664 */
1665 public function addWikiTextTidy( $text, $linestart = true ) {
1666 $title = $this->getTitle();
1667 $this->addWikiTextTitleTidy( $text, $title, $linestart );
1668 }
1669
1670 /**
1671 * Add wikitext with a custom Title object
1672 *
1673 * @param string $text Wikitext
1674 * @param Title $title
1675 * @param bool $linestart Is this the start of a line?
1676 * @param bool $tidy Whether to use tidy
1677 * @param bool $interface Whether it is an interface message
1678 * (for example disables conversion)
1679 */
1680 public function addWikiTextTitle( $text, Title $title, $linestart,
1681 $tidy = false, $interface = false
1682 ) {
1683 global $wgParser;
1684
1685 $popts = $this->parserOptions();
1686 $oldTidy = $popts->setTidy( $tidy );
1687 $popts->setInterfaceMessage( (bool)$interface );
1688
1689 $parserOutput = $wgParser->getFreshParser()->parse(
1690 $text, $title, $popts,
1691 $linestart, true, $this->mRevisionId
1692 );
1693
1694 $popts->setTidy( $oldTidy );
1695
1696 $this->addParserOutput( $parserOutput );
1697
1698 }
1699
1700 /**
1701 * Add a ParserOutput object, but without Html.
1702 *
1703 * @deprecated since 1.24, use addParserOutputMetadata() instead.
1704 * @param ParserOutput $parserOutput
1705 */
1706 public function addParserOutputNoText( $parserOutput ) {
1707 wfDeprecated( __METHOD__, '1.24' );
1708 $this->addParserOutputMetadata( $parserOutput );
1709 }
1710
1711 /**
1712 * Add all metadata associated with a ParserOutput object, but without the actual HTML. This
1713 * includes categories, language links, ResourceLoader modules, effects of certain magic words,
1714 * and so on.
1715 *
1716 * @since 1.24
1717 * @param ParserOutput $parserOutput
1718 */
1719 public function addParserOutputMetadata( $parserOutput ) {
1720 $this->mLanguageLinks += $parserOutput->getLanguageLinks();
1721 $this->addCategoryLinks( $parserOutput->getCategories() );
1722 $this->setIndicators( $parserOutput->getIndicators() );
1723 $this->mNewSectionLink = $parserOutput->getNewSection();
1724 $this->mHideNewSectionLink = $parserOutput->getHideNewSection();
1725
1726 if ( !$parserOutput->isCacheable() ) {
1727 $this->enableClientCache( false );
1728 }
1729 $this->mNoGallery = $parserOutput->getNoGallery();
1730 $this->mHeadItems = array_merge( $this->mHeadItems, $parserOutput->getHeadItems() );
1731 $this->addModules( $parserOutput->getModules() );
1732 $this->addModuleScripts( $parserOutput->getModuleScripts() );
1733 $this->addModuleStyles( $parserOutput->getModuleStyles() );
1734 $this->addJsConfigVars( $parserOutput->getJsConfigVars() );
1735 $this->mPreventClickjacking = $this->mPreventClickjacking
1736 || $parserOutput->preventClickjacking();
1737
1738 // Template versioning...
1739 foreach ( (array)$parserOutput->getTemplateIds() as $ns => $dbks ) {
1740 if ( isset( $this->mTemplateIds[$ns] ) ) {
1741 $this->mTemplateIds[$ns] = $dbks + $this->mTemplateIds[$ns];
1742 } else {
1743 $this->mTemplateIds[$ns] = $dbks;
1744 }
1745 }
1746 // File versioning...
1747 foreach ( (array)$parserOutput->getFileSearchOptions() as $dbk => $data ) {
1748 $this->mImageTimeKeys[$dbk] = $data;
1749 }
1750
1751 // Hooks registered in the object
1752 $parserOutputHooks = $this->getConfig()->get( 'ParserOutputHooks' );
1753 foreach ( $parserOutput->getOutputHooks() as $hookInfo ) {
1754 list( $hookName, $data ) = $hookInfo;
1755 if ( isset( $parserOutputHooks[$hookName] ) ) {
1756 call_user_func( $parserOutputHooks[$hookName], $this, $parserOutput, $data );
1757 }
1758 }
1759
1760 // Enable OOUI if requested via ParserOutput
1761 if ( $parserOutput->getEnableOOUI() ) {
1762 $this->enableOOUI();
1763 }
1764
1765 // Include profiling data
1766 $this->limitReportData = $parserOutput->getLimitReportData();
1767
1768 // Link flags are ignored for now, but may in the future be
1769 // used to mark individual language links.
1770 $linkFlags = [];
1771 Hooks::run( 'LanguageLinks', [ $this->getTitle(), &$this->mLanguageLinks, &$linkFlags ] );
1772 Hooks::run( 'OutputPageParserOutput', [ &$this, $parserOutput ] );
1773 }
1774
1775 /**
1776 * Add the HTML and enhancements for it (like ResourceLoader modules) associated with a
1777 * ParserOutput object, without any other metadata.
1778 *
1779 * @since 1.24
1780 * @param ParserOutput $parserOutput
1781 */
1782 public function addParserOutputContent( $parserOutput ) {
1783 $this->addParserOutputText( $parserOutput );
1784
1785 $this->addModules( $parserOutput->getModules() );
1786 $this->addModuleScripts( $parserOutput->getModuleScripts() );
1787 $this->addModuleStyles( $parserOutput->getModuleStyles() );
1788
1789 $this->addJsConfigVars( $parserOutput->getJsConfigVars() );
1790 }
1791
1792 /**
1793 * Add the HTML associated with a ParserOutput object, without any metadata.
1794 *
1795 * @since 1.24
1796 * @param ParserOutput $parserOutput
1797 */
1798 public function addParserOutputText( $parserOutput ) {
1799 $text = $parserOutput->getText();
1800 Hooks::run( 'OutputPageBeforeHTML', [ &$this, &$text ] );
1801 $this->addHTML( $text );
1802 }
1803
1804 /**
1805 * Add everything from a ParserOutput object.
1806 *
1807 * @param ParserOutput $parserOutput
1808 */
1809 function addParserOutput( $parserOutput ) {
1810 $this->addParserOutputMetadata( $parserOutput );
1811 $parserOutput->setTOCEnabled( $this->mEnableTOC );
1812
1813 // Touch section edit links only if not previously disabled
1814 if ( $parserOutput->getEditSectionTokens() ) {
1815 $parserOutput->setEditSectionTokens( $this->mEnableSectionEditLinks );
1816 }
1817
1818 $this->addParserOutputText( $parserOutput );
1819 }
1820
1821 /**
1822 * Add the output of a QuickTemplate to the output buffer
1823 *
1824 * @param QuickTemplate $template
1825 */
1826 public function addTemplate( &$template ) {
1827 $this->addHTML( $template->getHTML() );
1828 }
1829
1830 /**
1831 * Parse wikitext and return the HTML.
1832 *
1833 * @param string $text
1834 * @param bool $linestart Is this the start of a line?
1835 * @param bool $interface Use interface language ($wgLang instead of
1836 * $wgContLang) while parsing language sensitive magic words like GRAMMAR and PLURAL.
1837 * This also disables LanguageConverter.
1838 * @param Language $language Target language object, will override $interface
1839 * @throws MWException
1840 * @return string HTML
1841 */
1842 public function parse( $text, $linestart = true, $interface = false, $language = null ) {
1843 global $wgParser;
1844
1845 if ( is_null( $this->getTitle() ) ) {
1846 throw new MWException( 'Empty $mTitle in ' . __METHOD__ );
1847 }
1848
1849 $popts = $this->parserOptions();
1850 if ( $interface ) {
1851 $popts->setInterfaceMessage( true );
1852 }
1853 if ( $language !== null ) {
1854 $oldLang = $popts->setTargetLanguage( $language );
1855 }
1856
1857 $parserOutput = $wgParser->getFreshParser()->parse(
1858 $text, $this->getTitle(), $popts,
1859 $linestart, true, $this->mRevisionId
1860 );
1861
1862 if ( $interface ) {
1863 $popts->setInterfaceMessage( false );
1864 }
1865 if ( $language !== null ) {
1866 $popts->setTargetLanguage( $oldLang );
1867 }
1868
1869 return $parserOutput->getText();
1870 }
1871
1872 /**
1873 * Parse wikitext, strip paragraphs, and return the HTML.
1874 *
1875 * @param string $text
1876 * @param bool $linestart Is this the start of a line?
1877 * @param bool $interface Use interface language ($wgLang instead of
1878 * $wgContLang) while parsing language sensitive magic
1879 * words like GRAMMAR and PLURAL
1880 * @return string HTML
1881 */
1882 public function parseInline( $text, $linestart = true, $interface = false ) {
1883 $parsed = $this->parse( $text, $linestart, $interface );
1884 return Parser::stripOuterParagraph( $parsed );
1885 }
1886
1887 /**
1888 * @param $maxage
1889 * @deprecated since 1.27 Use setCdnMaxage() instead
1890 */
1891 public function setSquidMaxage( $maxage ) {
1892 $this->setCdnMaxage( $maxage );
1893 }
1894
1895 /**
1896 * Set the value of the "s-maxage" part of the "Cache-control" HTTP header
1897 *
1898 * @param int $maxage Maximum cache time on the CDN, in seconds.
1899 */
1900 public function setCdnMaxage( $maxage ) {
1901 $this->mCdnMaxage = min( $maxage, $this->mCdnMaxageLimit );
1902 }
1903
1904 /**
1905 * Lower the value of the "s-maxage" part of the "Cache-control" HTTP header
1906 *
1907 * @param int $maxage Maximum cache time on the CDN, in seconds
1908 * @since 1.27
1909 */
1910 public function lowerCdnMaxage( $maxage ) {
1911 $this->mCdnMaxageLimit = min( $maxage, $this->mCdnMaxageLimit );
1912 $this->setCdnMaxage( $this->mCdnMaxage );
1913 }
1914
1915 /**
1916 * Use enableClientCache(false) to force it to send nocache headers
1917 *
1918 * @param bool $state
1919 *
1920 * @return bool
1921 */
1922 public function enableClientCache( $state ) {
1923 return wfSetVar( $this->mEnableClientCache, $state );
1924 }
1925
1926 /**
1927 * Get the list of cookies that will influence on the cache
1928 *
1929 * @return array
1930 */
1931 function getCacheVaryCookies() {
1932 static $cookies;
1933 if ( $cookies === null ) {
1934 $config = $this->getConfig();
1935 $cookies = array_merge(
1936 SessionManager::singleton()->getVaryCookies(),
1937 [
1938 'forceHTTPS',
1939 ],
1940 $config->get( 'CacheVaryCookies' )
1941 );
1942 Hooks::run( 'GetCacheVaryCookies', [ $this, &$cookies ] );
1943 }
1944 return $cookies;
1945 }
1946
1947 /**
1948 * Check if the request has a cache-varying cookie header
1949 * If it does, it's very important that we don't allow public caching
1950 *
1951 * @return bool
1952 */
1953 function haveCacheVaryCookies() {
1954 $request = $this->getRequest();
1955 foreach ( $this->getCacheVaryCookies() as $cookieName ) {
1956 if ( $request->getCookie( $cookieName, '', '' ) !== '' ) {
1957 wfDebug( __METHOD__ . ": found $cookieName\n" );
1958 return true;
1959 }
1960 }
1961 wfDebug( __METHOD__ . ": no cache-varying cookies found\n" );
1962 return false;
1963 }
1964
1965 /**
1966 * Add an HTTP header that will influence on the cache
1967 *
1968 * @param string $header Header name
1969 * @param string[]|null $option Options for the Key header. See
1970 * https://datatracker.ietf.org/doc/draft-fielding-http-key/
1971 * for the list of valid options.
1972 */
1973 public function addVaryHeader( $header, array $option = null ) {
1974 if ( !array_key_exists( $header, $this->mVaryHeader ) ) {
1975 $this->mVaryHeader[$header] = [];
1976 }
1977 if ( !is_array( $option ) ) {
1978 $option = [];
1979 }
1980 $this->mVaryHeader[$header] = array_unique( array_merge( $this->mVaryHeader[$header], $option ) );
1981 }
1982
1983 /**
1984 * Return a Vary: header on which to vary caches. Based on the keys of $mVaryHeader,
1985 * such as Accept-Encoding or Cookie
1986 *
1987 * @return string
1988 */
1989 public function getVaryHeader() {
1990 // If we vary on cookies, let's make sure it's always included here too.
1991 if ( $this->getCacheVaryCookies() ) {
1992 $this->addVaryHeader( 'Cookie' );
1993 }
1994
1995 foreach ( SessionManager::singleton()->getVaryHeaders() as $header => $options ) {
1996 $this->addVaryHeader( $header, $options );
1997 }
1998 return 'Vary: ' . implode( ', ', array_keys( $this->mVaryHeader ) );
1999 }
2000
2001 /**
2002 * Get a complete Key header
2003 *
2004 * @return string
2005 */
2006 public function getKeyHeader() {
2007 $cvCookies = $this->getCacheVaryCookies();
2008
2009 $cookiesOption = [];
2010 foreach ( $cvCookies as $cookieName ) {
2011 $cookiesOption[] = 'param=' . $cookieName;
2012 }
2013 $this->addVaryHeader( 'Cookie', $cookiesOption );
2014
2015 foreach ( SessionManager::singleton()->getVaryHeaders() as $header => $options ) {
2016 $this->addVaryHeader( $header, $options );
2017 }
2018
2019 $headers = [];
2020 foreach ( $this->mVaryHeader as $header => $option ) {
2021 $newheader = $header;
2022 if ( is_array( $option ) && count( $option ) > 0 ) {
2023 $newheader .= ';' . implode( ';', $option );
2024 }
2025 $headers[] = $newheader;
2026 }
2027 $key = 'Key: ' . implode( ',', $headers );
2028
2029 return $key;
2030 }
2031
2032 /**
2033 * T23672: Add Accept-Language to Vary and Key headers
2034 * if there's no 'variant' parameter existed in GET.
2035 *
2036 * For example:
2037 * /w/index.php?title=Main_page should always be served; but
2038 * /w/index.php?title=Main_page&variant=zh-cn should never be served.
2039 */
2040 function addAcceptLanguage() {
2041 $title = $this->getTitle();
2042 if ( !$title instanceof Title ) {
2043 return;
2044 }
2045
2046 $lang = $title->getPageLanguage();
2047 if ( !$this->getRequest()->getCheck( 'variant' ) && $lang->hasVariants() ) {
2048 $variants = $lang->getVariants();
2049 $aloption = [];
2050 foreach ( $variants as $variant ) {
2051 if ( $variant === $lang->getCode() ) {
2052 continue;
2053 } else {
2054 $aloption[] = 'substr=' . $variant;
2055
2056 // IE and some other browsers use BCP 47 standards in
2057 // their Accept-Language header, like "zh-CN" or "zh-Hant".
2058 // We should handle these too.
2059 $variantBCP47 = wfBCP47( $variant );
2060 if ( $variantBCP47 !== $variant ) {
2061 $aloption[] = 'substr=' . $variantBCP47;
2062 }
2063 }
2064 }
2065 $this->addVaryHeader( 'Accept-Language', $aloption );
2066 }
2067 }
2068
2069 /**
2070 * Set a flag which will cause an X-Frame-Options header appropriate for
2071 * edit pages to be sent. The header value is controlled by
2072 * $wgEditPageFrameOptions.
2073 *
2074 * This is the default for special pages. If you display a CSRF-protected
2075 * form on an ordinary view page, then you need to call this function.
2076 *
2077 * @param bool $enable
2078 */
2079 public function preventClickjacking( $enable = true ) {
2080 $this->mPreventClickjacking = $enable;
2081 }
2082
2083 /**
2084 * Turn off frame-breaking. Alias for $this->preventClickjacking(false).
2085 * This can be called from pages which do not contain any CSRF-protected
2086 * HTML form.
2087 */
2088 public function allowClickjacking() {
2089 $this->mPreventClickjacking = false;
2090 }
2091
2092 /**
2093 * Get the prevent-clickjacking flag
2094 *
2095 * @since 1.24
2096 * @return bool
2097 */
2098 public function getPreventClickjacking() {
2099 return $this->mPreventClickjacking;
2100 }
2101
2102 /**
2103 * Get the X-Frame-Options header value (without the name part), or false
2104 * if there isn't one. This is used by Skin to determine whether to enable
2105 * JavaScript frame-breaking, for clients that don't support X-Frame-Options.
2106 *
2107 * @return string
2108 */
2109 public function getFrameOptions() {
2110 $config = $this->getConfig();
2111 if ( $config->get( 'BreakFrames' ) ) {
2112 return 'DENY';
2113 } elseif ( $this->mPreventClickjacking && $config->get( 'EditPageFrameOptions' ) ) {
2114 return $config->get( 'EditPageFrameOptions' );
2115 }
2116 return false;
2117 }
2118
2119 /**
2120 * Send cache control HTTP headers
2121 */
2122 public function sendCacheControl() {
2123 $response = $this->getRequest()->response();
2124 $config = $this->getConfig();
2125
2126 $this->addVaryHeader( 'Cookie' );
2127 $this->addAcceptLanguage();
2128
2129 # don't serve compressed data to clients who can't handle it
2130 # maintain different caches for logged-in users and non-logged in ones
2131 $response->header( $this->getVaryHeader() );
2132
2133 if ( $config->get( 'UseKeyHeader' ) ) {
2134 $response->header( $this->getKeyHeader() );
2135 }
2136
2137 if ( $this->mEnableClientCache ) {
2138 if (
2139 $config->get( 'UseSquid' ) &&
2140 !$response->hasCookies() &&
2141 !SessionManager::getGlobalSession()->isPersistent() &&
2142 !$this->isPrintable() &&
2143 $this->mCdnMaxage != 0 &&
2144 !$this->haveCacheVaryCookies()
2145 ) {
2146 if ( $config->get( 'UseESI' ) ) {
2147 # We'll purge the proxy cache explicitly, but require end user agents
2148 # to revalidate against the proxy on each visit.
2149 # Surrogate-Control controls our CDN, Cache-Control downstream caches
2150 wfDebug( __METHOD__ . ": proxy caching with ESI; {$this->mLastModified} **", 'private' );
2151 # start with a shorter timeout for initial testing
2152 # header( 'Surrogate-Control: max-age=2678400+2678400, content="ESI/1.0"');
2153 $response->header( 'Surrogate-Control: max-age=' . $config->get( 'SquidMaxage' )
2154 . '+' . $this->mCdnMaxage . ', content="ESI/1.0"' );
2155 $response->header( 'Cache-Control: s-maxage=0, must-revalidate, max-age=0' );
2156 } else {
2157 # We'll purge the proxy cache for anons explicitly, but require end user agents
2158 # to revalidate against the proxy on each visit.
2159 # IMPORTANT! The CDN needs to replace the Cache-Control header with
2160 # Cache-Control: s-maxage=0, must-revalidate, max-age=0
2161 wfDebug( __METHOD__ . ": local proxy caching; {$this->mLastModified} **", 'private' );
2162 # start with a shorter timeout for initial testing
2163 # header( "Cache-Control: s-maxage=2678400, must-revalidate, max-age=0" );
2164 $response->header( 'Cache-Control: s-maxage=' . $this->mCdnMaxage
2165 . ', must-revalidate, max-age=0' );
2166 }
2167 } else {
2168 # We do want clients to cache if they can, but they *must* check for updates
2169 # on revisiting the page.
2170 wfDebug( __METHOD__ . ": private caching; {$this->mLastModified} **", 'private' );
2171 $response->header( 'Expires: ' . gmdate( 'D, d M Y H:i:s', 0 ) . ' GMT' );
2172 $response->header( "Cache-Control: private, must-revalidate, max-age=0" );
2173 }
2174 if ( $this->mLastModified ) {
2175 $response->header( "Last-Modified: {$this->mLastModified}" );
2176 }
2177 } else {
2178 wfDebug( __METHOD__ . ": no caching **", 'private' );
2179
2180 # In general, the absence of a last modified header should be enough to prevent
2181 # the client from using its cache. We send a few other things just to make sure.
2182 $response->header( 'Expires: ' . gmdate( 'D, d M Y H:i:s', 0 ) . ' GMT' );
2183 $response->header( 'Cache-Control: no-cache, no-store, max-age=0, must-revalidate' );
2184 $response->header( 'Pragma: no-cache' );
2185 }
2186 }
2187
2188 /**
2189 * Finally, all the text has been munged and accumulated into
2190 * the object, let's actually output it:
2191 */
2192 public function output() {
2193 if ( $this->mDoNothing ) {
2194 return;
2195 }
2196
2197 $response = $this->getRequest()->response();
2198 $config = $this->getConfig();
2199
2200 if ( $this->mRedirect != '' ) {
2201 # Standards require redirect URLs to be absolute
2202 $this->mRedirect = wfExpandUrl( $this->mRedirect, PROTO_CURRENT );
2203
2204 $redirect = $this->mRedirect;
2205 $code = $this->mRedirectCode;
2206
2207 if ( Hooks::run( "BeforePageRedirect", [ $this, &$redirect, &$code ] ) ) {
2208 if ( $code == '301' || $code == '303' ) {
2209 if ( !$config->get( 'DebugRedirects' ) ) {
2210 $response->statusHeader( $code );
2211 }
2212 $this->mLastModified = wfTimestamp( TS_RFC2822 );
2213 }
2214 if ( $config->get( 'VaryOnXFP' ) ) {
2215 $this->addVaryHeader( 'X-Forwarded-Proto' );
2216 }
2217 $this->sendCacheControl();
2218
2219 $response->header( "Content-Type: text/html; charset=utf-8" );
2220 if ( $config->get( 'DebugRedirects' ) ) {
2221 $url = htmlspecialchars( $redirect );
2222 print "<html>\n<head>\n<title>Redirect</title>\n</head>\n<body>\n";
2223 print "<p>Location: <a href=\"$url\">$url</a></p>\n";
2224 print "</body>\n</html>\n";
2225 } else {
2226 $response->header( 'Location: ' . $redirect );
2227 }
2228 }
2229
2230 return;
2231 } elseif ( $this->mStatusCode ) {
2232 $response->statusHeader( $this->mStatusCode );
2233 }
2234
2235 # Buffer output; final headers may depend on later processing
2236 ob_start();
2237
2238 $response->header( 'Content-type: ' . $config->get( 'MimeType' ) . '; charset=UTF-8' );
2239 $response->header( 'Content-language: ' . $config->get( 'LanguageCode' ) );
2240
2241 // Avoid Internet Explorer "compatibility view" in IE 8-10, so that
2242 // jQuery etc. can work correctly.
2243 $response->header( 'X-UA-Compatible: IE=Edge' );
2244
2245 // Prevent framing, if requested
2246 $frameOptions = $this->getFrameOptions();
2247 if ( $frameOptions ) {
2248 $response->header( "X-Frame-Options: $frameOptions" );
2249 }
2250
2251 if ( $this->mArticleBodyOnly ) {
2252 echo $this->mBodytext;
2253 } else {
2254 $sk = $this->getSkin();
2255 // add skin specific modules
2256 $modules = $sk->getDefaultModules();
2257
2258 // Enforce various default modules for all skins
2259 $coreModules = [
2260 // Keep this list as small as possible
2261 'site',
2262 'mediawiki.page.startup',
2263 'mediawiki.user',
2264 ];
2265
2266 // Support for high-density display images if enabled
2267 if ( $config->get( 'ResponsiveImages' ) ) {
2268 $coreModules[] = 'mediawiki.hidpi';
2269 }
2270
2271 $this->addModules( $coreModules );
2272 foreach ( $modules as $group ) {
2273 $this->addModules( $group );
2274 }
2275 MWDebug::addModules( $this );
2276
2277 // Hook that allows last minute changes to the output page, e.g.
2278 // adding of CSS or Javascript by extensions.
2279 Hooks::run( 'BeforePageDisplay', [ &$this, &$sk ] );
2280
2281 try {
2282 $sk->outputPage();
2283 } catch ( Exception $e ) {
2284 ob_end_clean(); // bug T129657
2285 throw $e;
2286 }
2287 }
2288
2289 try {
2290 // This hook allows last minute changes to final overall output by modifying output buffer
2291 Hooks::run( 'AfterFinalPageOutput', [ $this ] );
2292 } catch ( Exception $e ) {
2293 ob_end_clean(); // bug T129657
2294 throw $e;
2295 }
2296
2297 $this->sendCacheControl();
2298
2299 ob_end_flush();
2300
2301 }
2302
2303 /**
2304 * Prepare this object to display an error page; disable caching and
2305 * indexing, clear the current text and redirect, set the page's title
2306 * and optionally an custom HTML title (content of the "<title>" tag).
2307 *
2308 * @param string|Message $pageTitle Will be passed directly to setPageTitle()
2309 * @param string|Message $htmlTitle Will be passed directly to setHTMLTitle();
2310 * optional, if not passed the "<title>" attribute will be
2311 * based on $pageTitle
2312 */
2313 public function prepareErrorPage( $pageTitle, $htmlTitle = false ) {
2314 $this->setPageTitle( $pageTitle );
2315 if ( $htmlTitle !== false ) {
2316 $this->setHTMLTitle( $htmlTitle );
2317 }
2318 $this->setRobotPolicy( 'noindex,nofollow' );
2319 $this->setArticleRelated( false );
2320 $this->enableClientCache( false );
2321 $this->mRedirect = '';
2322 $this->clearSubtitle();
2323 $this->clearHTML();
2324 }
2325
2326 /**
2327 * Output a standard error page
2328 *
2329 * showErrorPage( 'titlemsg', 'pagetextmsg' );
2330 * showErrorPage( 'titlemsg', 'pagetextmsg', array( 'param1', 'param2' ) );
2331 * showErrorPage( 'titlemsg', $messageObject );
2332 * showErrorPage( $titleMessageObject, $messageObject );
2333 *
2334 * @param string|Message $title Message key (string) for page title, or a Message object
2335 * @param string|Message $msg Message key (string) for page text, or a Message object
2336 * @param array $params Message parameters; ignored if $msg is a Message object
2337 */
2338 public function showErrorPage( $title, $msg, $params = [] ) {
2339 if ( !$title instanceof Message ) {
2340 $title = $this->msg( $title );
2341 }
2342
2343 $this->prepareErrorPage( $title );
2344
2345 if ( $msg instanceof Message ) {
2346 if ( $params !== [] ) {
2347 trigger_error( 'Argument ignored: $params. The message parameters argument '
2348 . 'is discarded when the $msg argument is a Message object instead of '
2349 . 'a string.', E_USER_NOTICE );
2350 }
2351 $this->addHTML( $msg->parseAsBlock() );
2352 } else {
2353 $this->addWikiMsgArray( $msg, $params );
2354 }
2355
2356 $this->returnToMain();
2357 }
2358
2359 /**
2360 * Output a standard permission error page
2361 *
2362 * @param array $errors Error message keys
2363 * @param string $action Action that was denied or null if unknown
2364 */
2365 public function showPermissionsErrorPage( array $errors, $action = null ) {
2366 // For some action (read, edit, create and upload), display a "login to do this action"
2367 // error if all of the following conditions are met:
2368 // 1. the user is not logged in
2369 // 2. the only error is insufficient permissions (i.e. no block or something else)
2370 // 3. the error can be avoided simply by logging in
2371 if ( in_array( $action, [ 'read', 'edit', 'createpage', 'createtalk', 'upload' ] )
2372 && $this->getUser()->isAnon() && count( $errors ) == 1 && isset( $errors[0][0] )
2373 && ( $errors[0][0] == 'badaccess-groups' || $errors[0][0] == 'badaccess-group0' )
2374 && ( User::groupHasPermission( 'user', $action )
2375 || User::groupHasPermission( 'autoconfirmed', $action ) )
2376 ) {
2377 $displayReturnto = null;
2378
2379 # Due to bug 32276, if a user does not have read permissions,
2380 # $this->getTitle() will just give Special:Badtitle, which is
2381 # not especially useful as a returnto parameter. Use the title
2382 # from the request instead, if there was one.
2383 $request = $this->getRequest();
2384 $returnto = Title::newFromText( $request->getVal( 'title', '' ) );
2385 if ( $action == 'edit' ) {
2386 $msg = 'whitelistedittext';
2387 $displayReturnto = $returnto;
2388 } elseif ( $action == 'createpage' || $action == 'createtalk' ) {
2389 $msg = 'nocreatetext';
2390 } elseif ( $action == 'upload' ) {
2391 $msg = 'uploadnologintext';
2392 } else { # Read
2393 $msg = 'loginreqpagetext';
2394 $displayReturnto = Title::newMainPage();
2395 }
2396
2397 $query = [];
2398
2399 if ( $returnto ) {
2400 $query['returnto'] = $returnto->getPrefixedText();
2401
2402 if ( !$request->wasPosted() ) {
2403 $returntoquery = $request->getValues();
2404 unset( $returntoquery['title'] );
2405 unset( $returntoquery['returnto'] );
2406 unset( $returntoquery['returntoquery'] );
2407 $query['returntoquery'] = wfArrayToCgi( $returntoquery );
2408 }
2409 }
2410 $loginLink = Linker::linkKnown(
2411 SpecialPage::getTitleFor( 'Userlogin' ),
2412 $this->msg( 'loginreqlink' )->escaped(),
2413 [],
2414 $query
2415 );
2416
2417 $this->prepareErrorPage( $this->msg( 'loginreqtitle' ) );
2418 $this->addHTML( $this->msg( $msg )->rawParams( $loginLink )->parse() );
2419
2420 # Don't return to a page the user can't read otherwise
2421 # we'll end up in a pointless loop
2422 if ( $displayReturnto && $displayReturnto->userCan( 'read', $this->getUser() ) ) {
2423 $this->returnToMain( null, $displayReturnto );
2424 }
2425 } else {
2426 $this->prepareErrorPage( $this->msg( 'permissionserrors' ) );
2427 $this->addWikiText( $this->formatPermissionsErrorMessage( $errors, $action ) );
2428 }
2429 }
2430
2431 /**
2432 * Display an error page indicating that a given version of MediaWiki is
2433 * required to use it
2434 *
2435 * @param mixed $version The version of MediaWiki needed to use the page
2436 */
2437 public function versionRequired( $version ) {
2438 $this->prepareErrorPage( $this->msg( 'versionrequired', $version ) );
2439
2440 $this->addWikiMsg( 'versionrequiredtext', $version );
2441 $this->returnToMain();
2442 }
2443
2444 /**
2445 * Format a list of error messages
2446 *
2447 * @param array $errors Array of arrays returned by Title::getUserPermissionsErrors
2448 * @param string $action Action that was denied or null if unknown
2449 * @return string The wikitext error-messages, formatted into a list.
2450 */
2451 public function formatPermissionsErrorMessage( array $errors, $action = null ) {
2452 if ( $action == null ) {
2453 $text = $this->msg( 'permissionserrorstext', count( $errors ) )->plain() . "\n\n";
2454 } else {
2455 $action_desc = $this->msg( "action-$action" )->plain();
2456 $text = $this->msg(
2457 'permissionserrorstext-withaction',
2458 count( $errors ),
2459 $action_desc
2460 )->plain() . "\n\n";
2461 }
2462
2463 if ( count( $errors ) > 1 ) {
2464 $text .= '<ul class="permissions-errors">' . "\n";
2465
2466 foreach ( $errors as $error ) {
2467 $text .= '<li>';
2468 $text .= call_user_func_array( [ $this, 'msg' ], $error )->plain();
2469 $text .= "</li>\n";
2470 }
2471 $text .= '</ul>';
2472 } else {
2473 $text .= "<div class=\"permissions-errors\">\n" .
2474 call_user_func_array( [ $this, 'msg' ], reset( $errors ) )->plain() .
2475 "\n</div>";
2476 }
2477
2478 return $text;
2479 }
2480
2481 /**
2482 * Display a page stating that the Wiki is in read-only mode.
2483 * Should only be called after wfReadOnly() has returned true.
2484 *
2485 * Historically, this function was used to show the source of the page that the user
2486 * was trying to edit and _also_ permissions error messages. The relevant code was
2487 * moved into EditPage in 1.19 (r102024 / d83c2a431c2a) and removed here in 1.25.
2488 *
2489 * @deprecated since 1.25; throw the exception directly
2490 * @throws ReadOnlyError
2491 */
2492 public function readOnlyPage() {
2493 if ( func_num_args() > 0 ) {
2494 throw new MWException( __METHOD__ . ' no longer accepts arguments since 1.25.' );
2495 }
2496
2497 throw new ReadOnlyError;
2498 }
2499
2500 /**
2501 * Turn off regular page output and return an error response
2502 * for when rate limiting has triggered.
2503 *
2504 * @deprecated since 1.25; throw the exception directly
2505 */
2506 public function rateLimited() {
2507 wfDeprecated( __METHOD__, '1.25' );
2508 throw new ThrottledError;
2509 }
2510
2511 /**
2512 * Show a warning about slave lag
2513 *
2514 * If the lag is higher than $wgSlaveLagCritical seconds,
2515 * then the warning is a bit more obvious. If the lag is
2516 * lower than $wgSlaveLagWarning, then no warning is shown.
2517 *
2518 * @param int $lag Slave lag
2519 */
2520 public function showLagWarning( $lag ) {
2521 $config = $this->getConfig();
2522 if ( $lag >= $config->get( 'SlaveLagWarning' ) ) {
2523 $message = $lag < $config->get( 'SlaveLagCritical' )
2524 ? 'lag-warn-normal'
2525 : 'lag-warn-high';
2526 $wrap = Html::rawElement( 'div', [ 'class' => "mw-{$message}" ], "\n$1\n" );
2527 $this->wrapWikiMsg( "$wrap\n", [ $message, $this->getLanguage()->formatNum( $lag ) ] );
2528 }
2529 }
2530
2531 public function showFatalError( $message ) {
2532 $this->prepareErrorPage( $this->msg( 'internalerror' ) );
2533
2534 $this->addHTML( $message );
2535 }
2536
2537 public function showUnexpectedValueError( $name, $val ) {
2538 $this->showFatalError( $this->msg( 'unexpected', $name, $val )->text() );
2539 }
2540
2541 public function showFileCopyError( $old, $new ) {
2542 $this->showFatalError( $this->msg( 'filecopyerror', $old, $new )->text() );
2543 }
2544
2545 public function showFileRenameError( $old, $new ) {
2546 $this->showFatalError( $this->msg( 'filerenameerror', $old, $new )->text() );
2547 }
2548
2549 public function showFileDeleteError( $name ) {
2550 $this->showFatalError( $this->msg( 'filedeleteerror', $name )->text() );
2551 }
2552
2553 public function showFileNotFoundError( $name ) {
2554 $this->showFatalError( $this->msg( 'filenotfound', $name )->text() );
2555 }
2556
2557 /**
2558 * Add a "return to" link pointing to a specified title
2559 *
2560 * @param Title $title Title to link
2561 * @param array $query Query string parameters
2562 * @param string $text Text of the link (input is not escaped)
2563 * @param array $options Options array to pass to Linker
2564 */
2565 public function addReturnTo( $title, array $query = [], $text = null, $options = [] ) {
2566 $link = $this->msg( 'returnto' )->rawParams(
2567 Linker::link( $title, $text, [], $query, $options ) )->escaped();
2568 $this->addHTML( "<p id=\"mw-returnto\">{$link}</p>\n" );
2569 }
2570
2571 /**
2572 * Add a "return to" link pointing to a specified title,
2573 * or the title indicated in the request, or else the main page
2574 *
2575 * @param mixed $unused
2576 * @param Title|string $returnto Title or String to return to
2577 * @param string $returntoquery Query string for the return to link
2578 */
2579 public function returnToMain( $unused = null, $returnto = null, $returntoquery = null ) {
2580 if ( $returnto == null ) {
2581 $returnto = $this->getRequest()->getText( 'returnto' );
2582 }
2583
2584 if ( $returntoquery == null ) {
2585 $returntoquery = $this->getRequest()->getText( 'returntoquery' );
2586 }
2587
2588 if ( $returnto === '' ) {
2589 $returnto = Title::newMainPage();
2590 }
2591
2592 if ( is_object( $returnto ) ) {
2593 $titleObj = $returnto;
2594 } else {
2595 $titleObj = Title::newFromText( $returnto );
2596 }
2597 if ( !is_object( $titleObj ) ) {
2598 $titleObj = Title::newMainPage();
2599 }
2600
2601 $this->addReturnTo( $titleObj, wfCgiToArray( $returntoquery ) );
2602 }
2603
2604 /**
2605 * @param Skin $sk The given Skin
2606 * @param bool $includeStyle Unused
2607 * @return string The doctype, opening "<html>", and head element.
2608 */
2609 public function headElement( Skin $sk, $includeStyle = true ) {
2610 global $wgContLang;
2611
2612 $userdir = $this->getLanguage()->getDir();
2613 $sitedir = $wgContLang->getDir();
2614
2615 $pieces = [];
2616 $pieces[] = Html::htmlHeader( $sk->getHtmlElementAttributes() );
2617
2618 if ( $this->getHTMLTitle() == '' ) {
2619 $this->setHTMLTitle( $this->msg( 'pagetitle', $this->getPageTitle() )->inContentLanguage() );
2620 }
2621
2622 $openHead = Html::openElement( 'head' );
2623 if ( $openHead ) {
2624 $pieces[] = $openHead;
2625 }
2626
2627 if ( !Html::isXmlMimeType( $this->getConfig()->get( 'MimeType' ) ) ) {
2628 // Add <meta charset="UTF-8">
2629 // This should be before <title> since it defines the charset used by
2630 // text including the text inside <title>.
2631 // The spec recommends defining XHTML5's charset using the XML declaration
2632 // instead of meta.
2633 // Our XML declaration is output by Html::htmlHeader.
2634 // http://www.whatwg.org/html/semantics.html#attr-meta-http-equiv-content-type
2635 // http://www.whatwg.org/html/semantics.html#charset
2636 $pieces[] = Html::element( 'meta', [ 'charset' => 'UTF-8' ] );
2637 }
2638
2639 $pieces[] = Html::element( 'title', null, $this->getHTMLTitle() );
2640 $pieces[] = $this->getInlineHeadScripts();
2641 $pieces[] = $this->buildCssLinks();
2642 $pieces[] = $this->getExternalHeadScripts();
2643
2644 foreach ( $this->getHeadLinksArray() as $item ) {
2645 $pieces[] = $item;
2646 }
2647
2648 foreach ( $this->mHeadItems as $item ) {
2649 $pieces[] = $item;
2650 }
2651
2652 $closeHead = Html::closeElement( 'head' );
2653 if ( $closeHead ) {
2654 $pieces[] = $closeHead;
2655 }
2656
2657 $bodyClasses = [];
2658 $bodyClasses[] = 'mediawiki';
2659
2660 # Classes for LTR/RTL directionality support
2661 $bodyClasses[] = $userdir;
2662 $bodyClasses[] = "sitedir-$sitedir";
2663
2664 if ( $this->getLanguage()->capitalizeAllNouns() ) {
2665 # A <body> class is probably not the best way to do this . . .
2666 $bodyClasses[] = 'capitalize-all-nouns';
2667 }
2668
2669 // Parser feature migration class
2670 // The idea is that this will eventually be removed, after the wikitext
2671 // which requires it is cleaned up.
2672 $bodyClasses[] = 'mw-hide-empty-elt';
2673
2674 $bodyClasses[] = $sk->getPageClasses( $this->getTitle() );
2675 $bodyClasses[] = 'skin-' . Sanitizer::escapeClass( $sk->getSkinName() );
2676 $bodyClasses[] =
2677 'action-' . Sanitizer::escapeClass( Action::getActionName( $this->getContext() ) );
2678
2679 $bodyAttrs = [];
2680 // While the implode() is not strictly needed, it's used for backwards compatibility
2681 // (this used to be built as a string and hooks likely still expect that).
2682 $bodyAttrs['class'] = implode( ' ', $bodyClasses );
2683
2684 // Allow skins and extensions to add body attributes they need
2685 $sk->addToBodyAttributes( $this, $bodyAttrs );
2686 Hooks::run( 'OutputPageBodyAttributes', [ $this, $sk, &$bodyAttrs ] );
2687
2688 $pieces[] = Html::openElement( 'body', $bodyAttrs );
2689
2690 return WrappedStringList::join( "\n", $pieces );
2691 }
2692
2693 /**
2694 * Get a ResourceLoader object associated with this OutputPage
2695 *
2696 * @return ResourceLoader
2697 */
2698 public function getResourceLoader() {
2699 if ( is_null( $this->mResourceLoader ) ) {
2700 $this->mResourceLoader = new ResourceLoader(
2701 $this->getConfig(),
2702 LoggerFactory::getInstance( 'resourceloader' )
2703 );
2704 }
2705 return $this->mResourceLoader;
2706 }
2707
2708 /**
2709 * Construct neccecary html and loader preset states to load modules on a page.
2710 *
2711 * Use getHtmlFromLoaderLinks() to convert this array to HTML.
2712 *
2713 * @param array|string $modules One or more module names
2714 * @param string $only ResourceLoaderModule TYPE_ class constant
2715 * @param array $extraQuery [optional] Array with extra query parameters for the request
2716 * @return array A list of HTML strings and array of client loader preset states
2717 */
2718 public function makeResourceLoaderLink( $modules, $only, array $extraQuery = [] ) {
2719 $modules = (array)$modules;
2720
2721 $links = [
2722 // List of html strings
2723 'html' => [],
2724 // Associative array of module names and their states
2725 'states' => [],
2726 ];
2727
2728 if ( !count( $modules ) ) {
2729 return $links;
2730 }
2731
2732 if ( count( $modules ) > 1 ) {
2733 // Remove duplicate module requests
2734 $modules = array_unique( $modules );
2735 // Sort module names so requests are more uniform
2736 sort( $modules );
2737
2738 if ( ResourceLoader::inDebugMode() ) {
2739 // Recursively call us for every item
2740 foreach ( $modules as $name ) {
2741 $link = $this->makeResourceLoaderLink( $name, $only, $extraQuery );
2742 $links['html'] = array_merge( $links['html'], $link['html'] );
2743 $links['states'] += $link['states'];
2744 }
2745 return $links;
2746 }
2747 }
2748
2749 if ( !is_null( $this->mTarget ) ) {
2750 $extraQuery['target'] = $this->mTarget;
2751 }
2752
2753 // Create keyed-by-source and then keyed-by-group list of module objects from modules list
2754 $sortedModules = [];
2755 $resourceLoader = $this->getResourceLoader();
2756 foreach ( $modules as $name ) {
2757 $module = $resourceLoader->getModule( $name );
2758 # Check that we're allowed to include this module on this page
2759 if ( !$module
2760 || ( $module->getOrigin() > $this->getAllowedModules( ResourceLoaderModule::TYPE_SCRIPTS )
2761 && $only == ResourceLoaderModule::TYPE_SCRIPTS )
2762 || ( $module->getOrigin() > $this->getAllowedModules( ResourceLoaderModule::TYPE_STYLES )
2763 && $only == ResourceLoaderModule::TYPE_STYLES )
2764 || ( $module->getOrigin() > $this->getAllowedModules( ResourceLoaderModule::TYPE_COMBINED )
2765 && $only == ResourceLoaderModule::TYPE_COMBINED )
2766 || ( $this->mTarget && !in_array( $this->mTarget, $module->getTargets() ) )
2767 ) {
2768 continue;
2769 }
2770
2771 if ( $only === ResourceLoaderModule::TYPE_STYLES ) {
2772 if ( $module->getType() !== ResourceLoaderModule::LOAD_STYLES ) {
2773 $logger = $resourceLoader->getLogger();
2774 $logger->debug( 'Unexpected general module "{module}" in styles queue.', [
2775 'module' => $name,
2776 ] );
2777 } else {
2778 $links['states'][$name] = 'ready';
2779 }
2780 }
2781
2782 $sortedModules[$module->getSource()][$module->getGroup()][$name] = $module;
2783 }
2784
2785 foreach ( $sortedModules as $source => $groups ) {
2786 foreach ( $groups as $group => $grpModules ) {
2787 // Special handling for user-specific groups
2788 $user = null;
2789 if ( ( $group === 'user' || $group === 'private' ) && $this->getUser()->isLoggedIn() ) {
2790 $user = $this->getUser()->getName();
2791 }
2792
2793 // Create a fake request based on the one we are about to make so modules return
2794 // correct timestamp and emptiness data
2795 $query = ResourceLoader::makeLoaderQuery(
2796 [], // modules; not determined yet
2797 $this->getLanguage()->getCode(),
2798 $this->getSkin()->getSkinName(),
2799 $user,
2800 null, // version; not determined yet
2801 ResourceLoader::inDebugMode(),
2802 $only === ResourceLoaderModule::TYPE_COMBINED ? null : $only,
2803 $this->isPrintable(),
2804 $this->getRequest()->getBool( 'handheld' ),
2805 $extraQuery
2806 );
2807 $context = new ResourceLoaderContext( $resourceLoader, new FauxRequest( $query ) );
2808
2809 // Extract modules that know they're empty and see if we have one or more
2810 // raw modules
2811 $isRaw = false;
2812 foreach ( $grpModules as $key => $module ) {
2813 // Inline empty modules: since they're empty, just mark them as 'ready' (bug 46857)
2814 // If we're only getting the styles, we don't need to do anything for empty modules.
2815 if ( $module->isKnownEmpty( $context ) ) {
2816 unset( $grpModules[$key] );
2817 if ( $only !== ResourceLoaderModule::TYPE_STYLES ) {
2818 $links['states'][$key] = 'ready';
2819 }
2820 }
2821
2822 $isRaw |= $module->isRaw();
2823 }
2824
2825 // If there are no non-empty modules, skip this group
2826 if ( count( $grpModules ) === 0 ) {
2827 continue;
2828 }
2829
2830 // Inline private modules. These can't be loaded through load.php for security
2831 // reasons, see bug 34907. Note that these modules should be loaded from
2832 // getExternalHeadScripts() before the first loader call. Otherwise other modules can't
2833 // properly use them as dependencies (bug 30914)
2834 if ( $group === 'private' ) {
2835 if ( $only == ResourceLoaderModule::TYPE_STYLES ) {
2836 $links['html'][] = Html::inlineStyle(
2837 $resourceLoader->makeModuleResponse( $context, $grpModules )
2838 );
2839 } else {
2840 $links['html'][] = ResourceLoader::makeInlineScript(
2841 $resourceLoader->makeModuleResponse( $context, $grpModules )
2842 );
2843 }
2844 continue;
2845 }
2846
2847 // Special handling for the user group; because users might change their stuff
2848 // on-wiki like user pages, or user preferences; we need to find the highest
2849 // timestamp of these user-changeable modules so we can ensure cache misses on change
2850 // This should NOT be done for the site group (bug 27564) because anons get that too
2851 // and we shouldn't be putting timestamps in CDN-cached HTML
2852 $version = null;
2853 if ( $group === 'user' ) {
2854 $query['version'] = $resourceLoader->getCombinedVersion( $context, array_keys( $grpModules ) );
2855 }
2856
2857 $query['modules'] = ResourceLoader::makePackedModulesString( array_keys( $grpModules ) );
2858 $moduleContext = new ResourceLoaderContext( $resourceLoader, new FauxRequest( $query ) );
2859 $url = $resourceLoader->createLoaderURL( $source, $moduleContext, $extraQuery );
2860
2861 // Automatically select style/script elements
2862 if ( $only === ResourceLoaderModule::TYPE_STYLES ) {
2863 $link = Html::linkedStyle( $url );
2864 } else {
2865 if ( $context->getRaw() || $isRaw ) {
2866 // Startup module can't load itself, needs to use <script> instead of mw.loader.load
2867 $link = Html::element( 'script', [
2868 // In SpecialJavaScriptTest, QUnit must load synchronous
2869 'async' => !isset( $extraQuery['sync'] ),
2870 'src' => $url
2871 ] );
2872 } else {
2873 $link = ResourceLoader::makeInlineScript(
2874 Xml::encodeJsCall( 'mw.loader.load', [ $url ] )
2875 );
2876 }
2877
2878 // For modules requested directly in the html via <script> or mw.loader.load
2879 // tell mw.loader they are being loading to prevent duplicate requests.
2880 foreach ( $grpModules as $key => $module ) {
2881 // Don't output state=loading for the startup module.
2882 if ( $key !== 'startup' ) {
2883 $links['states'][$key] = 'loading';
2884 }
2885 }
2886 }
2887
2888 if ( $group == 'noscript' ) {
2889 $links['html'][] = Html::rawElement( 'noscript', [], $link );
2890 } else {
2891 $links['html'][] = $link;
2892 }
2893 }
2894 }
2895
2896 return $links;
2897 }
2898
2899 /**
2900 * Build html output from an array of links from makeResourceLoaderLink.
2901 * @param array $links
2902 * @return string|WrappedStringList HTML
2903 */
2904 protected static function getHtmlFromLoaderLinks( array $links ) {
2905 $html = [];
2906 $states = [];
2907 foreach ( $links as $link ) {
2908 if ( !is_array( $link ) ) {
2909 $html[] = $link;
2910 } else {
2911 $html = array_merge( $html, $link['html'] );
2912 $states += $link['states'];
2913 }
2914 }
2915 // Filter out empty values
2916 $html = array_filter( $html, 'strlen' );
2917
2918 if ( $states ) {
2919 array_unshift( $html, ResourceLoader::makeInlineScript(
2920 ResourceLoader::makeLoaderStateScript( $states )
2921 ) );
2922 }
2923
2924 return WrappedString::join( "\n", $html );
2925 }
2926
2927 /**
2928 * JS stuff to put in the "<head>". This is the startup module, config
2929 * vars and modules marked with position 'top'
2930 *
2931 * @return string HTML fragment
2932 */
2933 function getHeadScripts() {
2934 return $this->getInlineHeadScripts() . $this->getExternalHeadScripts();
2935 }
2936
2937 /**
2938 * <script src="..."> tags for "<head>".This is the startup module
2939 * and other modules marked with position 'top'.
2940 *
2941 * @return string|WrappedStringList HTML
2942 */
2943 function getExternalHeadScripts() {
2944 // Startup - this provides the client with the module
2945 // manifest and loads jquery and mediawiki base modules
2946 $links = [];
2947 $links[] = $this->makeResourceLoaderLink( 'startup', ResourceLoaderModule::TYPE_SCRIPTS );
2948 return self::getHtmlFromLoaderLinks( $links );
2949 }
2950
2951 /**
2952 * Inline "<script>" tags to put in "<head>".
2953 *
2954 * @return string|WrappedStringList HTML
2955 */
2956 function getInlineHeadScripts() {
2957 $links = [];
2958
2959 // Client profile classes for <html>. Allows for easy hiding/showing of UI components.
2960 // Must be done synchronously on every page to avoid flashes of wrong content.
2961 // Note: This class distinguishes MediaWiki-supported JavaScript from the rest.
2962 // The "rest" includes browsers that support JavaScript but not supported by our runtime.
2963 // For the performance benefit of the majority, this is added unconditionally here and is
2964 // then fixed up by the startup module for unsupported browsers.
2965 $links[] = Html::inlineScript(
2966 'document.documentElement.className = document.documentElement.className'
2967 . '.replace( /(^|\s)client-nojs(\s|$)/, "$1client-js$2" );'
2968 );
2969
2970 // Load config before anything else
2971 $links[] = ResourceLoader::makeInlineScript(
2972 ResourceLoader::makeConfigSetScript( $this->getJSVars() )
2973 );
2974
2975 // Load embeddable private modules before any loader links
2976 // This needs to be TYPE_COMBINED so these modules are properly wrapped
2977 // in mw.loader.implement() calls and deferred until mw.user is available
2978 $embedScripts = [ 'user.options' ];
2979 $links[] = $this->makeResourceLoaderLink(
2980 $embedScripts,
2981 ResourceLoaderModule::TYPE_COMBINED
2982 );
2983 // Separate user.tokens as otherwise caching will be allowed (T84960)
2984 $links[] = $this->makeResourceLoaderLink(
2985 'user.tokens',
2986 ResourceLoaderModule::TYPE_COMBINED
2987 );
2988
2989 // Modules requests - let the client calculate dependencies and batch requests as it likes
2990 // Only load modules that have marked themselves for loading at the top
2991 $modules = $this->getModules( true, 'top' );
2992 if ( $modules ) {
2993 $links[] = ResourceLoader::makeInlineScript(
2994 Xml::encodeJsCall( 'mw.loader.load', [ $modules ] )
2995 );
2996 }
2997
2998 // "Scripts only" modules marked for top inclusion
2999 $links[] = $this->makeResourceLoaderLink(
3000 $this->getModuleScripts( true, 'top' ),
3001 ResourceLoaderModule::TYPE_SCRIPTS
3002 );
3003
3004 return self::getHtmlFromLoaderLinks( $links );
3005 }
3006
3007 /**
3008 * JS stuff to put at the 'bottom', which goes at the bottom of the `<body>`.
3009 * These are modules marked with position 'bottom', legacy scripts ($this->mScripts),
3010 * site JS, and user JS.
3011 *
3012 * @param bool $unused Previously used to let this method change its output based
3013 * on whether it was called by getExternalHeadScripts() or getBottomScripts().
3014 * @return string|WrappedStringList HTML
3015 */
3016 function getScriptsForBottomQueue( $unused = null ) {
3017 // Scripts "only" requests marked for bottom inclusion
3018 // If we're in the <head>, use load() calls rather than <script src="..."> tags
3019 $links = [];
3020
3021 $links[] = $this->makeResourceLoaderLink( $this->getModuleScripts( true, 'bottom' ),
3022 ResourceLoaderModule::TYPE_SCRIPTS
3023 );
3024
3025 // Modules requests - let the client calculate dependencies and batch requests as it likes
3026 // Only load modules that have marked themselves for loading at the bottom
3027 $modules = $this->getModules( true, 'bottom' );
3028 if ( $modules ) {
3029 $links[] = ResourceLoader::makeInlineScript(
3030 Xml::encodeJsCall( 'mw.loader.load', [ $modules ] )
3031 );
3032 }
3033
3034 // Legacy Scripts
3035 $links[] = $this->mScripts;
3036
3037 // Add user JS if enabled
3038 // This must use TYPE_COMBINED instead of only=scripts so that its request is handled by
3039 // mw.loader.implement() which ensures that execution is scheduled after the "site" module.
3040 if ( $this->getConfig()->get( 'AllowUserJs' )
3041 && $this->getUser()->isLoggedIn()
3042 && $this->getTitle()
3043 && $this->getTitle()->isJsSubpage()
3044 && $this->userCanPreview()
3045 ) {
3046 // We're on a preview of a JS subpage. Exclude this page from the user module (T28283)
3047 // and include the draft contents as a raw script instead.
3048 $links[] = $this->makeResourceLoaderLink( 'user', ResourceLoaderModule::TYPE_COMBINED,
3049 [ 'excludepage' => $this->getTitle()->getPrefixedDBkey() ]
3050 );
3051 // Load the previewed JS
3052 $links[] = ResourceLoader::makeInlineScript(
3053 Xml::encodeJsCall( 'mw.loader.using', [
3054 [ 'user', 'site' ],
3055 new XmlJsCode(
3056 'function () {'
3057 . Xml::encodeJsCall( '$.globalEval', [
3058 $this->getRequest()->getText( 'wpTextbox1' )
3059 ] )
3060 . '}'
3061 )
3062 ] )
3063 );
3064
3065 // FIXME: If the user is previewing, say, ./vector.js, his ./common.js will be loaded
3066 // asynchronously and may arrive *after* the inline script here. So the previewed code
3067 // may execute before ./common.js runs. Normally, ./common.js runs before ./vector.js.
3068 // Similarly, when previewing ./common.js and the user module does arrive first,
3069 // it will arrive without common.js and the inline script runs after.
3070 // Thus running common after the excluded subpage.
3071 } else {
3072 // Include the user module normally, i.e., raw to avoid it being wrapped in a closure.
3073 $links[] = $this->makeResourceLoaderLink( 'user', ResourceLoaderModule::TYPE_COMBINED );
3074 }
3075
3076 return self::getHtmlFromLoaderLinks( $links );
3077 }
3078
3079 /**
3080 * JS stuff to put at the bottom of the "<body>"
3081 * @return string
3082 */
3083 function getBottomScripts() {
3084 return $this->getScriptsForBottomQueue() .
3085 ResourceLoader::makeInlineScript(
3086 ResourceLoader::makeConfigSetScript(
3087 [ 'wgPageParseReport' => $this->limitReportData ],
3088 true
3089 )
3090 );
3091 }
3092
3093 /**
3094 * Get the javascript config vars to include on this page
3095 *
3096 * @return array Array of javascript config vars
3097 * @since 1.23
3098 */
3099 public function getJsConfigVars() {
3100 return $this->mJsConfigVars;
3101 }
3102
3103 /**
3104 * Add one or more variables to be set in mw.config in JavaScript
3105 *
3106 * @param string|array $keys Key or array of key/value pairs
3107 * @param mixed $value [optional] Value of the configuration variable
3108 */
3109 public function addJsConfigVars( $keys, $value = null ) {
3110 if ( is_array( $keys ) ) {
3111 foreach ( $keys as $key => $value ) {
3112 $this->mJsConfigVars[$key] = $value;
3113 }