includes/skins/SkinFactory.php

   1 <?php
   2
   3 /**
   4  * Copyright 2014
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  * http://www.gnu.org/copyleft/gpl.html
  20  *
  21  * @file
  22  */
  23
  24 /**
  25  * Factory class to create Skin objects
  26  *
  27  * @since 1.24
  28  */
  29 class SkinFactory {
  30
  31         /**
  32          * Map of name => callback
  33          * @var array
  34          */
  35         private $factoryFunctions = array();
  36         /**
  37          * Map of name => fallback human-readable name, used when the 'skinname-<skin>' message is not
  38          * available
  39          *
  40          * @var array
  41          */
  42         private $displayNames = array();
  43         /**
  44          * Map of name => class name without "Skin" prefix, for legacy skins using the autodiscovery
  45          * mechanism
  46          *
  47          * @var array
  48          */
  49         private $legacySkins = array();
  50
  51         /**
  52          * @var SkinFactory
  53          */
  54         private static $self;
  55
  56         public static function getDefaultInstance() {
  57                 if ( !self::$self ) {
  58                         self::$self = new self;
  59                 }
  60
  61                 return self::$self;
  62         }
  63
  64         /**
  65          * Register a new Skin factory function.
  66          *
  67          * Will override if it's already registered.
  68          *
  69          * @param string $name Internal skin name. Should be all-lowercase (technically doesn't have
  70          *     to be, but doing so would change the case of i18n message keys).
  71          * @param string $displayName For backwards-compatibility with old skin loading system. This is
  72          *     the text used as skin's human-readable name when the 'skinname-<skin>' message is not
  73          *     available. It should be the same as the skin name provided in $wgExtensionCredits.
  74          * @param callable $callback Callback that takes the skin name as an argument
  75          * @throws InvalidArgumentException If an invalid callback is provided
  76          */
  77         public function register( $name, $displayName, $callback ) {
  78                 if ( !is_callable( $callback ) ) {
  79                         throw new InvalidArgumentException( 'Invalid callback provided' );
  80                 }
  81                 $this->factoryFunctions[$name] = $callback;
  82                 $this->displayNames[$name] = $displayName;
  83         }
  84
  85         /**
  86          * @return array
  87          */
  88         private function getLegacySkinNames() {
  89                 static $skinsInitialised = false;
  90
  91                 if ( !$skinsInitialised || !count( $this->legacySkins ) ) {
  92                         # Get a list of available skins
  93                         # Build using the regular expression '^(.*).php$'
  94                         # Array keys are all lower case, array value keep the case used by filename
  95                         #
  96                         wfProfileIn( __METHOD__ . '-init' );
  97
  98                         global $wgStyleDirectory;
  99
 100                         $skinDir = dir( $wgStyleDirectory );
 101
 102                         if ( $skinDir !== false && $skinDir !== null ) {
 103                                 # while code from www.php.net
 104                                 while ( false !== ( $file = $skinDir->read() ) ) {
 105                                         // Skip non-PHP files, hidden files, and '.dep' includes
 106                                         $matches = array();
 107
 108                                         if ( preg_match( '/^([^.]*)\.php$/', $file, $matches ) ) {
 109                                                 $aSkin = $matches[1];
 110
 111                                                 // Explicitly disallow loading core skins via the autodiscovery mechanism.
 112                                                 //
 113                                                 // They should be loaded already (in a non-autodicovery way), but old files might still
 114                                                 // exist on the server because our MW version upgrade process is widely documented as
 115                                                 // requiring just copying over all files, without removing old ones.
 116                                                 //
 117                                                 // This is one of the reasons we should have never used autodiscovery in the first
 118                                                 // place. This hack can be safely removed when autodiscovery is gone.
 119                                                 if ( in_array( $aSkin, array( 'CologneBlue', 'Modern', 'MonoBook', 'Vector' ) ) ) {
 120                                                         wfLogWarning(
 121                                                                 "An old copy of the $aSkin skin was found in your skins/ directory. " .
 122                                                                 "You should remove it to avoid problems in the future." .
 123                                                                 "See https://www.mediawiki.org/wiki/Manual:Skin_autodiscovery for details."
 124                                                         );
 125                                                         continue;
 126                                                 }
 127
 128                                                 wfLogWarning(
 129                                                         "A skin using autodiscovery mechanism, $aSkin, was found in your skins/ directory. " .
 130                                                         "The mechanism will be removed in MediaWiki 1.25 and the skin will no longer be recognized. " .
 131                                                         "See https://www.mediawiki.org/wiki/Manual:Skin_autodiscovery for information how to fix this."
 132                                                 );
 133                                                 $this->legacySkins[strtolower( $aSkin )] = $aSkin;
 134                                         }
 135                                 }
 136                                 $skinDir->close();
 137                         }
 138                         $skinsInitialised = true;
 139                         wfProfileOut( __METHOD__ . '-init' );
 140                 }
 141                 return $this->legacySkins;
 142
 143         }
 144
 145         /**
 146          * Returns an associative array of:
 147          *  skin name => human readable name
 148          *
 149          * @return array
 150          */
 151         public function getSkinNames() {
 152                 return array_merge(
 153                         $this->getLegacySkinNames(),
 154                         $this->displayNames
 155                 );
 156         }
 157
 158         /**
 159          * Get a legacy skin which uses the autodiscovery mechanism.
 160          *
 161          * @param string $name
 162          * @return Skin|bool False if the skin couldn't be constructed
 163          */
 164         private function getLegacySkin( $name ) {
 165                 $skinNames = $this->getLegacySkinNames();
 166                 if ( !isset( $skinNames[$name] ) ) {
 167                         return false;
 168                 }
 169                 $skinName = $skinNames[$name];
 170                 $className = "Skin{$skinName}";
 171
 172                 # Grab the skin class and initialise it.
 173                 if ( !class_exists( $className ) ) {
 174                         global $wgStyleDirectory;
 175                         require_once "{$wgStyleDirectory}/{$skinName}.php";
 176
 177                         # Check if we got it
 178                         if ( !class_exists( $className ) ) {
 179                                 # DO NOT die if the class isn't found. This breaks maintenance
 180                                 # scripts and can cause a user account to be unrecoverable
 181                                 # except by SQL manipulation if a previously valid skin name
 182                                 # is no longer valid.
 183                                 return false;
 184                         }
 185                 }
 186                 $skin = new $className( $name );
 187                 return $skin;
 188
 189         }
 190
 191         /**
 192          * Create a given Skin using the registered callback for $name.
 193          * @param string $name Name of the skin you want
 194          * @throws SkinException If a factory function isn't registered for $name
 195          * @throws UnexpectedValueException If the factory function returns a non-Skin object
 196          * @return Skin
 197          */
 198         public function makeSkin( $name ) {
 199                 if ( !isset( $this->factoryFunctions[$name] ) ) {
 200                         // Check the legacy autodiscovery method of skin loading
 201                         $legacy = $this->getLegacySkin( $name );
 202                         if ( $legacy ) {
 203                                 return $legacy;
 204                         }
 205                         throw new SkinException( "No registered builder available for $name." );
 206                 }
 207                 $skin = call_user_func( $this->factoryFunctions[$name], $name );
 208                 if ( $skin instanceof Skin ) {
 209                         return $skin;
 210                 } else {
 211                         throw new UnexpectedValueException( "The builder for $name returned a non-Skin object." );
 212                 }
 213         }
 214 }