[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * Tools for dealing with other locally-hosted wikis.
   4   *
   5   * This program is free software; you can redistribute it and/or modify
   6   * it under the terms of the GNU General Public License as published by
   7   * the Free Software Foundation; either version 2 of the License, or
   8   * (at your option) any later version.
   9   *
  10   * This program is distributed in the hope that it will be useful,
  11   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13   * GNU General Public License for more details.
  14   *
  15   * You should have received a copy of the GNU General Public License along
  16   * with this program; if not, write to the Free Software Foundation, Inc.,
  17   * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18   * http://www.gnu.org/copyleft/gpl.html
  19   *
  20   * @file
  21   */
  22  
  23  /**
  24   * Helper tools for dealing with other locally-hosted wikis
  25   */
  26  class WikiMap {
  27  
  28      /**
  29       * Get a WikiReference object for $wikiID
  30       *
  31       * @param string $wikiID Wiki'd id (generally database name)
  32       * @return WikiReference|null WikiReference object or null if the wiki was not found
  33       */
  34  	public static function getWiki( $wikiID ) {
  35          global $wgConf;
  36  
  37          $wgConf->loadFullData();
  38  
  39          list( $major, $minor ) = $wgConf->siteFromDB( $wikiID );
  40          if ( $major === null ) {
  41              return null;
  42          }
  43          $server = $wgConf->get( 'wgServer', $wikiID, $major,
  44              array( 'lang' => $minor, 'site' => $major ) );
  45  
  46          $canonicalServer = $wgConf->get( 'wgCanonicalServer', $wikiID, $major,
  47              array( 'lang' => $minor, 'site' => $major ) );
  48          if ( $canonicalServer === false || $canonicalServer === null ) {
  49              $canonicalServer = $server;
  50          }
  51  
  52          $path = $wgConf->get( 'wgArticlePath', $wikiID, $major,
  53              array( 'lang' => $minor, 'site' => $major ) );
  54          return new WikiReference( $major, $minor, $canonicalServer, $path, $server );
  55      }
  56  
  57      /**
  58       * Convenience to get the wiki's display name
  59       *
  60       * @todo We can give more info than just the wiki id!
  61       * @param string $wikiID Wiki'd id (generally database name)
  62       * @return string|int Wiki's name or $wiki_id if the wiki was not found
  63       */
  64  	public static function getWikiName( $wikiID ) {
  65          $wiki = WikiMap::getWiki( $wikiID );
  66  
  67          if ( $wiki ) {
  68              return $wiki->getDisplayName();
  69          }
  70          return $wikiID;
  71      }
  72  
  73      /**
  74       * Convenience to get a link to a user page on a foreign wiki
  75       *
  76       * @param string $wikiID Wiki'd id (generally database name)
  77       * @param string $user User name (must be normalised before calling this function!)
  78       * @param string $text Link's text; optional, default to "User:$user"
  79       * @return string HTML link or false if the wiki was not found
  80       */
  81  	public static function foreignUserLink( $wikiID, $user, $text = null ) {
  82          return self::makeForeignLink( $wikiID, "User:$user", $text );
  83      }
  84  
  85      /**
  86       * Convenience to get a link to a page on a foreign wiki
  87       *
  88       * @param string $wikiID Wiki'd id (generally database name)
  89       * @param string $page Page name (must be normalised before calling this function!)
  90       * @param string $text Link's text; optional, default to $page
  91       * @return string HTML link or false if the wiki was not found
  92       */
  93  	public static function makeForeignLink( $wikiID, $page, $text = null ) {
  94          if ( !$text ) {
  95              $text = $page;
  96          }
  97  
  98          $url = self::getForeignURL( $wikiID, $page );
  99          if ( $url === false ) {
 100              return false;
 101          }
 102  
 103          return Linker::makeExternalLink( $url, $text );
 104      }
 105  
 106      /**
 107       * Convenience to get a url to a page on a foreign wiki
 108       *
 109       * @param string $wikiID Wiki'd id (generally database name)
 110       * @param string $page Page name (must be normalised before calling this function!)
 111       * @return string|bool URL or false if the wiki was not found
 112       */
 113  	public static function getForeignURL( $wikiID, $page ) {
 114          $wiki = WikiMap::getWiki( $wikiID );
 115  
 116          if ( $wiki ) {
 117              return $wiki->getFullUrl( $page );
 118          }
 119  
 120          return false;
 121      }
 122  }
 123  
 124  /**
 125   * Reference to a locally-hosted wiki
 126   */
 127  class WikiReference {
 128      private $mMinor; ///< 'en', 'meta', 'mediawiki', etc
 129      private $mMajor; ///< 'wiki', 'wiktionary', etc
 130      private $mCanonicalServer; ///< canonical server URL, e.g. 'https://www.mediawiki.org'
 131      private $mServer; ///< server URL, may be protocol-relative, e.g. '//www.mediawiki.org'
 132      private $mPath;   ///< path, '/wiki/$1'
 133  
 134      /**
 135       * @param string $major
 136       * @param string $minor
 137       * @param string $canonicalServer
 138       * @param string $path
 139       * @param null|string $server
 140       */
 141  	public function __construct( $major, $minor, $canonicalServer, $path, $server = null ) {
 142          $this->mMajor = $major;
 143          $this->mMinor = $minor;
 144          $this->mCanonicalServer = $canonicalServer;
 145          $this->mPath = $path;
 146          $this->mServer = $server === null ? $canonicalServer : $server;
 147      }
 148  
 149      /**
 150       * @return string
 151       * @throws MWException
 152       */
 153  	public function getHostname() {
 154          $prefixes = array( 'http://', 'https://' );
 155          foreach ( $prefixes as $prefix ) {
 156              if ( substr( $this->mCanonicalServer, 0, strlen( $prefix ) ) ) {
 157                  return substr( $this->mCanonicalServer, strlen( $prefix ) );
 158              }
 159          }
 160          throw new MWException( "Invalid hostname for wiki {$this->mMinor}.{$this->mMajor}" );
 161      }
 162  
 163      /**
 164       * Get the the URL in a way to de displayed to the user
 165       * More or less Wikimedia specific
 166       *
 167       * @return string
 168       */
 169  	public function getDisplayName() {
 170          $url = $this->getUrl( '' );
 171          $parsed = wfParseUrl( $url );
 172          if ( $parsed ) {
 173              return $parsed['host'];
 174          } else {
 175              // Invalid URL. There's no sane thing to do here, so just return it
 176              return $url;
 177          }
 178      }
 179  
 180      /**
 181       * Helper function for getUrl()
 182       *
 183       * @todo FIXME: This may be generalized...
 184       * @param string $page Page name (must be normalised before calling this function!)
 185       * @return string Url fragment
 186       */
 187  	private function getLocalUrl( $page ) {
 188          return str_replace( '$1', wfUrlEncode( str_replace( ' ', '_', $page ) ), $this->mPath );
 189      }
 190  
 191      /**
 192       * Get a canonical (i.e. based on $wgCanonicalServer) URL to a page on this foreign wiki
 193       *
 194       * @param string $page Page name (must be normalised before calling this function!)
 195       * @return string Url
 196       */
 197  	public function getCanonicalUrl( $page ) {
 198          return $this->mCanonicalServer . $this->getLocalUrl( $page );
 199      }
 200  
 201      /**
 202       * Get a canonical server URL
 203       * @return string
 204       */
 205  	public function getCanonicalServer() {
 206          return $this->mCanonicalServer;
 207      }
 208  
 209      /**
 210       * Alias for getCanonicalUrl(), for backwards compatibility.
 211       * @param string $page
 212       * @return string
 213       */
 214  	public function getUrl( $page ) {
 215          return $this->getCanonicalUrl( $page );
 216      }
 217  
 218      /**
 219       * Get a URL based on $wgServer, like Title::getFullURL() would produce
 220       * when called locally on the wiki.
 221       *
 222       * @param string $page Page name (must be normalized before calling this function!)
 223       * @return string URL
 224       */
 225  	public function getFullUrl( $page ) {
 226          return $this->mServer .
 227              $this->getLocalUrl( $page );
 228      }
 229  }