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