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