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                                 'antispam' => wfMsg( 'version-antispam' ),
 225                                 'skin' => wfMsg( 'version-skins' ),
 226                                 'other' => wfMsg( 'version-other' ),
 227                         );
 228
 229                         wfRunHooks( 'ExtensionTypes', array( &self::$extensionTypes ) );
 230                 }
 231
 232                 return self::$extensionTypes;
 233         }
 234
 235         /**
 236          * Returns the internationalized name for an extension type.
 237          *
 238          * @since 1.17
 239          *
 240          * @param $type String
 241          *
 242          * @return string
 243          */
 244         public static function getExtensionTypeName( $type ) {
 245                 $types = self::getExtensionTypes();
 246                 return $types[$type];
 247         }
 248
 249         /**
 250          * Generate wikitext showing extensions name, URL, author and description.
 251          *
 252          * @return String: Wikitext
 253          */
 254         function getExtensionCredits() {
 255                 global $wgExtensionCredits, $wgExtensionFunctions, $wgParser, $wgSkinExtensionFunctions;
 256
 257                 if ( !count( $wgExtensionCredits ) && !count( $wgExtensionFunctions ) && !count( $wgSkinExtensionFunctions ) ) {
 258                         return '';
 259                 }
 260
 261                 $extensionTypes = self::getExtensionTypes();
 262
 263                 /**
 264                  * @deprecated as of 1.17, use hook ExtensionTypes instead.
 265                  */
 266                 wfRunHooks( 'SpecialVersionExtensionTypes', array( &$this, &$extensionTypes ) );
 267
 268                 $out = Xml::element( 'h2', array( 'id' => 'mw-version-ext' ), wfMsg( 'version-extensions' ) ) .
 269                         Xml::openElement( 'table', array( 'class' => 'wikitable', 'id' => 'sv-ext' ) );
 270
 271                 // Make sure the 'other' type is set to an array.
 272                 if ( !array_key_exists( 'other', $wgExtensionCredits ) ) {
 273                         $wgExtensionCredits['other'] = array();
 274                 }
 275
 276                 // Find all extensions that do not have a valid type and give them the type 'other'.
 277                 foreach ( $wgExtensionCredits as $type => $extensions ) {
 278                         if ( !array_key_exists( $type, $extensionTypes ) ) {
 279                                 $wgExtensionCredits['other'] = array_merge( $wgExtensionCredits['other'], $extensions );
 280                         }
 281                 }
 282
 283                 // Loop through the extension categories to display their extensions in the list.
 284                 foreach ( $extensionTypes as $type => $message ) {
 285                         if ( $type != 'other' ) {
 286                                 $out .= $this->getExtensionCategory( $type, $message );
 287                         }
 288                 }
 289
 290                 // We want the 'other' type to be last in the list.
 291                 $out .= $this->getExtensionCategory( 'other', $extensionTypes['other'] );
 292
 293                 if ( count( $wgExtensionFunctions ) ) {
 294                         $out .= $this->openExtType( wfMsg( 'version-extension-functions' ), 'extension-functions' );
 295                         $out .= '<tr><td colspan="4">' . $this->listToText( $wgExtensionFunctions ) . "</td></tr>\n";
 296                 }
 297
 298                 $tags = $wgParser->getTags();
 299                 $cnt = count( $tags );
 300
 301                 if ( $cnt ) {
 302                         for ( $i = 0; $i < $cnt; ++$i ) {
 303                                 $tags[$i] = "&lt;{$tags[$i]}&gt;";
 304                         }
 305                         $out .= $this->openExtType( wfMsg( 'version-parser-extensiontags' ), 'parser-tags' );
 306                         $out .= '<tr><td colspan="4">' . $this->listToText( $tags ). "</td></tr>\n";
 307                 }
 308
 309                 if( count( $fhooks = $wgParser->getFunctionHooks() ) ) {
 310                         $out .= $this->openExtType( wfMsg( 'version-parser-function-hooks' ), 'parser-function-hooks' );
 311                         $out .= '<tr><td colspan="4">' . $this->listToText( $fhooks ) . "</td></tr>\n";
 312                 }
 313
 314                 if ( count( $wgSkinExtensionFunctions ) ) {
 315                         $out .= $this->openExtType( wfMsg( 'version-skin-extension-functions' ), 'skin-extension-functions' );
 316                         $out .= '<tr><td colspan="4">' . $this->listToText( $wgSkinExtensionFunctions ) . "</td></tr>\n";
 317                 }
 318
 319                 $out .= Xml::closeElement( 'table' );
 320
 321                 return $out;
 322         }
 323
 324         /**
 325          * Creates and returns the HTML for a single extension category.
 326          *
 327          * @since 1.17
 328          *
 329          * @param $type String
 330          * @param $message String
 331          *
 332          * @return string
 333          */
 334         protected function getExtensionCategory( $type, $message ) {
 335                 global $wgExtensionCredits;
 336
 337                 $out = '';
 338
 339                 if ( array_key_exists( $type, $wgExtensionCredits ) && count( $wgExtensionCredits[$type] ) > 0 ) {
 340                         $out .= $this->openExtType( $message, 'credits-' . $type );
 341
 342                         usort( $wgExtensionCredits[$type], array( $this, 'compare' ) );
 343
 344                         foreach ( $wgExtensionCredits[$type] as $extension ) {
 345                                 $out .= $this->getCreditsForExtension( $extension );
 346                         }
 347                 }
 348
 349                 return $out;
 350         }
 351
 352         /**
 353          * Callback to sort extensions by type.
 354          */
 355         function compare( $a, $b ) {
 356                 global $wgLang;
 357                 if( $a['name'] === $b['name'] ) {
 358                         return 0;
 359                 } else {
 360                         return $wgLang->lc( $a['name'] ) > $wgLang->lc( $b['name'] )
 361                                 ? 1
 362                                 : -1;
 363                 }
 364         }
 365
 366         /**
 367          * Creates and formats the creidts for a single extension and returns this.
 368          *
 369          * @param $extension Array
 370          *
 371          * @return string
 372          */
 373         function getCreditsForExtension( array $extension ) {
 374                 $name = isset( $extension['name'] ) ? $extension['name'] : '[no name]';
 375
 376                 if ( isset( $extension['path'] ) ) {
 377                         $svnInfo = self::getSvnInfo( dirname($extension['path']) );
 378                         $directoryRev = isset( $svnInfo['directory-rev'] ) ? $svnInfo['directory-rev'] : null;
 379                         $checkoutRev = isset( $svnInfo['checkout-rev'] ) ? $svnInfo['checkout-rev'] : null;
 380                         $viewvcUrl = isset( $svnInfo['viewvc-url'] ) ? $svnInfo['viewvc-url'] : null;
 381                 } else {
 382                         $directoryRev = null;
 383                         $checkoutRev = null;
 384                         $viewvcUrl = null;
 385                 }
 386
 387                 # Make main link (or just the name if there is no URL).
 388                 if ( isset( $extension['url'] ) ) {
 389                         $mainLink = "[{$extension['url']} $name]";
 390                 } else {
 391                         $mainLink = $name;
 392                 }
 393
 394                 if ( isset( $extension['version'] ) ) {
 395                         $versionText = '<span class="mw-version-ext-version">' .
 396                                 wfMsg( 'version-version', $extension['version'] ) .
 397                                 '</span>';
 398                 } else {
 399                         $versionText = '';
 400                 }
 401
 402                 # Make subversion text/link.
 403                 if ( $checkoutRev ) {
 404                         $svnText = wfMsg( 'version-svn-revision', $directoryRev, $checkoutRev );
 405                         $svnText = isset( $viewvcUrl ) ? "[$viewvcUrl $svnText]" : $svnText;
 406                 } else {
 407                         $svnText = false;
 408                 }
 409
 410                 # Make description text.
 411                 $description = isset ( $extension['description'] ) ? $extension['description'] : '';
 412
 413                 if( isset ( $extension['descriptionmsg'] ) ) {
 414                         # Look for a localized description.
 415                         $descriptionMsg = $extension['descriptionmsg'];
 416
 417                         if( is_array( $descriptionMsg ) ) {
 418                                 $descriptionMsgKey = $descriptionMsg[0]; // Get the message key
 419                                 array_shift( $descriptionMsg ); // Shift out the message key to get the parameters only
 420                                 array_map( "htmlspecialchars", $descriptionMsg ); // For sanity
 421                                 $description = wfMsg( $descriptionMsgKey, $descriptionMsg );
 422                         } else {
 423                                 $description = wfMsg( $descriptionMsg );
 424                         }
 425                 }
 426
 427                 if ( $svnText !== false ) {
 428                         $extNameVer = "<tr>
 429                                 <td><em>$mainLink $versionText</em></td>
 430                                 <td><em>$svnText</em></td>";
 431                 } else {
 432                         $extNameVer = "<tr>
 433                                 <td colspan=\"2\"><em>$mainLink $versionText</em></td>";
 434                 }
 435
 436                 $author = isset ( $extension['author'] ) ? $extension['author'] : array();
 437                 $extDescAuthor = "<td>$description</td>
 438                         <td>" . $this->listToText( (array)$author, false ) . "</td>
 439                         </tr>\n";
 440
 441                 return $extNameVer . $extDescAuthor;
 442         }
 443
 444         /**
 445          * Generate wikitext showing hooks in $wgHooks.
 446          *
 447          * @return String: wikitext
 448          */
 449         private function getWgHooks() {
 450                 global $wgHooks;
 451
 452                 if ( count( $wgHooks ) ) {
 453                         $myWgHooks = $wgHooks;
 454                         ksort( $myWgHooks );
 455
 456                         $ret = Xml::element( 'h2', array( 'id' => 'mw-version-hooks' ), wfMsg( 'version-hooks' ) ) .
 457                                 Xml::openElement( 'table', array( 'class' => 'wikitable', 'id' => 'sv-hooks' ) ) .
 458                                 "<tr>
 459                                         <th>" . wfMsg( 'version-hook-name' ) . "</th>
 460                                         <th>" . wfMsg( 'version-hook-subscribedby' ) . "</th>
 461                                 </tr>\n";
 462
 463                         foreach ( $myWgHooks as $hook => $hooks )
 464                                 $ret .= "<tr>
 465                                                 <td>$hook</td>
 466                                                 <td>" . $this->listToText( $hooks ) . "</td>
 467                                         </tr>\n";
 468
 469                         $ret .= Xml::closeElement( 'table' );
 470                         return $ret;
 471                 } else
 472                         return '';
 473         }
 474
 475         private function openExtType( $text, $name = null ) {
 476                 $opt = array( 'colspan' => 4 );
 477                 $out = '';
 478
 479                 if( $this->firstExtOpened ) {
 480                         // Insert a spacing line
 481                         $out .= '<tr class="sv-space">' . Html::element( 'td', $opt ) . "</tr>\n";
 482                 }
 483                 $this->firstExtOpened = true;
 484
 485                 if( $name ) {
 486                         $opt['id'] = "sv-$name";
 487                 }
 488
 489                 $out .= "<tr>" . Xml::element( 'th', $opt, $text ) . "</tr>\n";
 490
 491                 return $out;
 492         }
 493
 494         /**
 495          * Get information about client's IP address.
 496          *
 497          * @return String: HTML fragment
 498          */
 499         private function IPInfo() {
 500                 $ip =  str_replace( '--', ' - ', htmlspecialchars( wfGetIP() ) );
 501                 return "<!-- visited from $ip -->\n" .
 502                         "<span style='display:none'>visited from $ip</span>";
 503         }
 504
 505         /**
 506          * Convert an array of items into a list for display.
 507          *
 508          * @param $list Array of elements to display
 509          * @param $sort Boolean: whether to sort the items in $list
 510          *
 511          * @return String
 512          */
 513         function listToText( $list, $sort = true ) {
 514                 $cnt = count( $list );
 515
 516                 if ( $cnt == 1 ) {
 517                         // Enforce always returning a string
 518                         return (string)self::arrayToString( $list[0] );
 519                 } elseif ( $cnt == 0 ) {
 520                         return '';
 521                 } else {
 522                         global $wgLang;
 523                         if ( $sort ) {
 524                                 sort( $list );
 525                         }
 526                         return $wgLang->listToText( array_map( array( __CLASS__, 'arrayToString' ), $list ) );
 527                 }
 528         }
 529
 530         /**
 531          * Convert an array or object to a string for display.
 532          *
 533          * @param $list Mixed: will convert an array to string if given and return
 534          *              the paramater unaltered otherwise
 535          *
 536          * @return Mixed
 537          */
 538         static function arrayToString( $list ) {
 539                 if( is_array( $list ) && count( $list ) == 1 )
 540                         $list = $list[0];
 541                 if( is_object( $list ) ) {
 542                         $class = get_class( $list );
 543                         return "($class)";
 544                 } elseif ( !is_array( $list ) ) {
 545                         return $list;
 546                 } else {
 547                         if( is_object( $list[0] ) )
 548                                 $class = get_class( $list[0] );
 549                         else
 550                                 $class = $list[0];
 551                         return "($class, {$list[1]})";
 552                 }
 553         }
 554
 555         /**
 556          * Get an associative array of information about a given path, from its .svn
 557          * subdirectory. Returns false on error, such as if the directory was not
 558          * checked out with subversion.
 559          *
 560          * Returned keys are:
 561          *    Required:
 562          *        checkout-rev          The revision which was checked out
 563          *    Optional:
 564          *        directory-rev         The revision when the directory was last modified
 565          *        url                   The subversion URL of the directory
 566          *        repo-url              The base URL of the repository
 567          *        viewvc-url            A ViewVC URL pointing to the checked-out revision
 568          */
 569         public static function getSvnInfo( $dir ) {
 570                 // http://svnbook.red-bean.com/nightly/en/svn.developer.insidewc.html
 571                 $entries = $dir . '/.svn/entries';
 572
 573                 if( !file_exists( $entries ) ) {
 574                         return false;
 575                 }
 576
 577                 $lines = file( $entries );
 578                 if ( !count( $lines ) ) {
 579                         return false;
 580                 }
 581
 582                 // check if file is xml (subversion release <= 1.3) or not (subversion release = 1.4)
 583                 if( preg_match( '/^<\?xml/', $lines[0] ) ) {
 584                         // subversion is release <= 1.3
 585                         if( !function_exists( 'simplexml_load_file' ) ) {
 586                                 // We could fall back to expat... YUCK
 587                                 return false;
 588                         }
 589
 590                         // SimpleXml whines about the xmlns...
 591                         wfSuppressWarnings();
 592                         $xml = simplexml_load_file( $entries );
 593                         wfRestoreWarnings();
 594
 595                         if( $xml ) {
 596                                 foreach( $xml->entry as $entry ) {
 597                                         if( $xml->entry[0]['name'] == '' ) {
 598                                                 // The directory entry should always have a revision marker.
 599                                                 if( $entry['revision'] ) {
 600                                                         return array( 'checkout-rev' => intval( $entry['revision'] ) );
 601                                                 }
 602                                         }
 603                                 }
 604                         }
 605
 606                         return false;
 607                 }
 608
 609                 // Subversion is release 1.4 or above.
 610                 if ( count( $lines ) < 11 ) {
 611                         return false;
 612                 }
 613
 614                 $info = array(
 615                         'checkout-rev' => intval( trim( $lines[3] ) ),
 616                         'url' => trim( $lines[4] ),
 617                         'repo-url' => trim( $lines[5] ),
 618                         'directory-rev' => intval( trim( $lines[10] ) )
 619                 );
 620
 621                 if ( isset( self::$viewvcUrls[$info['repo-url']] ) ) {
 622                         $viewvc = str_replace(
 623                                 $info['repo-url'],
 624                                 self::$viewvcUrls[$info['repo-url']],
 625                                 $info['url']
 626                         );
 627
 628                         $viewvc .= '/?pathrev=';
 629                         $viewvc .= urlencode( $info['checkout-rev'] );
 630                         $info['viewvc-url'] = $viewvc;
 631                 }
 632
 633                 return $info;
 634         }
 635
 636         /**
 637          * Retrieve the revision number of a Subversion working directory.
 638          *
 639          * @param $dir String: directory of the svn checkout
 640          *
 641          * @return Integer: revision number as int
 642          */
 643         public static function getSvnRevision( $dir ) {
 644                 $info = self::getSvnInfo( $dir );
 645
 646                 if ( $info === false ) {
 647                         return false;
 648                 } elseif ( isset( $info['checkout-rev'] ) ) {
 649                         return $info['checkout-rev'];
 650                 } else {
 651                         return false;
 652                 }
 653         }
 654
 655 }