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                 # Doesn't work at the time of writing but maybe some day:
  41                 'https://svn.wikimedia.org/viewvc/mediawiki' => 'http://svn.wikimedia.org/viewvc/mediawiki',
  42         );
  43
  44         public function __construct(){
  45                 parent::__construct( 'Version' );
  46         }
  47
  48         /**
  49          * main()
  50          */
  51         public function execute( $par ) {
  52                 global $wgOut, $wgSpecialVersionShowHooks, $wgContLang;
  53
  54                 $this->setHeaders();
  55                 $this->outputHeader();
  56
  57                 $wgOut->addHTML( Xml::openElement( 'div',
  58                         array( 'dir' => $wgContLang->getDir() ) ) );
  59                 $text =
  60                         $this->getMediaWikiCredits() .
  61                         $this->softwareInformation() .
  62                         $this->getExtensionCredits();
  63                 if ( $wgSpecialVersionShowHooks ) {
  64                         $text .= $this->getWgHooks();
  65                 }
  66
  67                 $wgOut->addWikiText( $text );
  68                 $wgOut->addHTML( $this->IPInfo() );
  69                 $wgOut->addHTML( '</div>' );
  70         }
  71
  72         /**
  73          * Returns wiki text showing the license information.
  74          *
  75          * @return string
  76          */
  77         private static function getMediaWikiCredits() {
  78                 $ret = Xml::element( 'h2', array( 'id' => 'mw-version-license' ), wfMsg( 'version-license' ) );
  79
  80                 // This text is always left-to-right.
  81                 $ret .= '<div>';
  82                 $ret .= "__NOTOC__
  83                 " . self::getCopyrightAndAuthorList() . "\n
  84                 " . wfMsg( 'version-license-info' );
  85                 $ret .= '</div>';
  86
  87                 return str_replace( "\t\t", '', $ret ) . "\n";
  88         }
  89
  90         /**
  91          * Get the "Mediawiki is copyright 2001-20xx by lots of cool guys" text
  92          *
  93          * @return String
  94          */
  95         public static function getCopyrightAndAuthorList() {
  96                 global $wgLang;
  97
  98                 $authorList = array( 'Magnus Manske', 'Brion Vibber', 'Lee Daniel Crocker',
  99                         'Tim Starling', 'Erik Möller', 'Gabriel Wicke', 'Ævar Arnfjörð Bjarmason',
 100                         'Niklas Laxström', 'Domas Mituzas', 'Rob Church', 'Yuri Astrakhan',
 101                         'Aryeh Gregor', 'Aaron Schulz', 'Andrew Garrett', 'Raimond Spekking',
 102                         'Alexandre Emsenhuber', 'Siebrand Mazeland', 'Chad Horohoe',
 103                         wfMsg( 'version-poweredby-others' )
 104                 );
 105
 106                 return wfMsg( 'version-poweredby-credits', date( 'Y' ),
 107                         $wgLang->listToText( $authorList ) );
 108         }
 109
 110         /**
 111          * Returns wiki text showing the third party software versions (apache, php, mysql).
 112          *
 113          * @return string
 114          */
 115         static function softwareInformation() {
 116                 $dbr = wfGetDB( DB_SLAVE );
 117
 118                 // Put the software in an array of form 'name' => 'version'. All messages should
 119                 // be loaded here, so feel free to use wfMsg*() in the 'name'. Raw HTML or wikimarkup
 120                 // can be used.
 121                 $software = array();
 122                 $software['[http://www.mediawiki.org/ MediaWiki]'] = self::getVersionLinked();
 123                 $software['[http://www.php.net/ PHP]'] = phpversion() . " (" . php_sapi_name() . ")";
 124                 $software[$dbr->getSoftwareLink()] = $dbr->getServerInfo();
 125
 126                 // Allow a hook to add/remove items.
 127                 wfRunHooks( 'SoftwareInfo', array( &$software ) );
 128
 129                 $out = Xml::element( 'h2', array( 'id' => 'mw-version-software' ), wfMsg( 'version-software' ) ) .
 130                            Xml::openElement( 'table', array( 'class' => 'wikitable', 'id' => 'sv-software' ) ) .
 131                                 "<tr>
 132                                         <th>" . wfMsg( 'version-software-product' ) . "</th>
 133                                         <th>" . wfMsg( 'version-software-version' ) . "</th>
 134                                 </tr>\n";
 135
 136                 foreach( $software as $name => $version ) {
 137                         $out .= "<tr>
 138                                         <td>" . $name . "</td>
 139                                         <td>" . $version . "</td>
 140                                 </tr>\n";
 141                 }
 142
 143                 return $out . Xml::closeElement( 'table' );
 144         }
 145
 146         /**
 147          * Return a string of the MediaWiki version with SVN revision if available.
 148          *
 149          * @return mixed
 150          */
 151         public static function getVersion( $flags = '' ) {
 152                 global $wgVersion, $IP;
 153                 wfProfileIn( __METHOD__ );
 154
 155                 $info = self::getSvnInfo( $IP );
 156                 if ( !$info ) {
 157                         $version = $wgVersion;
 158                 } elseif( $flags === 'nodb' ) {
 159                         $version = "$wgVersion (r{$info['checkout-rev']})";
 160                 } else {
 161                         $version = $wgVersion . ' ' .
 162                                 wfMsg(
 163                                         'version-svn-revision',
 164                                         isset( $info['directory-rev'] ) ? $info['directory-rev'] : '',
 165                                         $info['checkout-rev']
 166                                 );
 167                 }
 168
 169                 wfProfileOut( __METHOD__ );
 170                 return $version;
 171         }
 172
 173         /**
 174          * Return a wikitext-formatted string of the MediaWiki version with a link to
 175          * the SVN revision if available.
 176          *
 177          * @return mixed
 178          */
 179         public static function getVersionLinked() {
 180                 global $wgVersion, $IP;
 181                 wfProfileIn( __METHOD__ );
 182
 183                 $info = self::getSvnInfo( $IP );
 184
 185                 if ( isset(  $info['checkout-rev'] ) ) {
 186                         $linkText = wfMsg(
 187                                 'version-svn-revision',
 188                                 isset( $info['directory-rev'] ) ? $info['directory-rev'] : '',
 189                                 $info['checkout-rev']
 190                         );
 191
 192                         if ( isset( $info['viewvc-url'] ) ) {
 193                                 $version = "$wgVersion [{$info['viewvc-url']} $linkText]";
 194                         } else {
 195                                 $version = "$wgVersion $linkText";
 196                         }
 197                 } else {
 198                         $version = $wgVersion;
 199                 }
 200
 201                 wfProfileOut( __METHOD__ );
 202                 return $version;
 203         }
 204
 205         /**
 206          * Returns an array with the base extension types.
 207          * Type is stored as array key, the message as array value.
 208          *
 209          * TODO: ideally this would return all extension types, including
 210          * those added by SpecialVersionExtensionTypes. This is not possible
 211          * since this hook is passing along $this though.
 212          *
 213          * @since 1.17
 214          *
 215          * @return array
 216          */
 217         public static function getExtensionTypes() {
 218                 if ( self::$extensionTypes === false ) {
 219                         self::$extensionTypes = array(
 220                                 'specialpage' => wfMsg( 'version-specialpages' ),
 221                                 'parserhook' => wfMsg( 'version-parserhooks' ),
 222                                 'variable' => wfMsg( 'version-variables' ),
 223                                 'media' => wfMsg( 'version-mediahandlers' ),
 224                                 'other' => wfMsg( 'version-other' ),
 225                         );
 226
 227                         wfRunHooks( 'ExtensionTypes', array( &self::$extensionTypes ) );
 228                 }
 229
 230                 return self::$extensionTypes;
 231         }
 232
 233         /**
 234          * Returns the internationalized name for an extension type.
 235          *
 236          * @since 1.17
 237          *
 238          * @param $type String
 239          *
 240          * @return string
 241          */
 242         public static function getExtensionTypeName( $type ) {
 243                 $types = self::getExtensionTypes();
 244                 return $types[$type];
 245         }
 246
 247         /**
 248          * Generate wikitext showing extensions name, URL, author and description.
 249          *
 250          * @return String: Wikitext
 251          */
 252         function getExtensionCredits() {
 253                 global $wgExtensionCredits, $wgExtensionFunctions, $wgParser, $wgSkinExtensionFunctions;
 254
 255                 if ( !count( $wgExtensionCredits ) && !count( $wgExtensionFunctions ) && !count( $wgSkinExtensionFunctions ) ) {
 256                         return '';
 257                 }
 258
 259                 $extensionTypes = self::getExtensionTypes();
 260
 261                 /**
 262                  * @deprecated as of 1.17, use hook ExtensionTypes instead.
 263                  */
 264                 wfRunHooks( 'SpecialVersionExtensionTypes', array( &$this, &$extensionTypes ) );
 265
 266                 $out = Xml::element( 'h2', array( 'id' => 'mw-version-ext' ), wfMsg( 'version-extensions' ) ) .
 267                         Xml::openElement( 'table', array( 'class' => 'wikitable', 'id' => 'sv-ext' ) );
 268
 269                 // Make sure the 'other' type is set to an array.
 270                 if ( !array_key_exists( 'other', $wgExtensionCredits ) ) {
 271                         $wgExtensionCredits['other'] = array();
 272                 }
 273
 274                 // Find all extensions that do not have a valid type and give them the type 'other'.
 275                 foreach ( $wgExtensionCredits as $type => $extensions ) {
 276                         if ( !array_key_exists( $type, $extensionTypes ) ) {
 277                                 $wgExtensionCredits['other'] = array_merge( $wgExtensionCredits['other'], $extensions );
 278                         }
 279                 }
 280
 281                 // Loop through the extension categories to display their extensions in the list.
 282                 foreach ( $extensionTypes as $type => $message ) {
 283                         if ( $type != 'other' ) {
 284                                 $out .= $this->getExtensionCategory( $type, $message );
 285                         }
 286                 }
 287
 288                 // We want the 'other' type to be last in the list.
 289                 $out .= $this->getExtensionCategory( 'other', $extensionTypes['other'] );
 290
 291                 if ( count( $wgExtensionFunctions ) ) {
 292                         $out .= $this->openExtType( wfMsg( 'version-extension-functions' ), 'extension-functions' );
 293                         $out .= '<tr><td colspan="4">' . $this->listToText( $wgExtensionFunctions ) . "</td></tr>\n";
 294                 }
 295
 296                 $tags = $wgParser->getTags();
 297                 $cnt = count( $tags );
 298
 299                 if ( $cnt ) {
 300                         for ( $i = 0; $i < $cnt; ++$i ) {
 301                                 $tags[$i] = "&lt;{$tags[$i]}&gt;";
 302                         }
 303                         $out .= $this->openExtType( wfMsg( 'version-parser-extensiontags' ), 'parser-tags' );
 304                         $out .= '<tr><td colspan="4">' . $this->listToText( $tags ). "</td></tr>\n";
 305                 }
 306
 307                 if( count( $fhooks = $wgParser->getFunctionHooks() ) ) {
 308                         $out .= $this->openExtType( wfMsg( 'version-parser-function-hooks' ), 'parser-function-hooks' );
 309                         $out .= '<tr><td colspan="4">' . $this->listToText( $fhooks ) . "</td></tr>\n";
 310                 }
 311
 312                 if ( count( $wgSkinExtensionFunctions ) ) {
 313                         $out .= $this->openExtType( wfMsg( 'version-skin-extension-functions' ), 'skin-extension-functions' );
 314                         $out .= '<tr><td colspan="4">' . $this->listToText( $wgSkinExtensionFunctions ) . "</td></tr>\n";
 315                 }
 316
 317                 $out .= Xml::closeElement( 'table' );
 318
 319                 return $out;
 320         }
 321
 322         /**
 323          * Creates and returns the HTML for a single extension category.
 324          *
 325          * @since 1.17
 326          *
 327          * @param $type String
 328          * @param $message String
 329          *
 330          * @return string
 331          */
 332         protected function getExtensionCategory( $type, $message ) {
 333                 global $wgExtensionCredits;
 334
 335                 $out = '';
 336
 337                 if ( array_key_exists( $type, $wgExtensionCredits ) && count( $wgExtensionCredits[$type] ) > 0 ) {
 338                         $out .= $this->openExtType( $message, 'credits-' . $type );
 339
 340                         usort( $wgExtensionCredits[$type], array( $this, 'compare' ) );
 341
 342                         foreach ( $wgExtensionCredits[$type] as $extension ) {
 343                                 $out .= $this->getCreditsForExtension( $extension );
 344                         }
 345                 }
 346
 347                 return $out;
 348         }
 349
 350         /**
 351          * Callback to sort extensions by type.
 352          */
 353         function compare( $a, $b ) {
 354                 global $wgLang;
 355                 if( $a['name'] === $b['name'] ) {
 356                         return 0;
 357                 } else {
 358                         return $wgLang->lc( $a['name'] ) > $wgLang->lc( $b['name'] )
 359                                 ? 1
 360                                 : -1;
 361                 }
 362         }
 363
 364         /**
 365          * Creates and formats the creidts for a single extension and returns this.
 366          *
 367          * @param $extension Array
 368          *
 369          * @return string
 370          */
 371         function getCreditsForExtension( array $extension ) {
 372                 $name = isset( $extension['name'] ) ? $extension['name'] : '[no name]';
 373
 374                 if ( isset( $extension['path'] ) ) {
 375                         $svnInfo = self::getSvnInfo( dirname($extension['path']) );
 376                         $directoryRev = isset( $svnInfo['directory-rev'] ) ? $svnInfo['directory-rev'] : null;
 377                         $checkoutRev = isset( $svnInfo['checkout-rev'] ) ? $svnInfo['checkout-rev'] : null;
 378                         $viewvcUrl = isset( $svnInfo['viewvc-url'] ) ? $svnInfo['viewvc-url'] : null;
 379                 } else {
 380                         $directoryRev = null;
 381                         $checkoutRev = null;
 382                         $viewvcUrl = null;
 383                 }
 384
 385                 # Make main link (or just the name if there is no URL).
 386                 if ( isset( $extension['url'] ) ) {
 387                         $mainLink = "[{$extension['url']} $name]";
 388                 } else {
 389                         $mainLink = $name;
 390                 }
 391
 392                 if ( isset( $extension['version'] ) ) {
 393                         $versionText = '<span class="mw-version-ext-version">' .
 394                                 wfMsg( 'version-version', $extension['version'] ) .
 395                                 '</span>';
 396                 } else {
 397                         $versionText = '';
 398                 }
 399
 400                 # Make subversion text/link.
 401                 if ( $checkoutRev ) {
 402                         $svnText = wfMsg( 'version-svn-revision', $directoryRev, $checkoutRev );
 403                         $svnText = isset( $viewvcUrl ) ? "[$viewvcUrl $svnText]" : $svnText;
 404                 } else {
 405                         $svnText = false;
 406                 }
 407
 408                 # Make description text.
 409                 $description = isset ( $extension['description'] ) ? $extension['description'] : '';
 410
 411                 if( isset ( $extension['descriptionmsg'] ) ) {
 412                         # Look for a localized description.
 413                         $descriptionMsg = $extension['descriptionmsg'];
 414
 415                         if( is_array( $descriptionMsg ) ) {
 416                                 $descriptionMsgKey = $descriptionMsg[0]; // Get the message key
 417                                 array_shift( $descriptionMsg ); // Shift out the message key to get the parameters only
 418                                 array_map( "htmlspecialchars", $descriptionMsg ); // For sanity
 419                                 $msg = wfMsg( $descriptionMsgKey, $descriptionMsg );
 420                         } else {
 421                                 $msg = wfMsg( $descriptionMsg );
 422                         }
 423                         if ( !wfEmptyMsg( $descriptionMsg, $msg ) && $msg != '' ) {
 424                                 $description = $msg;
 425                         }
 426                 }
 427
 428                 if ( $svnText !== false ) {
 429                         $extNameVer = "<tr>
 430                                 <td><em>$mainLink $versionText</em></td>
 431                                 <td><em>$svnText</em></td>";
 432                 } else {
 433                         $extNameVer = "<tr>
 434                                 <td colspan=\"2\"><em>$mainLink $versionText</em></td>";
 435                 }
 436
 437                 $author = isset ( $extension['author'] ) ? $extension['author'] : array();
 438                 $extDescAuthor = "<td>$description</td>
 439                         <td>" . $this->listToText( (array)$author, false ) . "</td>
 440                         </tr>\n";
 441
 442                 return $extNameVer . $extDescAuthor;
 443         }
 444
 445         /**
 446          * Generate wikitext showing hooks in $wgHooks.
 447          *
 448          * @return String: wikitext
 449          */
 450         private function getWgHooks() {
 451                 global $wgHooks;
 452
 453                 if ( count( $wgHooks ) ) {
 454                         $myWgHooks = $wgHooks;
 455                         ksort( $myWgHooks );
 456
 457                         $ret = Xml::element( 'h2', array( 'id' => 'mw-version-hooks' ), wfMsg( 'version-hooks' ) ) .
 458                                 Xml::openElement( 'table', array( 'class' => 'wikitable', 'id' => 'sv-hooks' ) ) .
 459                                 "<tr>
 460                                         <th>" . wfMsg( 'version-hook-name' ) . "</th>
 461                                         <th>" . wfMsg( 'version-hook-subscribedby' ) . "</th>
 462                                 </tr>\n";
 463
 464                         foreach ( $myWgHooks as $hook => $hooks )
 465                                 $ret .= "<tr>
 466                                                 <td>$hook</td>
 467                                                 <td>" . $this->listToText( $hooks ) . "</td>
 468                                         </tr>\n";
 469
 470                         $ret .= Xml::closeElement( 'table' );
 471                         return $ret;
 472                 } else
 473                         return '';
 474         }
 475
 476         private function openExtType( $text, $name = null ) {
 477                 $opt = array( 'colspan' => 4 );
 478                 $out = '';
 479
 480                 if( $this->firstExtOpened ) {
 481                         // Insert a spacing line
 482                         $out .= '<tr class="sv-space">' . Html::element( 'td', $opt ) . "</tr>\n";
 483                 }
 484                 $this->firstExtOpened = true;
 485
 486                 if( $name ) {
 487                         $opt['id'] = "sv-$name";
 488                 }
 489
 490                 $out .= "<tr>" . Xml::element( 'th', $opt, $text ) . "</tr>\n";
 491
 492                 return $out;
 493         }
 494
 495         /**
 496          * Get information about client's IP address.
 497          *
 498          * @return String: HTML fragment
 499          */
 500         private function IPInfo() {
 501                 $ip =  str_replace( '--', ' - ', htmlspecialchars( wfGetIP() ) );
 502                 return "<!-- visited from $ip -->\n" .
 503                         "<span style='display:none'>visited from $ip</span>";
 504         }
 505
 506         /**
 507          * Convert an array of items into a list for display.
 508          *
 509          * @param $list Array of elements to display
 510          * @param $sort Boolean: whether to sort the items in $list
 511          *
 512          * @return String
 513          */
 514         function listToText( $list, $sort = true ) {
 515                 $cnt = count( $list );
 516
 517                 if ( $cnt == 1 ) {
 518                         // Enforce always returning a string
 519                         return (string)self::arrayToString( $list[0] );
 520                 } elseif ( $cnt == 0 ) {
 521                         return '';
 522                 } else {
 523                         global $wgLang;
 524                         if ( $sort ) {
 525                                 sort( $list );
 526                         }
 527                         return $wgLang->listToText( array_map( array( __CLASS__, 'arrayToString' ), $list ) );
 528                 }
 529         }
 530
 531         /**
 532          * Convert an array or object to a string for display.
 533          *
 534          * @param $list Mixed: will convert an array to string if given and return
 535          *              the paramater unaltered otherwise
 536          *
 537          * @return Mixed
 538          */
 539         static function arrayToString( $list ) {
 540                 if( is_array( $list ) && count( $list ) == 1 )
 541                         $list = $list[0];
 542                 if( is_object( $list ) ) {
 543                         $class = get_class( $list );
 544                         return "($class)";
 545                 } elseif ( !is_array( $list ) ) {
 546                         return $list;
 547                 } else {
 548                         if( is_object( $list[0] ) )
 549                                 $class = get_class( $list[0] );
 550                         else
 551                                 $class = $list[0];
 552                         return "($class, {$list[1]})";
 553                 }
 554         }
 555
 556         /**
 557          * Get an associative array of information about a given path, from its .svn
 558          * subdirectory. Returns false on error, such as if the directory was not
 559          * checked out with subversion.
 560          *
 561          * Returned keys are:
 562          *    Required:
 563          *        checkout-rev          The revision which was checked out
 564          *    Optional:
 565          *        directory-rev         The revision when the directory was last modified
 566          *        url                   The subversion URL of the directory
 567          *        repo-url              The base URL of the repository
 568          *        viewvc-url            A ViewVC URL pointing to the checked-out revision
 569          */
 570         public static function getSvnInfo( $dir ) {
 571                 // http://svnbook.red-bean.com/nightly/en/svn.developer.insidewc.html
 572                 $entries = $dir . '/.svn/entries';
 573
 574                 if( !file_exists( $entries ) ) {
 575                         return false;
 576                 }
 577
 578                 $lines = file( $entries );
 579                 if ( !count( $lines ) ) {
 580                         return false;
 581                 }
 582
 583                 // check if file is xml (subversion release <= 1.3) or not (subversion release = 1.4)
 584                 if( preg_match( '/^<\?xml/', $lines[0] ) ) {
 585                         // subversion is release <= 1.3
 586                         if( !function_exists( 'simplexml_load_file' ) ) {
 587                                 // We could fall back to expat... YUCK
 588                                 return false;
 589                         }
 590
 591                         // SimpleXml whines about the xmlns...
 592                         wfSuppressWarnings();
 593                         $xml = simplexml_load_file( $entries );
 594                         wfRestoreWarnings();
 595
 596                         if( $xml ) {
 597                                 foreach( $xml->entry as $entry ) {
 598                                         if( $xml->entry[0]['name'] == '' ) {
 599                                                 // The directory entry should always have a revision marker.
 600                                                 if( $entry['revision'] ) {
 601                                                         return array( 'checkout-rev' => intval( $entry['revision'] ) );
 602                                                 }
 603                                         }
 604                                 }
 605                         }
 606
 607                         return false;
 608                 }
 609
 610                 // Subversion is release 1.4 or above.
 611                 if ( count( $lines ) < 11 ) {
 612                         return false;
 613                 }
 614
 615                 $info = array(
 616                         'checkout-rev' => intval( trim( $lines[3] ) ),
 617                         'url' => trim( $lines[4] ),
 618                         'repo-url' => trim( $lines[5] ),
 619                         'directory-rev' => intval( trim( $lines[10] ) )
 620                 );
 621
 622                 if ( isset( self::$viewvcUrls[$info['repo-url']] ) ) {
 623                         $viewvc = str_replace(
 624                                 $info['repo-url'],
 625                                 self::$viewvcUrls[$info['repo-url']],
 626                                 $info['url']
 627                         );
 628
 629                         $viewvc .= '/?pathrev=';
 630                         $viewvc .= urlencode( $info['checkout-rev'] );
 631                         $info['viewvc-url'] = $viewvc;
 632                 }
 633
 634                 return $info;
 635         }
 636
 637         /**
 638          * Retrieve the revision number of a Subversion working directory.
 639          *
 640          * @param $dir String: directory of the svn checkout
 641          *
 642          * @return Integer: revision number as int
 643          */
 644         public static function getSvnRevision( $dir ) {
 645                 $info = self::getSvnInfo( $dir );
 646
 647                 if ( $info === false ) {
 648                         return false;
 649                 } elseif ( isset( $info['checkout-rev'] ) ) {
 650                         return $info['checkout-rev'];
 651                 } else {
 652                         return false;
 653                 }
 654         }
 655
 656 }