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
  33         protected $firstExtOpened = false;
  34
  35         protected static $extensionTypes = false;
  36
  37         protected static $viewvcUrls = array(
  38                 'svn+ssh://svn.wikimedia.org/svnroot/mediawiki' => 'http://svn.wikimedia.org/viewvc/mediawiki',
  39                 'http://svn.wikimedia.org/svnroot/mediawiki' => 'http://svn.wikimedia.org/viewvc/mediawiki',
  40                 'https://svn.wikimedia.org/svnroot/mediawiki' => 'https://svn.wikimedia.org/viewvc/mediawiki',
  41         );
  42
  43         public function __construct() {
  44                 parent::__construct( 'Version' );
  45         }
  46
  47         /**
  48          * main()
  49          */
  50         public function execute( $par ) {
  51                 global $wgSpecialVersionShowHooks, $IP;
  52
  53                 $this->setHeaders();
  54                 $this->outputHeader();
  55                 $out = $this->getOutput();
  56                 $out->allowClickjacking();
  57
  58                 if( $par !== 'Credits' ) {
  59                         $text =
  60                                 $this->getMediaWikiCredits() .
  61                                 $this->softwareInformation() .
  62                                 $this->getEntryPointInfo() .
  63                                 $this->getExtensionCredits();
  64                         if ( $wgSpecialVersionShowHooks ) {
  65                                 $text .= $this->getWgHooks();
  66                         }
  67
  68                         $out->addWikiText( $text );
  69                         $out->addHTML( $this->IPInfo() );
  70
  71                         if ( $this->getRequest()->getVal( 'easteregg' ) ) {
  72                                 // TODO: put something interesting here
  73                         }
  74                 } else {
  75                         // Credits sub page
  76
  77                         // Header
  78                         $out->addHTML( wfMessage( 'version-credits-summary' )->parseAsBlock() );
  79
  80                         $wikiText = file_get_contents( $IP . '/CREDITS' );
  81
  82                         // Take everything from the first section onwards, to remove the (not localized) header
  83                         $wikiText = substr( $wikiText, strpos( $wikiText, '==' ) );
  84
  85                         $out->addWikiText( $wikiText );
  86                 }
  87         }
  88
  89         /**
  90          * Returns wiki text showing the license information.
  91          *
  92          * @return string
  93          */
  94         private static function getMediaWikiCredits() {
  95                 $ret = Xml::element( 'h2', array( 'id' => 'mw-version-license' ), wfMessage( 'version-license' )->text() );
  96
  97                 // This text is always left-to-right.
  98                 $ret .= '<div class="plainlinks">';
  99                 $ret .= "__NOTOC__
 100                 " . self::getCopyrightAndAuthorList() . "\n
 101                 " . wfMessage( 'version-license-info' )->text();
 102                 $ret .= '</div>';
 103
 104                 return str_replace( "\t\t", '', $ret ) . "\n";
 105         }
 106
 107         /**
 108          * Get the "MediaWiki is copyright 2001-20xx by lots of cool guys" text
 109          *
 110          * @return String
 111          */
 112         public static function getCopyrightAndAuthorList() {
 113                 global $wgLang;
 114
 115                 if ( defined( 'MEDIAWIKI_INSTALL' ) ) {
 116                         $othersLink = '[http://www.mediawiki.org/wiki/Special:Version/Credits ' . wfMessage( 'version-poweredby-others' )->text() . ']';
 117                 } else {
 118                         $othersLink = '[[Special:Version/Credits|' . wfMessage( 'version-poweredby-others' )->text() . ']]';
 119                 }
 120
 121                 $authorList = array(
 122                         'Magnus Manske', 'Brion Vibber', 'Lee Daniel Crocker',
 123                         'Tim Starling', 'Erik Möller', 'Gabriel Wicke', 'Ævar Arnfjörð Bjarmason',
 124                         'Niklas Laxström', 'Domas Mituzas', 'Rob Church', 'Yuri Astrakhan',
 125                         'Aryeh Gregor', 'Aaron Schulz', 'Andrew Garrett', 'Raimond Spekking',
 126                         'Alexandre Emsenhuber', 'Siebrand Mazeland', 'Chad Horohoe',
 127                         'Roan Kattouw', 'Trevor Parscal', 'Bryan Tong Minh', 'Sam Reed',
 128                         'Victor Vasiliev', 'Rotem Liss', 'Platonides', 'Antoine Musso',
 129                         'Timo Tijhof', 'Daniel Kinzler', 'Jeroen De Dauw', $othersLink
 130                 );
 131
 132                 return wfMessage( 'version-poweredby-credits', date( 'Y' ),
 133                         $wgLang->listToText( $authorList ) )->text();
 134         }
 135
 136         /**
 137          * Returns wiki text showing the third party software versions (apache, php, mysql).
 138          *
 139          * @return string
 140          */
 141         static function softwareInformation() {
 142                 $dbr = wfGetDB( DB_SLAVE );
 143
 144                 // Put the software in an array of form 'name' => 'version'. All messages should
 145                 // be loaded here, so feel free to use wfMessage in the 'name'. Raw HTML or
 146                 // wikimarkup can be used.
 147                 $software = array();
 148                 $software['[https://www.mediawiki.org/ MediaWiki]'] = self::getVersionLinked();
 149                 $software['[http://www.php.net/ PHP]'] = phpversion() . " (" . PHP_SAPI . ")";
 150                 $software[$dbr->getSoftwareLink()] = $dbr->getServerInfo();
 151
 152                 // Allow a hook to add/remove items.
 153                 wfRunHooks( 'SoftwareInfo', array( &$software ) );
 154
 155                 $out = Xml::element( 'h2', array( 'id' => 'mw-version-software' ), wfMessage( 'version-software' )->text() ) .
 156                                 Xml::openElement( 'table', array( 'class' => 'wikitable plainlinks', 'id' => 'sv-software' ) ) .
 157                                 "<tr>
 158                                         <th>" . wfMessage( 'version-software-product' )->text() . "</th>
 159                                         <th>" . wfMessage( 'version-software-version' )->text() . "</th>
 160                                 </tr>\n";
 161
 162                 foreach( $software as $name => $version ) {
 163                         $out .= "<tr>
 164                                         <td>" . $name . "</td>
 165                                         <td dir=\"ltr\">" . $version . "</td>
 166                                 </tr>\n";
 167                 }
 168
 169                 return $out . Xml::closeElement( 'table' );
 170         }
 171
 172         /**
 173          * Return a string of the MediaWiki version with SVN revision if available.
 174          *
 175          * @param $flags String
 176          * @return mixed
 177          */
 178         public static function getVersion( $flags = '' ) {
 179                 global $wgVersion, $IP;
 180                 wfProfileIn( __METHOD__ );
 181
 182                 $gitInfo = self::getGitHeadSha1( $IP );
 183                 $svnInfo = self::getSvnInfo( $IP );
 184                 if ( !$svnInfo && !$gitInfo ) {
 185                         $version = $wgVersion;
 186                 } elseif ( $gitInfo && $flags === 'nodb' ) {
 187                         $shortSha1 = substr( $gitInfo, 0, 7 );
 188                         $version = "$wgVersion ($shortSha1)";
 189                 } elseif ( $gitInfo ) {
 190                         $shortSha1 = substr( $gitInfo, 0, 7 );
 191                         $shortSha1 = wfMessage( 'parentheses' )->params( $shortSha1 )->escaped();
 192                         $version = "$wgVersion $shortSha1";
 193                 } elseif ( $flags === 'nodb' ) {
 194                         $version = "$wgVersion (r{$svnInfo['checkout-rev']})";
 195                 } else {
 196                         $version = $wgVersion . ' ' .
 197                                 wfMessage(
 198                                         'version-svn-revision',
 199                                         isset( $info['directory-rev'] ) ? $info['directory-rev'] : '',
 200                                         $info['checkout-rev']
 201                                 )->text();
 202                 }
 203
 204                 wfProfileOut( __METHOD__ );
 205                 return $version;
 206         }
 207
 208         /**
 209          * Return a wikitext-formatted string of the MediaWiki version with a link to
 210          * the SVN revision or the git SHA1 of head if available.
 211          * Git is prefered over Svn
 212          * The fallback is just $wgVersion
 213          *
 214          * @return mixed
 215          */
 216         public static function getVersionLinked() {
 217                 global $wgVersion;
 218                 wfProfileIn( __METHOD__ );
 219
 220                 $gitVersion = self::getVersionLinkedGit();
 221                 if( $gitVersion ) {
 222                         $v = $gitVersion;
 223                 } else {
 224                         $svnVersion = self::getVersionLinkedSvn();
 225                         if( $svnVersion ) {
 226                                 $v = $svnVersion;
 227                         } else {
 228                                 $v = $wgVersion; // fallback
 229                         }
 230                 }
 231
 232                 wfProfileOut( __METHOD__ );
 233                 return $v;
 234         }
 235
 236         /**
 237          * @return string wgVersion + a link to subversion revision of svn BASE
 238          */
 239         private static function getVersionLinkedSvn() {
 240                 global $IP;
 241
 242                 $info = self::getSvnInfo( $IP );
 243                 if( !isset( $info['checkout-rev'] ) ) {
 244                         return false;
 245                 }
 246
 247                 $linkText = wfMessage(
 248                         'version-svn-revision',
 249                         isset( $info['directory-rev'] ) ? $info['directory-rev'] : '',
 250                         $info['checkout-rev']
 251                 )->text();
 252
 253                 if ( isset( $info['viewvc-url'] ) ) {
 254                         $version = "[{$info['viewvc-url']} $linkText]";
 255                 } else {
 256                         $version = $linkText;
 257                 }
 258
 259                 return self::getwgVersionLinked() . " $version";
 260         }
 261
 262         /**
 263          * @return string
 264          */
 265         private static function getwgVersionLinked() {
 266                 global $wgVersion;
 267                 $versionUrl = "";
 268                 if( wfRunHooks( 'SpecialVersionVersionUrl', array( $wgVersion, &$versionUrl ) ) ) {
 269                         $versionParts = array();
 270                         preg_match( "/^(\d+\.\d+)/", $wgVersion, $versionParts );
 271                         $versionUrl = "https://www.mediawiki.org/wiki/MediaWiki_{$versionParts[1]}";
 272                 }
 273                 return "[$versionUrl $wgVersion]";
 274         }
 275
 276         /**
 277          * @since 1.22 Returns the HEAD date in addition to the sha1 and link
 278          * @return bool|string wgVersion + HEAD sha1 stripped to the first 7 chars with link and date, or false on failure
 279          */
 280         private static function getVersionLinkedGit() {
 281                 global $IP, $wgLang;
 282
 283                 $gitInfo = new GitInfo( $IP );
 284                 $headSHA1 = $gitInfo->getHeadSHA1();
 285                 if( !$headSHA1 ) {
 286                         return false;
 287                 }
 288
 289                 $shortSHA1 = '(' . substr( $headSHA1, 0, 7 ) . ')';
 290
 291                 $gitHeadUrl = $gitInfo->getHeadViewUrl();
 292                 if ( $gitHeadUrl !== false ) {
 293                         $shortSHA1 = "[$gitHeadUrl $shortSHA1]";
 294                 }
 295
 296                 $gitHeadCommitDate = $gitInfo->getHeadCommitDate();
 297                 if ( $gitHeadCommitDate ) {
 298                         $shortSHA1 .= "<br/>" . $wgLang->timeanddate( $gitHeadCommitDate, true );
 299                 }
 300
 301                 return self::getwgVersionLinked() . " $shortSHA1";
 302         }
 303
 304         /**
 305          * Returns an array with the base extension types.
 306          * Type is stored as array key, the message as array value.
 307          *
 308          * TODO: ideally this would return all extension types, including
 309          * those added by SpecialVersionExtensionTypes. This is not possible
 310          * since this hook is passing along $this though.
 311          *
 312          * @since 1.17
 313          *
 314          * @return array
 315          */
 316         public static function getExtensionTypes() {
 317                 if ( self::$extensionTypes === false ) {
 318                         self::$extensionTypes = array(
 319                                 'specialpage' => wfMessage( 'version-specialpages' )->text(),
 320                                 'parserhook' => wfMessage( 'version-parserhooks' )->text(),
 321                                 'variable' => wfMessage( 'version-variables' )->text(),
 322                                 'media' => wfMessage( 'version-mediahandlers' )->text(),
 323                                 'antispam' => wfMessage( 'version-antispam' )->text(),
 324                                 'skin' => wfMessage( 'version-skins' )->text(),
 325                                 'api' => wfMessage( 'version-api' )->text(),
 326                                 'other' => wfMessage( 'version-other' )->text(),
 327                         );
 328
 329                         wfRunHooks( 'ExtensionTypes', array( &self::$extensionTypes ) );
 330                 }
 331
 332                 return self::$extensionTypes;
 333         }
 334
 335         /**
 336          * Returns the internationalized name for an extension type.
 337          *
 338          * @since 1.17
 339          *
 340          * @param $type String
 341          *
 342          * @return string
 343          */
 344         public static function getExtensionTypeName( $type ) {
 345                 $types = self::getExtensionTypes();
 346                 return isset( $types[$type] ) ? $types[$type] : $types['other'];
 347         }
 348
 349         /**
 350          * Generate wikitext showing extensions name, URL, author and description.
 351          *
 352          * @return String: Wikitext
 353          */
 354         function getExtensionCredits() {
 355                 global $wgExtensionCredits, $wgExtensionFunctions, $wgParser;
 356
 357                 if ( !count( $wgExtensionCredits ) && !count( $wgExtensionFunctions ) ) {
 358                         return '';
 359                 }
 360
 361                 $extensionTypes = self::getExtensionTypes();
 362
 363                 /**
 364                  * @deprecated as of 1.17, use hook ExtensionTypes instead.
 365                  */
 366                 wfRunHooks( 'SpecialVersionExtensionTypes', array( &$this, &$extensionTypes ) );
 367
 368                 $out = Xml::element( 'h2', array( 'id' => 'mw-version-ext' ), $this->msg( 'version-extensions' )->text() ) .
 369                         Xml::openElement( 'table', array( 'class' => 'wikitable plainlinks', 'id' => 'sv-ext' ) );
 370
 371                 // Make sure the 'other' type is set to an array.
 372                 if ( !array_key_exists( 'other', $wgExtensionCredits ) ) {
 373                         $wgExtensionCredits['other'] = array();
 374                 }
 375
 376                 // Find all extensions that do not have a valid type and give them the type 'other'.
 377                 foreach ( $wgExtensionCredits as $type => $extensions ) {
 378                         if ( !array_key_exists( $type, $extensionTypes ) ) {
 379                                 $wgExtensionCredits['other'] = array_merge( $wgExtensionCredits['other'], $extensions );
 380                         }
 381                 }
 382
 383                 // Loop through the extension categories to display their extensions in the list.
 384                 foreach ( $extensionTypes as $type => $message ) {
 385                         if ( $type != 'other' ) {
 386                                 $out .= $this->getExtensionCategory( $type, $message );
 387                         }
 388                 }
 389
 390                 // We want the 'other' type to be last in the list.
 391                 $out .= $this->getExtensionCategory( 'other', $extensionTypes['other'] );
 392
 393                 if ( count( $wgExtensionFunctions ) ) {
 394                         $out .= $this->openExtType( $this->msg( 'version-extension-functions' )->text(), 'extension-functions' );
 395                         $out .= '<tr><td colspan="4">' . $this->listToText( $wgExtensionFunctions ) . "</td></tr>\n";
 396                 }
 397
 398                 $tags = $wgParser->getTags();
 399                 $cnt = count( $tags );
 400
 401                 if ( $cnt ) {
 402                         for ( $i = 0; $i < $cnt; ++$i ) {
 403                                 $tags[$i] = "&lt;{$tags[$i]}&gt;";
 404                         }
 405                         $out .= $this->openExtType( $this->msg( 'version-parser-extensiontags' )->text(), 'parser-tags' );
 406                         $out .= '<tr><td colspan="4">' . $this->listToText( $tags ) . "</td></tr>\n";
 407                 }
 408
 409                 $fhooks = $wgParser->getFunctionHooks();
 410                 if( count( $fhooks ) ) {
 411                         $out .= $this->openExtType( $this->msg( 'version-parser-function-hooks' )->text(), 'parser-function-hooks' );
 412                         $out .= '<tr><td colspan="4">' . $this->listToText( $fhooks ) . "</td></tr>\n";
 413                 }
 414
 415                 $out .= Xml::closeElement( 'table' );
 416
 417                 return $out;
 418         }
 419
 420         /**
 421          * Creates and returns the HTML for a single extension category.
 422          *
 423          * @since 1.17
 424          *
 425          * @param $type String
 426          * @param $message String
 427          *
 428          * @return string
 429          */
 430         protected function getExtensionCategory( $type, $message ) {
 431                 global $wgExtensionCredits;
 432
 433                 $out = '';
 434
 435                 if ( array_key_exists( $type, $wgExtensionCredits ) && count( $wgExtensionCredits[$type] ) > 0 ) {
 436                         $out .= $this->openExtType( $message, 'credits-' . $type );
 437
 438                         usort( $wgExtensionCredits[$type], array( $this, 'compare' ) );
 439
 440                         foreach ( $wgExtensionCredits[$type] as $extension ) {
 441                                 $out .= $this->getCreditsForExtension( $extension );
 442                         }
 443                 }
 444
 445                 return $out;
 446         }
 447
 448         /**
 449          * Callback to sort extensions by type.
 450          * @param $a array
 451          * @param $b array
 452          * @return int
 453          */
 454         function compare( $a, $b ) {
 455                 if( $a['name'] === $b['name'] ) {
 456                         return 0;
 457                 } else {
 458                         return $this->getLanguage()->lc( $a['name'] ) > $this->getLanguage()->lc( $b['name'] )
 459                                 ? 1
 460                                 : -1;
 461                 }
 462         }
 463
 464         /**
 465          * Creates and formats the credits for a single extension and returns this.
 466          *
 467          * @param $extension Array
 468          *
 469          * @return string
 470          */
 471         function getCreditsForExtension( array $extension ) {
 472                 global $wgLang;
 473
 474                 $name = isset( $extension['name'] ) ? $extension['name'] : '[no name]';
 475
 476                 $vcsText = false;
 477
 478                 if ( isset( $extension['path'] ) ) {
 479                         $gitInfo = new GitInfo( dirname( $extension['path'] ) );
 480                         $gitHeadSHA1 = $gitInfo->getHeadSHA1();
 481                         if ( $gitHeadSHA1 !== false ) {
 482                                 $vcsText = '(' . substr( $gitHeadSHA1, 0, 7 ) . ')';
 483                                 $gitViewerUrl = $gitInfo->getHeadViewUrl();
 484                                 if ( $gitViewerUrl !== false ) {
 485                                         $vcsText = "[$gitViewerUrl $vcsText]";
 486                                 }
 487                                 $gitHeadCommitDate = $gitInfo->getHeadCommitDate();
 488                                 if ( $gitHeadCommitDate ) {
 489                                         $vcsText .= "<br/>" .  $wgLang->timeanddate( $gitHeadCommitDate, true );
 490                                 }
 491                         } else {
 492                                 $svnInfo = self::getSvnInfo( dirname( $extension['path'] ) );
 493                                 # Make subversion text/link.
 494                                 if ( $svnInfo !== false ) {
 495                                         $directoryRev = isset( $svnInfo['directory-rev'] ) ? $svnInfo['directory-rev'] : null;
 496                                         $vcsText = $this->msg( 'version-svn-revision', $directoryRev, $svnInfo['checkout-rev'] )->text();
 497                                         $vcsText = isset( $svnInfo['viewvc-url'] ) ? '[' . $svnInfo['viewvc-url'] . " $vcsText]" : $vcsText;
 498                                 }
 499                         }
 500                 }
 501
 502                 # Make main link (or just the name if there is no URL).
 503                 if ( isset( $extension['url'] ) ) {
 504                         $mainLink = "[{$extension['url']} $name]";
 505                 } else {
 506                         $mainLink = $name;
 507                 }
 508
 509                 if ( isset( $extension['version'] ) ) {
 510                         $versionText = '<span class="mw-version-ext-version">' .
 511                                 $this->msg( 'version-version', $extension['version'] )->text() .
 512                                 '</span>';
 513                 } else {
 514                         $versionText = '';
 515                 }
 516
 517                 # Make description text.
 518                 $description = isset ( $extension['description'] ) ? $extension['description'] : '';
 519
 520                 if( isset ( $extension['descriptionmsg'] ) ) {
 521                         # Look for a localized description.
 522                         $descriptionMsg = $extension['descriptionmsg'];
 523
 524                         if( is_array( $descriptionMsg ) ) {
 525                                 $descriptionMsgKey = $descriptionMsg[0]; // Get the message key
 526                                 array_shift( $descriptionMsg ); // Shift out the message key to get the parameters only
 527                                 array_map( "htmlspecialchars", $descriptionMsg ); // For sanity
 528                                 $description = $this->msg( $descriptionMsgKey, $descriptionMsg )->text();
 529                         } else {
 530                                 $description = $this->msg( $descriptionMsg )->text();
 531                         }
 532                 }
 533
 534                 if ( $vcsText !== false ) {
 535                         $extNameVer = "<tr>
 536                                 <td><em>$mainLink $versionText</em></td>
 537                                 <td><em>$vcsText</em></td>";
 538                 } else {
 539                         $extNameVer = "<tr>
 540                                 <td colspan=\"2\"><em>$mainLink $versionText</em></td>";
 541                 }
 542
 543                 $author = isset ( $extension['author'] ) ? $extension['author'] : array();
 544                 $extDescAuthor = "<td>$description</td>
 545                         <td>" . $this->listAuthors( $author, false ) . "</td>
 546                         </tr>\n";
 547
 548                 return $extNameVer . $extDescAuthor;
 549         }
 550
 551         /**
 552          * Generate wikitext showing hooks in $wgHooks.
 553          *
 554          * @return String: wikitext
 555          */
 556         private function getWgHooks() {
 557                 global $wgHooks;
 558
 559                 if ( count( $wgHooks ) ) {
 560                         $myWgHooks = $wgHooks;
 561                         ksort( $myWgHooks );
 562
 563                         $ret = Xml::element( 'h2', array( 'id' => 'mw-version-hooks' ), $this->msg( 'version-hooks' )->text() ) .
 564                                 Xml::openElement( 'table', array( 'class' => 'wikitable', 'id' => 'sv-hooks' ) ) .
 565                                 "<tr>
 566                                         <th>" . $this->msg( 'version-hook-name' )->text() . "</th>
 567                                         <th>" . $this->msg( 'version-hook-subscribedby' )->text() . "</th>
 568                                 </tr>\n";
 569
 570                         foreach ( $myWgHooks as $hook => $hooks ) {
 571                                 $ret .= "<tr>
 572                                                 <td>$hook</td>
 573                                                 <td>" . $this->listToText( $hooks ) . "</td>
 574                                         </tr>\n";
 575                         }
 576
 577                         $ret .= Xml::closeElement( 'table' );
 578                         return $ret;
 579                 } else
 580                         return '';
 581         }
 582
 583         private function openExtType( $text, $name = null ) {
 584                 $opt = array( 'colspan' => 4 );
 585                 $out = '';
 586
 587                 if( $this->firstExtOpened ) {
 588                         // Insert a spacing line
 589                         $out .= '<tr class="sv-space">' . Html::element( 'td', $opt ) . "</tr>\n";
 590                 }
 591                 $this->firstExtOpened = true;
 592
 593                 if( $name ) {
 594                         $opt['id'] = "sv-$name";
 595                 }
 596
 597                 $out .= "<tr>" . Xml::element( 'th', $opt, $text ) . "</tr>\n";
 598
 599                 return $out;
 600         }
 601
 602         /**
 603          * Get information about client's IP address.
 604          *
 605          * @return String: HTML fragment
 606          */
 607         private function IPInfo() {
 608                 $ip = str_replace( '--', ' - ', htmlspecialchars( $this->getRequest()->getIP() ) );
 609                 return "<!-- visited from $ip -->\n<span style='display:none'>visited from $ip</span>";
 610         }
 611
 612         /**
 613          * Return a formatted unsorted list of authors
 614          *
 615          * @param $authors mixed: string or array of strings
 616          * @return String: HTML fragment
 617          */
 618         function listAuthors( $authors ) {
 619                 $list = array();
 620                 foreach( (array)$authors as $item ) {
 621                         if ( $item == '...' ) {
 622                                 $list[] = $this->msg( 'version-poweredby-others' )->text();
 623                         } elseif ( substr( $item, -5 ) == ' ...]' ) {
 624                                 $list[] = substr( $item, 0, -4 ) . $this->msg( 'version-poweredby-others' )->text() . "]";
 625                         } else {
 626                                 $list[] = $item;
 627                         }
 628                 }
 629                 return $this->listToText( $list, false );
 630         }
 631
 632         /**
 633          * Convert an array of items into a list for display.
 634          *
 635          * @param array $list of elements to display
 636          * @param $sort Boolean: whether to sort the items in $list
 637          *
 638          * @return String
 639          */
 640         function listToText( $list, $sort = true ) {
 641                 $cnt = count( $list );
 642
 643                 if ( $cnt == 1 ) {
 644                         // Enforce always returning a string
 645                         return (string)self::arrayToString( $list[0] );
 646                 } elseif ( $cnt == 0 ) {
 647                         return '';
 648                 } else {
 649                         if ( $sort ) {
 650                                 sort( $list );
 651                         }
 652                         return $this->getLanguage()->listToText( array_map( array( __CLASS__, 'arrayToString' ), $list ) );
 653                 }
 654         }
 655
 656         /**
 657          * Convert an array or object to a string for display.
 658          *
 659          * @param $list Mixed: will convert an array to string if given and return
 660          *              the paramater unaltered otherwise
 661          *
 662          * @return Mixed
 663          */
 664         public static function arrayToString( $list ) {
 665                 if( is_array( $list ) && count( $list ) == 1 ) {
 666                         $list = $list[0];
 667                 }
 668                 if( is_object( $list ) ) {
 669                         $class = wfMessage( 'parentheses' )->params( get_class( $list ) )->escaped();
 670                         return $class;
 671                 } elseif ( !is_array( $list ) ) {
 672                         return $list;
 673                 } else {
 674                         if( is_object( $list[0] ) ) {
 675                                 $class = get_class( $list[0] );
 676                         } else {
 677                                 $class = $list[0];
 678                         }
 679                         return wfMessage( 'parentheses' )->params( "$class, {$list[1]}" )->escaped();
 680                 }
 681         }
 682
 683         /**
 684          * Get an associative array of information about a given path, from its .svn
 685          * subdirectory. Returns false on error, such as if the directory was not
 686          * checked out with subversion.
 687          *
 688          * Returned keys are:
 689          *    Required:
 690          *        checkout-rev          The revision which was checked out
 691          *    Optional:
 692          *        directory-rev         The revision when the directory was last modified
 693          *        url                   The subversion URL of the directory
 694          *        repo-url              The base URL of the repository
 695          *        viewvc-url            A ViewVC URL pointing to the checked-out revision
 696          * @param $dir string
 697          * @return array|bool
 698          */
 699         public static function getSvnInfo( $dir ) {
 700                 // http://svnbook.red-bean.com/nightly/en/svn.developer.insidewc.html
 701                 $entries = $dir . '/.svn/entries';
 702
 703                 if( !file_exists( $entries ) ) {
 704                         return false;
 705                 }
 706
 707                 $lines = file( $entries );
 708                 if ( !count( $lines ) ) {
 709                         return false;
 710                 }
 711
 712                 // check if file is xml (subversion release <= 1.3) or not (subversion release = 1.4)
 713                 if( preg_match( '/^<\?xml/', $lines[0] ) ) {
 714                         // subversion is release <= 1.3
 715                         if( !function_exists( 'simplexml_load_file' ) ) {
 716                                 // We could fall back to expat... YUCK
 717                                 return false;
 718                         }
 719
 720                         // SimpleXml whines about the xmlns...
 721                         wfSuppressWarnings();
 722                         $xml = simplexml_load_file( $entries );
 723                         wfRestoreWarnings();
 724
 725                         if( $xml ) {
 726                                 foreach( $xml->entry as $entry ) {
 727                                         if( $xml->entry[0]['name'] == '' ) {
 728                                                 // The directory entry should always have a revision marker.
 729                                                 if( $entry['revision'] ) {
 730                                                         return array( 'checkout-rev' => intval( $entry['revision'] ) );
 731                                                 }
 732                                         }
 733                                 }
 734                         }
 735
 736                         return false;
 737                 }
 738
 739                 // Subversion is release 1.4 or above.
 740                 if ( count( $lines ) < 11 ) {
 741                         return false;
 742                 }
 743
 744                 $info = array(
 745                         'checkout-rev' => intval( trim( $lines[3] ) ),
 746                         'url' => trim( $lines[4] ),
 747                         'repo-url' => trim( $lines[5] ),
 748                         'directory-rev' => intval( trim( $lines[10] ) )
 749                 );
 750
 751                 if ( isset( self::$viewvcUrls[$info['repo-url']] ) ) {
 752                         $viewvc = str_replace(
 753                                 $info['repo-url'],
 754                                 self::$viewvcUrls[$info['repo-url']],
 755                                 $info['url']
 756                         );
 757
 758                         $viewvc .= '/?pathrev=';
 759                         $viewvc .= urlencode( $info['checkout-rev'] );
 760                         $info['viewvc-url'] = $viewvc;
 761                 }
 762
 763                 return $info;
 764         }
 765
 766         /**
 767          * Retrieve the revision number of a Subversion working directory.
 768          *
 769          * @param string $dir directory of the svn checkout
 770          *
 771          * @return Integer: revision number as int
 772          */
 773         public static function getSvnRevision( $dir ) {
 774                 $info = self::getSvnInfo( $dir );
 775
 776                 if ( $info === false ) {
 777                         return false;
 778                 } elseif ( isset( $info['checkout-rev'] ) ) {
 779                         return $info['checkout-rev'];
 780                 } else {
 781                         return false;
 782                 }
 783         }
 784
 785         /**
 786          * @param string $dir directory of the git checkout
 787          * @return bool|String sha1 of commit HEAD points to
 788          */
 789         public static function getGitHeadSha1( $dir ) {
 790                 $repo = new GitInfo( $dir );
 791                 return $repo->getHeadSHA1();
 792         }
 793
 794         /**
 795          * Get the list of entry points and their URLs
 796          * @return string Wikitext
 797          */
 798         public function getEntryPointInfo() {
 799                 global $wgArticlePath, $wgScriptPath;
 800                 $scriptPath = $wgScriptPath ? $wgScriptPath : "/";
 801                 $entryPoints = array(
 802                         'version-entrypoints-articlepath' => $wgArticlePath,
 803                         'version-entrypoints-scriptpath' => $scriptPath,
 804                         'version-entrypoints-index-php' => wfScript( 'index' ),
 805                         'version-entrypoints-api-php' => wfScript( 'api' ),
 806                         'version-entrypoints-load-php' => wfScript( 'load' ),
 807                 );
 808
 809                 $language = $this->getLanguage();
 810                 $thAttribures = array(
 811                         'dir' => $language->getDir(),
 812                         'lang' => $language->getCode()
 813                 );
 814                 $out = Html::element( 'h2', array( 'id' => 'mw-version-entrypoints' ), $this->msg( 'version-entrypoints' )->text() ) .
 815                         Html::openElement( 'table',
 816                                 array(
 817                                         'class' => 'wikitable plainlinks',
 818                                         'id' => 'mw-version-entrypoints-table',
 819                                         'dir' => 'ltr',
 820                                         'lang' => 'en'
 821                                 )
 822                         ) .
 823                         Html::openElement( 'tr' ) .
 824                         Html::element( 'th', $thAttribures, $this->msg( 'version-entrypoints-header-entrypoint' )->text() ) .
 825                         Html::element( 'th', $thAttribures, $this->msg( 'version-entrypoints-header-url' )->text() ) .
 826                         Html::closeElement( 'tr' );
 827
 828                 foreach ( $entryPoints as $message => $value ) {
 829                         $url = wfExpandUrl( $value, PROTO_RELATIVE );
 830                         $out .= Html::openElement( 'tr' ) .
 831                                 // ->text() looks like it should be ->parse(), but this function
 832                                 // returns wikitext, not HTML, boo
 833                                 Html::rawElement( 'td', array(), $this->msg( $message )->text() ) .
 834                                 Html::rawElement( 'td', array(), Html::rawElement( 'code', array(), "[$url $value]" ) ) .
 835                                 Html::closeElement( 'tr' );
 836                 }
 837
 838                 $out .= Html::closeElement( 'table' );
 839                 return $out;
 840         }
 841
 842         protected function getGroupName() {
 843                 return 'wiki';
 844         }
 845
 846 }