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