includes/specials/SpecialVersion.php

   1 <?php
   2 /**
   3  * Implements Special:Version
   4  *
   5  * Copyright © 2005 Ævar Arnfjörð Bjarmason
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  * http://www.gnu.org/copyleft/gpl.html
  21  *
  22  * @file
  23  * @ingroup SpecialPage
  24  */
  25
  26 use MediaWiki\MediaWikiServices;
  27
  28 /**
  29  * Give information about the version of MediaWiki, PHP, the DB and extensions
  30  *
  31  * @ingroup SpecialPage
  32  */
  33 class SpecialVersion extends SpecialPage {
  34
  35         /**
  36          * @var bool
  37          */
  38         protected $firstExtOpened = false;
  39
  40         /**
  41          * @var string The current rev id/SHA hash of MediaWiki core
  42          */
  43         protected $coreId = '';
  44
  45         /**
  46          * @var string[]|false Lazy initialized key/value with message content
  47          */
  48         protected static $extensionTypes = false;
  49
  50         public function __construct() {
  51                 parent::__construct( 'Version' );
  52         }
  53
  54         /**
  55          * main()
  56          * @param string|null $par
  57          */
  58         public function execute( $par ) {
  59                 global $IP;
  60                 $config = $this->getConfig();
  61                 $extensionCredits = $config->get( 'ExtensionCredits' );
  62
  63                 $this->setHeaders();
  64                 $this->outputHeader();
  65                 $out = $this->getOutput();
  66                 $out->allowClickjacking();
  67
  68                 // Explode the sub page information into useful bits
  69                 $parts = explode( '/', (string)$par );
  70                 $extNode = null;
  71                 if ( isset( $parts[1] ) ) {
  72                         $extName = str_replace( '_', ' ', $parts[1] );
  73                         // Find it!
  74                         foreach ( $extensionCredits as $group => $extensions ) {
  75                                 foreach ( $extensions as $ext ) {
  76                                         if ( isset( $ext['name'] ) && ( $ext['name'] === $extName ) ) {
  77                                                 $extNode = &$ext;
  78                                                 break 2;
  79                                         }
  80                                 }
  81                         }
  82                         if ( !$extNode ) {
  83                                 $out->setStatusCode( 404 );
  84                         }
  85                 } else {
  86                         $extName = 'MediaWiki';
  87                 }
  88
  89                 // Now figure out what to do
  90                 switch ( strtolower( $parts[0] ) ) {
  91                         case 'credits':
  92                                 $out->addModuleStyles( 'mediawiki.special.version' );
  93
  94                                 $wikiText = '{{int:version-credits-not-found}}';
  95                                 if ( $extName === 'MediaWiki' ) {
  96                                         $wikiText = file_get_contents( $IP . '/CREDITS' );
  97                                         // Put the contributor list into columns
  98                                         $wikiText = str_replace(
  99                                                 [ '<!-- BEGIN CONTRIBUTOR LIST -->', '<!-- END CONTRIBUTOR LIST -->' ],
 100                                                 [ '<div class="mw-version-credits">', '</div>' ],
 101                                                 $wikiText );
 102                                 } elseif ( ( $extNode !== null ) && isset( $extNode['path'] ) ) {
 103                                         $file = $this->getExtAuthorsFileName( dirname( $extNode['path'] ) );
 104                                         if ( $file ) {
 105                                                 $wikiText = file_get_contents( $file );
 106                                                 if ( substr( $file, -4 ) === '.txt' ) {
 107                                                         $wikiText = Html::element(
 108                                                                 'pre',
 109                                                                 [
 110                                                                         'lang' => 'en',
 111                                                                         'dir' => 'ltr',
 112                                                                 ],
 113                                                                 $wikiText
 114                                                         );
 115                                                 }
 116                                         }
 117                                 }
 118
 119                                 $out->setPageTitle( $this->msg( 'version-credits-title', $extName ) );
 120                                 $out->addWikiTextAsInterface( $wikiText );
 121                                 break;
 122
 123                         case 'license':
 124                                 $wikiText = '{{int:version-license-not-found}}';
 125                                 if ( $extName === 'MediaWiki' ) {
 126                                         $wikiText = file_get_contents( $IP . '/COPYING' );
 127                                 } elseif ( ( $extNode !== null ) && isset( $extNode['path'] ) ) {
 128                                         $file = $this->getExtLicenseFileName( dirname( $extNode['path'] ) );
 129                                         if ( $file ) {
 130                                                 $wikiText = file_get_contents( $file );
 131                                                 $wikiText = Html::element(
 132                                                         'pre',
 133                                                         [
 134                                                                 'lang' => 'en',
 135                                                                 'dir' => 'ltr',
 136                                                         ],
 137                                                         $wikiText
 138                                                 );
 139                                         }
 140                                 }
 141
 142                                 $out->setPageTitle( $this->msg( 'version-license-title', $extName ) );
 143                                 $out->addWikiTextAsInterface( $wikiText );
 144                                 break;
 145
 146                         default:
 147                                 $out->addModuleStyles( 'mediawiki.special.version' );
 148                                 $out->addWikiTextAsInterface(
 149                                         $this->getMediaWikiCredits() .
 150                                         $this->softwareInformation() .
 151                                         $this->getEntryPointInfo()
 152                                 );
 153                                 $out->addHTML(
 154                                         $this->getSkinCredits() .
 155                                         $this->getExtensionCredits() .
 156                                         $this->getExternalLibraries() .
 157                                         $this->getParserTags() .
 158                                         $this->getParserFunctionHooks()
 159                                 );
 160                                 $out->addWikiTextAsInterface( $this->getWgHooks() );
 161                                 $out->addHTML( $this->IPInfo() );
 162
 163                                 break;
 164                 }
 165         }
 166
 167         /**
 168          * Returns wiki text showing the license information.
 169          *
 170          * @return string
 171          */
 172         private static function getMediaWikiCredits() {
 173                 $ret = Xml::element(
 174                         'h2',
 175                         [ 'id' => 'mw-version-license' ],
 176                         wfMessage( 'version-license' )->text()
 177                 );
 178
 179                 // This text is always left-to-right.
 180                 $ret .= '<div class="plainlinks">';
 181                 $ret .= "__NOTOC__
 182                 " . self::getCopyrightAndAuthorList() . "\n
 183                 " . '<div class="mw-version-license-info">' .
 184                 wfMessage( 'version-license-info' )->text() .
 185                 '</div>';
 186                 $ret .= '</div>';
 187
 188                 return str_replace( "\t\t", '', $ret ) . "\n";
 189         }
 190
 191         /**
 192          * Get the "MediaWiki is copyright 2001-20xx by lots of cool guys" text
 193          *
 194          * @return string
 195          */
 196         public static function getCopyrightAndAuthorList() {
 197                 global $wgLang;
 198
 199                 if ( defined( 'MEDIAWIKI_INSTALL' ) ) {
 200                         $othersLink = '[https://www.mediawiki.org/wiki/Special:Version/Credits ' .
 201                                 wfMessage( 'version-poweredby-others' )->text() . ']';
 202                 } else {
 203                         $othersLink = '[[Special:Version/Credits|' .
 204                                 wfMessage( 'version-poweredby-others' )->text() . ']]';
 205                 }
 206
 207                 $translatorsLink = '[https://translatewiki.net/wiki/Translating:MediaWiki/Credits ' .
 208                         wfMessage( 'version-poweredby-translators' )->text() . ']';
 209
 210                 $authorList = [
 211                         'Magnus Manske', 'Brion Vibber', 'Lee Daniel Crocker',
 212                         'Tim Starling', 'Erik Möller', 'Gabriel Wicke', 'Ævar Arnfjörð Bjarmason',
 213                         'Niklas Laxström', 'Domas Mituzas', 'Rob Church', 'Yuri Astrakhan',
 214                         'Aryeh Gregor', 'Aaron Schulz', 'Andrew Garrett', 'Raimond Spekking',
 215                         'Alexandre Emsenhuber', 'Siebrand Mazeland', 'Chad Horohoe',
 216                         'Roan Kattouw', 'Trevor Parscal', 'Bryan Tong Minh', 'Sam Reed',
 217                         'Victor Vasiliev', 'Rotem Liss', 'Platonides', 'Antoine Musso',
 218                         'Timo Tijhof', 'Daniel Kinzler', 'Jeroen De Dauw', 'Brad Jorsch',
 219                         'Bartosz Dziewoński', 'Ed Sanders', 'Moriel Schottlender',
 220                         'Kunal Mehta', 'James D. Forrester', 'Brian Wolff', 'Adam Shorland',
 221                         $othersLink, $translatorsLink
 222                 ];
 223
 224                 return wfMessage( 'version-poweredby-credits', MWTimestamp::getLocalInstance()->format( 'Y' ),
 225                         $wgLang->listToText( $authorList ) )->text();
 226         }
 227
 228         /**
 229          * @since 1.34
 230          *
 231          * @return array
 232          */
 233         public static function getSoftwareInformation() {
 234                 $dbr = wfGetDB( DB_REPLICA );
 235
 236                 // Put the software in an array of form 'name' => 'version'. All messages should
 237                 // be loaded here, so feel free to use wfMessage in the 'name'. Raw HTML or
 238                 // wikimarkup can be used.
 239                 $software = [
 240                         '[https://www.mediawiki.org/ MediaWiki]' => self::getVersionLinked()
 241                 ];
 242
 243                 if ( wfIsHHVM() ) {
 244                         $software['[https://hhvm.com/ HHVM]'] = HHVM_VERSION . " (" . PHP_SAPI . ")";
 245                 } else {
 246                         $software['[https://php.net/ PHP]'] = PHP_VERSION . " (" . PHP_SAPI . ")";
 247                 }
 248
 249                 $software[$dbr->getSoftwareLink()] = $dbr->getServerInfo();
 250
 251                 if ( defined( 'INTL_ICU_VERSION' ) ) {
 252                         $software['[http://site.icu-project.org/ ICU]'] = INTL_ICU_VERSION;
 253                 }
 254
 255                 // Allow a hook to add/remove items.
 256                 Hooks::run( 'SoftwareInfo', [ &$software ] );
 257
 258                 return $software;
 259         }
 260
 261         /**
 262          * Returns HTML showing the third party software versions (apache, php, mysql).
 263          *
 264          * @return string HTML table
 265          */
 266         public static function softwareInformation() {
 267                 $out = Xml::element(
 268                                 'h2',
 269                                 [ 'id' => 'mw-version-software' ],
 270                                 wfMessage( 'version-software' )->text()
 271                         ) .
 272                         Xml::openElement( 'table', [ 'class' => 'wikitable plainlinks', 'id' => 'sv-software' ] ) .
 273                         "<tr>
 274                                 <th>" . wfMessage( 'version-software-product' )->text() . "</th>
 275                                 <th>" . wfMessage( 'version-software-version' )->text() . "</th>
 276                         </tr>\n";
 277
 278                 foreach ( self::getSoftwareInformation() as $name => $version ) {
 279                         $out .= "<tr>
 280                                         <td>" . $name . "</td>
 281                                         <td dir=\"ltr\">" . $version . "</td>
 282                                 </tr>\n";
 283                 }
 284
 285                 return $out . Xml::closeElement( 'table' );
 286         }
 287
 288         /**
 289          * Return a string of the MediaWiki version with Git revision if available.
 290          *
 291          * @param string $flags
 292          * @param Language|string|null $lang
 293          * @return mixed
 294          */
 295         public static function getVersion( $flags = '', $lang = null ) {
 296                 global $wgVersion, $IP;
 297
 298                 $gitInfo = self::getGitHeadSha1( $IP );
 299                 if ( !$gitInfo ) {
 300                         $version = $wgVersion;
 301                 } elseif ( $flags === 'nodb' ) {
 302                         $shortSha1 = substr( $gitInfo, 0, 7 );
 303                         $version = "$wgVersion ($shortSha1)";
 304                 } else {
 305                         $shortSha1 = substr( $gitInfo, 0, 7 );
 306                         $msg = wfMessage( 'parentheses' );
 307                         if ( $lang !== null ) {
 308                                 $msg->inLanguage( $lang );
 309                         }
 310                         $shortSha1 = $msg->params( $shortSha1 )->escaped();
 311                         $version = "$wgVersion $shortSha1";
 312                 }
 313
 314                 return $version;
 315         }
 316
 317         /**
 318          * Return a wikitext-formatted string of the MediaWiki version with a link to
 319          * the Git SHA1 of head if available.
 320          * The fallback is just $wgVersion
 321          *
 322          * @return mixed
 323          */
 324         public static function getVersionLinked() {
 325                 global $wgVersion;
 326
 327                 $gitVersion = self::getVersionLinkedGit();
 328                 if ( $gitVersion ) {
 329                         $v = $gitVersion;
 330                 } else {
 331                         $v = $wgVersion; // fallback
 332                 }
 333
 334                 return $v;
 335         }
 336
 337         /**
 338          * @return string
 339          */
 340         private static function getwgVersionLinked() {
 341                 global $wgVersion;
 342                 $versionUrl = "";
 343                 if ( Hooks::run( 'SpecialVersionVersionUrl', [ $wgVersion, &$versionUrl ] ) ) {
 344                         $versionParts = [];
 345                         preg_match( "/^(\d+\.\d+)/", $wgVersion, $versionParts );
 346                         $versionUrl = "https://www.mediawiki.org/wiki/MediaWiki_{$versionParts[1]}";
 347                 }
 348
 349                 return "[$versionUrl $wgVersion]";
 350         }
 351
 352         /**
 353          * @since 1.22 Returns the HEAD date in addition to the sha1 and link
 354          * @return bool|string Global wgVersion + HEAD sha1 stripped to the first 7 chars
 355          *   with link and date, or false on failure
 356          */
 357         private static function getVersionLinkedGit() {
 358                 global $IP, $wgLang;
 359
 360                 $gitInfo = new GitInfo( $IP );
 361                 $headSHA1 = $gitInfo->getHeadSHA1();
 362                 if ( !$headSHA1 ) {
 363                         return false;
 364                 }
 365
 366                 $shortSHA1 = '(' . substr( $headSHA1, 0, 7 ) . ')';
 367
 368                 $gitHeadUrl = $gitInfo->getHeadViewUrl();
 369                 if ( $gitHeadUrl !== false ) {
 370                         $shortSHA1 = "[$gitHeadUrl $shortSHA1]";
 371                 }
 372
 373                 $gitHeadCommitDate = $gitInfo->getHeadCommitDate();
 374                 if ( $gitHeadCommitDate ) {
 375                         $shortSHA1 .= Html::element( 'br' ) . $wgLang->timeanddate( $gitHeadCommitDate, true );
 376                 }
 377
 378                 return self::getwgVersionLinked() . " $shortSHA1";
 379         }
 380
 381         /**
 382          * Returns an array with the base extension types.
 383          * Type is stored as array key, the message as array value.
 384          *
 385          * TODO: ideally this would return all extension types.
 386          *
 387          * @since 1.17
 388          *
 389          * @return string[]
 390          */
 391         public static function getExtensionTypes() {
 392                 if ( self::$extensionTypes === false ) {
 393                         self::$extensionTypes = [
 394                                 'specialpage' => wfMessage( 'version-specialpages' )->text(),
 395                                 'editor' => wfMessage( 'version-editors' )->text(),
 396                                 'parserhook' => wfMessage( 'version-parserhooks' )->text(),
 397                                 'variable' => wfMessage( 'version-variables' )->text(),
 398                                 'media' => wfMessage( 'version-mediahandlers' )->text(),
 399                                 'antispam' => wfMessage( 'version-antispam' )->text(),
 400                                 'skin' => wfMessage( 'version-skins' )->text(),
 401                                 'api' => wfMessage( 'version-api' )->text(),
 402                                 'other' => wfMessage( 'version-other' )->text(),
 403                         ];
 404
 405                         Hooks::run( 'ExtensionTypes', [ &self::$extensionTypes ] );
 406                 }
 407
 408                 return self::$extensionTypes;
 409         }
 410
 411         /**
 412          * Returns the internationalized name for an extension type.
 413          *
 414          * @since 1.17
 415          *
 416          * @param string $type
 417          *
 418          * @return string
 419          */
 420         public static function getExtensionTypeName( $type ) {
 421                 $types = self::getExtensionTypes();
 422
 423                 return $types[$type] ?? $types['other'];
 424         }
 425
 426         /**
 427          * Generate wikitext showing the name, URL, author and description of each extension.
 428          *
 429          * @return string Wikitext
 430          */
 431         public function getExtensionCredits() {
 432                 $config = $this->getConfig();
 433                 $extensionCredits = $config->get( 'ExtensionCredits' );
 434
 435                 if (
 436                         count( $extensionCredits ) === 0 ||
 437                         // Skins are displayed separately, see getSkinCredits()
 438                         ( count( $extensionCredits ) === 1 && isset( $extensionCredits['skin'] ) )
 439                 ) {
 440                         return '';
 441                 }
 442
 443                 $extensionTypes = self::getExtensionTypes();
 444
 445                 $out = Xml::element(
 446                                 'h2',
 447                                 [ 'id' => 'mw-version-ext' ],
 448                                 $this->msg( 'version-extensions' )->text()
 449                         ) .
 450                         Xml::openElement( 'table', [ 'class' => 'wikitable plainlinks', 'id' => 'sv-ext' ] );
 451
 452                 // Make sure the 'other' type is set to an array.
 453                 if ( !array_key_exists( 'other', $extensionCredits ) ) {
 454                         $extensionCredits['other'] = [];
 455                 }
 456
 457                 // Find all extensions that do not have a valid type and give them the type 'other'.
 458                 foreach ( $extensionCredits as $type => $extensions ) {
 459                         if ( !array_key_exists( $type, $extensionTypes ) ) {
 460                                 $extensionCredits['other'] = array_merge( $extensionCredits['other'], $extensions );
 461                         }
 462                 }
 463
 464                 $this->firstExtOpened = false;
 465                 // Loop through the extension categories to display their extensions in the list.
 466                 foreach ( $extensionTypes as $type => $message ) {
 467                         // Skins have a separate section
 468                         if ( $type !== 'other' && $type !== 'skin' ) {
 469                                 $out .= $this->getExtensionCategory( $type, $message );
 470                         }
 471                 }
 472
 473                 // We want the 'other' type to be last in the list.
 474                 $out .= $this->getExtensionCategory( 'other', $extensionTypes['other'] );
 475
 476                 $out .= Xml::closeElement( 'table' );
 477
 478                 return $out;
 479         }
 480
 481         /**
 482          * Generate wikitext showing the name, URL, author and description of each skin.
 483          *
 484          * @return string Wikitext
 485          */
 486         public function getSkinCredits() {
 487                 global $wgExtensionCredits;
 488                 if ( !isset( $wgExtensionCredits['skin'] ) || count( $wgExtensionCredits['skin'] ) === 0 ) {
 489                         return '';
 490                 }
 491
 492                 $out = Xml::element(
 493                                 'h2',
 494                                 [ 'id' => 'mw-version-skin' ],
 495                                 $this->msg( 'version-skins' )->text()
 496                         ) .
 497                         Xml::openElement( 'table', [ 'class' => 'wikitable plainlinks', 'id' => 'sv-skin' ] );
 498
 499                 $this->firstExtOpened = false;
 500                 $out .= $this->getExtensionCategory( 'skin', null );
 501
 502                 $out .= Xml::closeElement( 'table' );
 503
 504                 return $out;
 505         }
 506
 507         /**
 508          * Generate an HTML table for external libraries that are installed
 509          *
 510          * @return string
 511          */
 512         protected function getExternalLibraries() {
 513                 global $IP;
 514                 $path = "$IP/vendor/composer/installed.json";
 515                 if ( !file_exists( $path ) ) {
 516                         return '';
 517                 }
 518
 519                 $installed = new ComposerInstalled( $path );
 520                 $out = Html::element(
 521                         'h2',
 522                         [ 'id' => 'mw-version-libraries' ],
 523                         $this->msg( 'version-libraries' )->text()
 524                 );
 525                 $out .= Html::openElement(
 526                         'table',
 527                         [ 'class' => 'wikitable plainlinks', 'id' => 'sv-libraries' ]
 528                 );
 529                 $out .= Html::openElement( 'tr' )
 530                         . Html::element( 'th', [], $this->msg( 'version-libraries-library' )->text() )
 531                         . Html::element( 'th', [], $this->msg( 'version-libraries-version' )->text() )
 532                         . Html::element( 'th', [], $this->msg( 'version-libraries-license' )->text() )
 533                         . Html::element( 'th', [], $this->msg( 'version-libraries-description' )->text() )
 534                         . Html::element( 'th', [], $this->msg( 'version-libraries-authors' )->text() )
 535                         . Html::closeElement( 'tr' );
 536
 537                 foreach ( $installed->getInstalledDependencies() as $name => $info ) {
 538                         if ( strpos( $info['type'], 'mediawiki-' ) === 0 ) {
 539                                 // Skip any extensions or skins since they'll be listed
 540                                 // in their proper section
 541                                 continue;
 542                         }
 543                         $authors = array_map( function ( $arr ) {
 544                                 // If a homepage is set, link to it
 545                                 if ( isset( $arr['homepage'] ) ) {
 546                                         return "[{$arr['homepage']} {$arr['name']}]";
 547                                 }
 548                                 return $arr['name'];
 549                         }, $info['authors'] );
 550                         $authors = $this->listAuthors( $authors, false, "$IP/vendor/$name" );
 551
 552                         // We can safely assume that the libraries' names and descriptions
 553                         // are written in English and aren't going to be translated,
 554                         // so set appropriate lang and dir attributes
 555                         $out .= Html::openElement( 'tr' )
 556                                 . Html::rawElement(
 557                                         'td',
 558                                         [],
 559                                         Linker::makeExternalLink(
 560                                                 "https://packagist.org/packages/$name", $name,
 561                                                 true, '',
 562                                                 [ 'class' => 'mw-version-library-name' ]
 563                                         )
 564                                 )
 565                                 . Html::element( 'td', [ 'dir' => 'auto' ], $info['version'] )
 566                                 . Html::element( 'td', [ 'dir' => 'auto' ], $this->listToText( $info['licenses'] ) )
 567                                 . Html::element( 'td', [ 'lang' => 'en', 'dir' => 'ltr' ], $info['description'] )
 568                                 . Html::rawElement( 'td', [], $authors )
 569                                 . Html::closeElement( 'tr' );
 570                 }
 571                 $out .= Html::closeElement( 'table' );
 572
 573                 return $out;
 574         }
 575
 576         /**
 577          * Obtains a list of installed parser tags and the associated H2 header
 578          *
 579          * @return string HTML output
 580          */
 581         protected function getParserTags() {
 582                 $tags = MediaWikiServices::getInstance()->getParser()->getTags();
 583
 584                 if ( count( $tags ) ) {
 585                         $out = Html::rawElement(
 586                                 'h2',
 587                                 [
 588                                         'class' => 'mw-headline plainlinks',
 589                                         'id' => 'mw-version-parser-extensiontags',
 590                                 ],
 591                                 Linker::makeExternalLink(
 592                                         'https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Tag_extensions',
 593                                         $this->msg( 'version-parser-extensiontags' )->parse(),
 594                                         false /* msg()->parse() already escapes */
 595                                 )
 596                         );
 597
 598                         array_walk( $tags, function ( &$value ) {
 599                                 // Bidirectional isolation improves readability in RTL wikis
 600                                 $value = Html::element(
 601                                         'bdi',
 602                                         // Prevent < and > from slipping to another line
 603                                         [
 604                                                 'style' => 'white-space: nowrap;',
 605                                         ],
 606                                         "<$value>"
 607                                 );
 608                         } );
 609
 610                         $out .= $this->listToText( $tags );
 611                 } else {
 612                         $out = '';
 613                 }
 614
 615                 return $out;
 616         }
 617
 618         /**
 619          * Obtains a list of installed parser function hooks and the associated H2 header
 620          *
 621          * @return string HTML output
 622          */
 623         protected function getParserFunctionHooks() {
 624                 $fhooks = MediaWikiServices::getInstance()->getParser()->getFunctionHooks();
 625                 if ( count( $fhooks ) ) {
 626                         $out = Html::rawElement(
 627                                 'h2',
 628                                 [
 629                                         'class' => 'mw-headline plainlinks',
 630                                         'id' => 'mw-version-parser-function-hooks',
 631                                 ],
 632                                 Linker::makeExternalLink(
 633                                         'https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Parser_functions',
 634                                         $this->msg( 'version-parser-function-hooks' )->parse(),
 635                                         false /* msg()->parse() already escapes */
 636                                 )
 637                         );
 638
 639                         $out .= $this->listToText( $fhooks );
 640                 } else {
 641                         $out = '';
 642                 }
 643
 644                 return $out;
 645         }
 646
 647         /**
 648          * Creates and returns the HTML for a single extension category.
 649          *
 650          * @since 1.17
 651          *
 652          * @param string $type
 653          * @param string $message
 654          *
 655          * @return string
 656          */
 657         protected function getExtensionCategory( $type, $message ) {
 658                 $config = $this->getConfig();
 659                 $extensionCredits = $config->get( 'ExtensionCredits' );
 660
 661                 $out = '';
 662
 663                 if ( array_key_exists( $type, $extensionCredits ) && count( $extensionCredits[$type] ) > 0 ) {
 664                         $out .= $this->openExtType( $message, 'credits-' . $type );
 665
 666                         usort( $extensionCredits[$type], [ $this, 'compare' ] );
 667
 668                         foreach ( $extensionCredits[$type] as $extension ) {
 669                                 $out .= $this->getCreditsForExtension( $type, $extension );
 670                         }
 671                 }
 672
 673                 return $out;
 674         }
 675
 676         /**
 677          * Callback to sort extensions by type.
 678          * @param array $a
 679          * @param array $b
 680          * @return int
 681          */
 682         public function compare( $a, $b ) {
 683                 return $this->getLanguage()->lc( $a['name'] ) <=> $this->getLanguage()->lc( $b['name'] );
 684         }
 685
 686         /**
 687          * Creates and formats a version line for a single extension.
 688          *
 689          * Information for five columns will be created. Parameters required in the
 690          * $extension array for part rendering are indicated in ()
 691          *  - The name of (name), and URL link to (url), the extension
 692          *  - Official version number (version) and if available version control system
 693          *    revision (path), link, and date
 694          *  - If available the short name of the license (license-name) and a link
 695          *    to ((LICENSE)|(COPYING))(\.txt)? if it exists.
 696          *  - Description of extension (descriptionmsg or description)
 697          *  - List of authors (author) and link to a ((AUTHORS)|(CREDITS))(\.txt)? file if it exists
 698          *
 699          * @param string $type Category name of the extension
 700          * @param array $extension
 701          *
 702          * @return string Raw HTML
 703          */
 704         public function getCreditsForExtension( $type, array $extension ) {
 705                 $out = $this->getOutput();
 706
 707                 // We must obtain the information for all the bits and pieces!
 708                 // ... such as extension names and links
 709                 if ( isset( $extension['namemsg'] ) ) {
 710                         // Localized name of extension
 711                         $extensionName = $this->msg( $extension['namemsg'] )->text();
 712                 } elseif ( isset( $extension['name'] ) ) {
 713                         // Non localized version
 714                         $extensionName = $extension['name'];
 715                 } else {
 716                         $extensionName = $this->msg( 'version-no-ext-name' )->text();
 717                 }
 718
 719                 if ( isset( $extension['url'] ) ) {
 720                         $extensionNameLink = Linker::makeExternalLink(
 721                                 $extension['url'],
 722                                 $extensionName,
 723                                 true,
 724                                 '',
 725                                 [ 'class' => 'mw-version-ext-name' ]
 726                         );
 727                 } else {
 728                         $extensionNameLink = htmlspecialchars( $extensionName );
 729                 }
 730
 731                 // ... and the version information
 732                 // If the extension path is set we will check that directory for GIT
 733                 // metadata in an attempt to extract date and vcs commit metadata.
 734                 $canonicalVersion = '&ndash;';
 735                 $extensionPath = null;
 736                 $vcsVersion = null;
 737                 $vcsLink = null;
 738                 $vcsDate = null;
 739
 740                 if ( isset( $extension['version'] ) ) {
 741                         $canonicalVersion = $out->parseInlineAsInterface( $extension['version'] );
 742                 }
 743
 744                 if ( isset( $extension['path'] ) ) {
 745                         global $IP;
 746                         $extensionPath = dirname( $extension['path'] );
 747                         if ( $this->coreId == '' ) {
 748                                 wfDebug( 'Looking up core head id' );
 749                                 $coreHeadSHA1 = self::getGitHeadSha1( $IP );
 750                                 if ( $coreHeadSHA1 ) {
 751                                         $this->coreId = $coreHeadSHA1;
 752                                 }
 753                         }
 754                         $cache = wfGetCache( CACHE_ANYTHING );
 755                         $memcKey = $cache->makeKey(
 756                                 'specialversion-ext-version-text', $extension['path'], $this->coreId
 757                         );
 758                         list( $vcsVersion, $vcsLink, $vcsDate ) = $cache->get( $memcKey );
 759
 760                         if ( !$vcsVersion ) {
 761                                 wfDebug( "Getting VCS info for extension {$extension['name']}" );
 762                                 $gitInfo = new GitInfo( $extensionPath );
 763                                 $vcsVersion = $gitInfo->getHeadSHA1();
 764                                 if ( $vcsVersion !== false ) {
 765                                         $vcsVersion = substr( $vcsVersion, 0, 7 );
 766                                         $vcsLink = $gitInfo->getHeadViewUrl();
 767                                         $vcsDate = $gitInfo->getHeadCommitDate();
 768                                 }
 769                                 $cache->set( $memcKey, [ $vcsVersion, $vcsLink, $vcsDate ], 60 * 60 * 24 );
 770                         } else {
 771                                 wfDebug( "Pulled VCS info for extension {$extension['name']} from cache" );
 772                         }
 773                 }
 774
 775                 $versionString = Html::rawElement(
 776                         'span',
 777                         [ 'class' => 'mw-version-ext-version' ],
 778                         $canonicalVersion
 779                 );
 780
 781                 if ( $vcsVersion ) {
 782                         if ( $vcsLink ) {
 783                                 $vcsVerString = Linker::makeExternalLink(
 784                                         $vcsLink,
 785                                         $this->msg( 'version-version', $vcsVersion ),
 786                                         true,
 787                                         '',
 788                                         [ 'class' => 'mw-version-ext-vcs-version' ]
 789                                 );
 790                         } else {
 791                                 $vcsVerString = Html::element( 'span',
 792                                         [ 'class' => 'mw-version-ext-vcs-version' ],
 793                                         "({$vcsVersion})"
 794                                 );
 795                         }
 796                         $versionString .= " {$vcsVerString}";
 797
 798                         if ( $vcsDate ) {
 799                                 $vcsTimeString = Html::element( 'span',
 800                                         [ 'class' => 'mw-version-ext-vcs-timestamp' ],
 801                                         $this->getLanguage()->timeanddate( $vcsDate, true )
 802                                 );
 803                                 $versionString .= " {$vcsTimeString}";
 804                         }
 805                         $versionString = Html::rawElement( 'span',
 806                                 [ 'class' => 'mw-version-ext-meta-version' ],
 807                                 $versionString
 808                         );
 809                 }
 810
 811                 // ... and license information; if a license file exists we
 812                 // will link to it
 813                 $licenseLink = '';
 814                 if ( isset( $extension['name'] ) ) {
 815                         $licenseName = null;
 816                         if ( isset( $extension['license-name'] ) ) {
 817                                 $licenseName = new HtmlArmor( $out->parseInlineAsInterface( $extension['license-name'] ) );
 818                         } elseif ( $this->getExtLicenseFileName( $extensionPath ) ) {
 819                                 $licenseName = $this->msg( 'version-ext-license' )->text();
 820                         }
 821                         if ( $licenseName !== null ) {
 822                                 $licenseLink = $this->getLinkRenderer()->makeLink(
 823                                         $this->getPageTitle( 'License/' . $extension['name'] ),
 824                                         $licenseName,
 825                                         [
 826                                                 'class' => 'mw-version-ext-license',
 827                                                 'dir' => 'auto',
 828                                         ]
 829                                 );
 830                         }
 831                 }
 832
 833                 // ... and generate the description; which can be a parameterized l10n message
 834                 // in the form [ <msgname>, <parameter>, <parameter>... ] or just a straight
 835                 // up string
 836                 if ( isset( $extension['descriptionmsg'] ) ) {
 837                         // Localized description of extension
 838                         $descriptionMsg = $extension['descriptionmsg'];
 839
 840                         if ( is_array( $descriptionMsg ) ) {
 841                                 $descriptionMsgKey = $descriptionMsg[0]; // Get the message key
 842                                 array_shift( $descriptionMsg ); // Shift out the message key to get the parameters only
 843                                 array_map( "htmlspecialchars", $descriptionMsg ); // For sanity
 844                                 $description = $this->msg( $descriptionMsgKey, $descriptionMsg )->text();
 845                         } else {
 846                                 $description = $this->msg( $descriptionMsg )->text();
 847                         }
 848                 } elseif ( isset( $extension['description'] ) ) {
 849                         // Non localized version
 850                         $description = $extension['description'];
 851                 } else {
 852                         $description = '';
 853                 }
 854                 $description = $out->parseInlineAsInterface( $description );
 855
 856                 // ... now get the authors for this extension
 857                 $authors = $extension['author'] ?? [];
 858                 $authors = $this->listAuthors( $authors, $extension['name'], $extensionPath );
 859
 860                 // Finally! Create the table
 861                 $html = Html::openElement( 'tr', [
 862                                 'class' => 'mw-version-ext',
 863                                 'id' => Sanitizer::escapeIdForAttribute( 'mw-version-ext-' . $type . '-' . $extension['name'] )
 864                         ]
 865                 );
 866
 867                 $html .= Html::rawElement( 'td', [], $extensionNameLink );
 868                 $html .= Html::rawElement( 'td', [], $versionString );
 869                 $html .= Html::rawElement( 'td', [], $licenseLink );
 870                 $html .= Html::rawElement( 'td', [ 'class' => 'mw-version-ext-description' ], $description );
 871                 $html .= Html::rawElement( 'td', [ 'class' => 'mw-version-ext-authors' ], $authors );
 872
 873                 $html .= Html::closeElement( 'tr' );
 874
 875                 return $html;
 876         }
 877
 878         /**
 879          * Generate wikitext showing hooks in $wgHooks.
 880          *
 881          * @return string Wikitext
 882          */
 883         private function getWgHooks() {
 884                 global $wgSpecialVersionShowHooks, $wgHooks;
 885
 886                 if ( $wgSpecialVersionShowHooks && count( $wgHooks ) ) {
 887                         $myWgHooks = $wgHooks;
 888                         ksort( $myWgHooks );
 889
 890                         $ret = [];
 891                         $ret[] = '== {{int:version-hooks}} ==';
 892                         $ret[] = Html::openElement( 'table', [ 'class' => 'wikitable', 'id' => 'sv-hooks' ] );
 893                         $ret[] = Html::openElement( 'tr' );
 894                         $ret[] = Html::element( 'th', [], $this->msg( 'version-hook-name' )->text() );
 895                         $ret[] = Html::element( 'th', [], $this->msg( 'version-hook-subscribedby' )->text() );
 896                         $ret[] = Html::closeElement( 'tr' );
 897
 898                         foreach ( $myWgHooks as $hook => $hooks ) {
 899                                 $ret[] = Html::openElement( 'tr' );
 900                                 $ret[] = Html::element( 'td', [], $hook );
 901                                 $ret[] = Html::element( 'td', [], $this->listToText( $hooks ) );
 902                                 $ret[] = Html::closeElement( 'tr' );
 903                         }
 904
 905                         $ret[] = Html::closeElement( 'table' );
 906
 907                         return implode( "\n", $ret );
 908                 }
 909
 910                 return '';
 911         }
 912
 913         private function openExtType( $text = null, $name = null ) {
 914                 $out = '';
 915
 916                 $opt = [ 'colspan' => 5 ];
 917                 if ( $this->firstExtOpened ) {
 918                         // Insert a spacing line
 919                         $out .= Html::rawElement( 'tr', [ 'class' => 'sv-space' ],
 920                                 Html::element( 'td', $opt )
 921                         );
 922                 }
 923                 $this->firstExtOpened = true;
 924
 925                 if ( $name ) {
 926                         $opt['id'] = "sv-$name";
 927                 }
 928
 929                 if ( $text !== null ) {
 930                         $out .= Html::rawElement( 'tr', [],
 931                                 Html::element( 'th', $opt, $text )
 932                         );
 933                 }
 934
 935                 $firstHeadingMsg = ( $name === 'credits-skin' )
 936                         ? 'version-skin-colheader-name'
 937                         : 'version-ext-colheader-name';
 938                 $out .= Html::openElement( 'tr' );
 939                 $out .= Html::element( 'th', [ 'class' => 'mw-version-ext-col-label' ],
 940                         $this->msg( $firstHeadingMsg )->text() );
 941                 $out .= Html::element( 'th', [ 'class' => 'mw-version-ext-col-label' ],
 942                         $this->msg( 'version-ext-colheader-version' )->text() );
 943                 $out .= Html::element( 'th', [ 'class' => 'mw-version-ext-col-label' ],
 944                         $this->msg( 'version-ext-colheader-license' )->text() );
 945                 $out .= Html::element( 'th', [ 'class' => 'mw-version-ext-col-label' ],
 946                         $this->msg( 'version-ext-colheader-description' )->text() );
 947                 $out .= Html::element( 'th', [ 'class' => 'mw-version-ext-col-label' ],
 948                         $this->msg( 'version-ext-colheader-credits' )->text() );
 949                 $out .= Html::closeElement( 'tr' );
 950
 951                 return $out;
 952         }
 953
 954         /**
 955          * Get information about client's IP address.
 956          *
 957          * @return string HTML fragment
 958          */
 959         private function IPInfo() {
 960                 $ip = str_replace( '--', ' - ', htmlspecialchars( $this->getRequest()->getIP() ) );
 961
 962                 return "<!-- visited from $ip -->\n<span style='display:none'>visited from $ip</span>";
 963         }
 964
 965         /**
 966          * Return a formatted unsorted list of authors
 967          *
 968          * 'And Others'
 969          *   If an item in the $authors array is '...' it is assumed to indicate an
 970          *   'and others' string which will then be linked to an ((AUTHORS)|(CREDITS))(\.txt)?
 971          *   file if it exists in $dir.
 972          *
 973          *   Similarly an entry ending with ' ...]' is assumed to be a link to an
 974          *   'and others' page.
 975          *
 976          *   If no '...' string variant is found, but an authors file is found an
 977          *   'and others' will be added to the end of the credits.
 978          *
 979          * @param string|array $authors
 980          * @param string|bool $extName Name of the extension for link creation,
 981          *   false if no links should be created
 982          * @param string $extDir Path to the extension root directory
 983          *
 984          * @return string HTML fragment
 985          */
 986         public function listAuthors( $authors, $extName, $extDir ) {
 987                 $hasOthers = false;
 988                 $linkRenderer = $this->getLinkRenderer();
 989
 990                 $list = [];
 991                 $authors = (array)$authors;
 992
 993                 // Special case: if the authors array has only one item and it is "...",
 994                 // it should not be rendered as the "version-poweredby-others" i18n msg,
 995                 // but rather as "version-poweredby-various" i18n msg instead.
 996                 if ( count( $authors ) === 1 && $authors[0] === '...' ) {
 997                         // Link to the extension's or skin's AUTHORS or CREDITS file, if there is
 998                         // such a file; otherwise just return the i18n msg as-is
 999                         if ( $extName && $this->getExtAuthorsFileName( $extDir ) ) {
1000                                 return $linkRenderer->makeLink(
1001                                         $this->getPageTitle( "Credits/$extName" ),
1002                                         $this->msg( 'version-poweredby-various' )->text()
1003                                 );
1004                         } else {
1005                                 return $this->msg( 'version-poweredby-various' )->escaped();
1006                         }
1007                 }
1008
1009                 // Otherwise, if we have an actual array that has more than one item,
1010                 // process each array item as usual
1011                 foreach ( $authors as $item ) {
1012                         if ( $item == '...' ) {
1013                                 $hasOthers = true;
1014
1015                                 if ( $extName && $this->getExtAuthorsFileName( $extDir ) ) {
1016                                         $text = $linkRenderer->makeLink(
1017                                                 $this->getPageTitle( "Credits/$extName" ),
1018                                                 $this->msg( 'version-poweredby-others' )->text()
1019                                         );
1020                                 } else {
1021                                         $text = $this->msg( 'version-poweredby-others' )->escaped();
1022                                 }
1023                                 $list[] = $text;
1024                         } elseif ( substr( $item, -5 ) == ' ...]' ) {
1025                                 $hasOthers = true;
1026                                 $list[] = $this->getOutput()->parseInlineAsInterface(
1027                                         substr( $item, 0, -4 ) . $this->msg( 'version-poweredby-others' )->text() . "]"
1028                                 );
1029                         } else {
1030                                 $list[] = $this->getOutput()->parseInlineAsInterface( $item );
1031                         }
1032                 }
1033
1034                 if ( $extName && !$hasOthers && $this->getExtAuthorsFileName( $extDir ) ) {
1035                         $list[] = $text = $linkRenderer->makeLink(
1036                                 $this->getPageTitle( "Credits/$extName" ),
1037                                 $this->msg( 'version-poweredby-others' )->text()
1038                         );
1039                 }
1040
1041                 return $this->listToText( $list, false );
1042         }
1043
1044         /**
1045          * Obtains the full path of an extensions authors or credits file if
1046          * one exists.
1047          *
1048          * @param string $extDir Path to the extensions root directory
1049          *
1050          * @since 1.23
1051          *
1052          * @return bool|string False if no such file exists, otherwise returns
1053          * a path to it.
1054          */
1055         public static function getExtAuthorsFileName( $extDir ) {
1056                 if ( !$extDir ) {
1057                         return false;
1058                 }
1059
1060                 foreach ( scandir( $extDir ) as $file ) {
1061                         $fullPath = $extDir . DIRECTORY_SEPARATOR . $file;
1062                         if ( preg_match( '/^((AUTHORS)|(CREDITS))(\.txt|\.wiki|\.mediawiki)?$/', $file ) &&
1063                                 is_readable( $fullPath ) &&
1064                                 is_file( $fullPath )
1065                         ) {
1066                                 return $fullPath;
1067                         }
1068                 }
1069
1070                 return false;
1071         }
1072
1073         /**
1074          * Obtains the full path of an extensions copying or license file if
1075          * one exists.
1076          *
1077          * @param string $extDir Path to the extensions root directory
1078          *
1079          * @since 1.23
1080          *
1081          * @return bool|string False if no such file exists, otherwise returns
1082          * a path to it.
1083          */
1084         public static function getExtLicenseFileName( $extDir ) {
1085                 if ( !$extDir ) {
1086                         return false;
1087                 }
1088
1089                 foreach ( scandir( $extDir ) as $file ) {
1090                         $fullPath = $extDir . DIRECTORY_SEPARATOR . $file;
1091                         if ( preg_match( '/^((COPYING)|(LICENSE))(\.txt)?$/', $file ) &&
1092                                 is_readable( $fullPath ) &&
1093                                 is_file( $fullPath )
1094                         ) {
1095                                 return $fullPath;
1096                         }
1097                 }
1098
1099                 return false;
1100         }
1101
1102         /**
1103          * Convert an array of items into a list for display.
1104          *
1105          * @param array $list List of elements to display
1106          * @param bool $sort Whether to sort the items in $list
1107          *
1108          * @return string
1109          */
1110         public function listToText( $list, $sort = true ) {
1111                 if ( !count( $list ) ) {
1112                         return '';
1113                 }
1114                 if ( $sort ) {
1115                         sort( $list );
1116                 }
1117
1118                 return $this->getLanguage()
1119                         ->listToText( array_map( [ __CLASS__, 'arrayToString' ], $list ) );
1120         }
1121
1122         /**
1123          * Convert an array or object to a string for display.
1124          *
1125          * @param mixed $list Will convert an array to string if given and return
1126          *   the parameter unaltered otherwise
1127          *
1128          * @return mixed
1129          */
1130         public static function arrayToString( $list ) {
1131                 if ( is_array( $list ) && count( $list ) == 1 ) {
1132                         $list = $list[0];
1133                 }
1134                 if ( $list instanceof Closure ) {
1135                         // Don't output stuff like "Closure$;1028376090#8$48499d94fe0147f7c633b365be39952b$"
1136                         return 'Closure';
1137                 } elseif ( is_object( $list ) ) {
1138                         $class = wfMessage( 'parentheses' )->params( get_class( $list ) )->escaped();
1139
1140                         return $class;
1141                 } elseif ( !is_array( $list ) ) {
1142                         return $list;
1143                 } else {
1144                         if ( is_object( $list[0] ) ) {
1145                                 $class = get_class( $list[0] );
1146                         } else {
1147                                 $class = $list[0];
1148                         }
1149
1150                         return wfMessage( 'parentheses' )->params( "$class, {$list[1]}" )->escaped();
1151                 }
1152         }
1153
1154         /**
1155          * @param string $dir Directory of the git checkout
1156          * @return bool|string Sha1 of commit HEAD points to
1157          */
1158         public static function getGitHeadSha1( $dir ) {
1159                 $repo = new GitInfo( $dir );
1160
1161                 return $repo->getHeadSHA1();
1162         }
1163
1164         /**
1165          * @param string $dir Directory of the git checkout
1166          * @return bool|string Branch currently checked out
1167          */
1168         public static function getGitCurrentBranch( $dir ) {
1169                 $repo = new GitInfo( $dir );
1170                 return $repo->getCurrentBranch();
1171         }
1172
1173         /**
1174          * Get the list of entry points and their URLs
1175          * @return string Wikitext
1176          */
1177         public function getEntryPointInfo() {
1178                 $config = $this->getConfig();
1179                 $scriptPath = $config->get( 'ScriptPath' ) ?: '/';
1180
1181                 $entryPoints = [
1182                         'version-entrypoints-articlepath' => $config->get( 'ArticlePath' ),
1183                         'version-entrypoints-scriptpath' => $scriptPath,
1184                         'version-entrypoints-index-php' => wfScript( 'index' ),
1185                         'version-entrypoints-api-php' => wfScript( 'api' ),
1186                         'version-entrypoints-load-php' => wfScript( 'load' ),
1187                 ];
1188
1189                 $language = $this->getLanguage();
1190                 $thAttribures = [
1191                         'dir' => $language->getDir(),
1192                         'lang' => $language->getHtmlCode()
1193                 ];
1194                 $out = Html::element(
1195                                 'h2',
1196                                 [ 'id' => 'mw-version-entrypoints' ],
1197                                 $this->msg( 'version-entrypoints' )->text()
1198                         ) .
1199                         Html::openElement( 'table',
1200                                 [
1201                                         'class' => 'wikitable plainlinks',
1202                                         'id' => 'mw-version-entrypoints-table',
1203                                         'dir' => 'ltr',
1204                                         'lang' => 'en'
1205                                 ]
1206                         ) .
1207                         Html::openElement( 'tr' ) .
1208                         Html::element(
1209                                 'th',
1210                                 $thAttribures,
1211                                 $this->msg( 'version-entrypoints-header-entrypoint' )->text()
1212                         ) .
1213                         Html::element(
1214                                 'th',
1215                                 $thAttribures,
1216                                 $this->msg( 'version-entrypoints-header-url' )->text()
1217                         ) .
1218                         Html::closeElement( 'tr' );
1219
1220                 foreach ( $entryPoints as $message => $value ) {
1221                         $url = wfExpandUrl( $value, PROTO_RELATIVE );
1222                         $out .= Html::openElement( 'tr' ) .
1223                                 // ->plain() looks like it should be ->parse(), but this function
1224                                 // returns wikitext, not HTML, boo
1225                                 Html::rawElement( 'td', [], $this->msg( $message )->plain() ) .
1226                                 Html::rawElement( 'td', [], Html::rawElement( 'code', [], "[$url $value]" ) ) .
1227                                 Html::closeElement( 'tr' );
1228                 }
1229
1230                 $out .= Html::closeElement( 'table' );
1231
1232                 return $out;
1233         }
1234
1235         protected function getGroupName() {
1236                 return 'wiki';
1237         }
1238 }