[Summary view]

   1  <?php
   2  
   3  /**

   4   * Class responsible for generating HTMLPurifier_Language objects, managing

   5   * caching and fallbacks.

   6   * @note Thanks to MediaWiki for the general logic, although this version

   7   *       has been entirely rewritten

   8   * @todo Serialized cache for languages

   9   */
  10  class HTMLPurifier_LanguageFactory
  11  {
  12  
  13      /**

  14       * Cache of language code information used to load HTMLPurifier_Language objects.

  15       * Structure is: $factory->cache[$language_code][$key] = $value

  16       * @type array

  17       */
  18      public $cache;
  19  
  20      /**

  21       * Valid keys in the HTMLPurifier_Language object. Designates which

  22       * variables to slurp out of a message file.

  23       * @type array

  24       */
  25      public $keys = array('fallback', 'messages', 'errorNames');
  26  
  27      /**

  28       * Instance to validate language codes.

  29       * @type HTMLPurifier_AttrDef_Lang

  30       *

  31       */
  32      protected $validator;
  33  
  34      /**

  35       * Cached copy of dirname(__FILE__), directory of current file without

  36       * trailing slash.

  37       * @type string

  38       */
  39      protected $dir;
  40  
  41      /**

  42       * Keys whose contents are a hash map and can be merged.

  43       * @type array

  44       */
  45      protected $mergeable_keys_map = array('messages' => true, 'errorNames' => true);
  46  
  47      /**

  48       * Keys whose contents are a list and can be merged.

  49       * @value array lookup

  50       */
  51      protected $mergeable_keys_list = array();
  52  
  53      /**

  54       * Retrieve sole instance of the factory.

  55       * @param HTMLPurifier_LanguageFactory $prototype Optional prototype to overload sole instance with,

  56       *                   or bool true to reset to default factory.

  57       * @return HTMLPurifier_LanguageFactory

  58       */
  59      public static function instance($prototype = null)
  60      {
  61          static $instance = null;
  62          if ($prototype !== null) {
  63              $instance = $prototype;
  64          } elseif ($instance === null || $prototype == true) {
  65              $instance = new HTMLPurifier_LanguageFactory();
  66              $instance->setup();
  67          }
  68          return $instance;
  69      }
  70  
  71      /**

  72       * Sets up the singleton, much like a constructor

  73       * @note Prevents people from getting this outside of the singleton

  74       */
  75      public function setup()
  76      {
  77          $this->validator = new HTMLPurifier_AttrDef_Lang();
  78          $this->dir = HTMLPURIFIER_PREFIX . '/HTMLPurifier';
  79      }
  80  
  81      /**

  82       * Creates a language object, handles class fallbacks

  83       * @param HTMLPurifier_Config $config

  84       * @param HTMLPurifier_Context $context

  85       * @param bool|string $code Code to override configuration with. Private parameter.

  86       * @return HTMLPurifier_Language

  87       */
  88      public function create($config, $context, $code = false)
  89      {
  90          // validate language code

  91          if ($code === false) {
  92              $code = $this->validator->validate(
  93                  $config->get('Core.Language'),
  94                  $config,
  95                  $context
  96              );
  97          } else {
  98              $code = $this->validator->validate($code, $config, $context);
  99          }
 100          if ($code === false) {
 101              $code = 'en'; // malformed code becomes English

 102          }
 103  
 104          $pcode = str_replace('-', '_', $code); // make valid PHP classname

 105          static $depth = 0; // recursion protection

 106  
 107          if ($code == 'en') {
 108              $lang = new HTMLPurifier_Language($config, $context);
 109          } else {
 110              $class = 'HTMLPurifier_Language_' . $pcode;
 111              $file  = $this->dir . '/Language/classes/' . $code . '.php';
 112              if (file_exists($file) || class_exists($class, false)) {
 113                  $lang = new $class($config, $context);
 114              } else {
 115                  // Go fallback

 116                  $raw_fallback = $this->getFallbackFor($code);
 117                  $fallback = $raw_fallback ? $raw_fallback : 'en';
 118                  $depth++;
 119                  $lang = $this->create($config, $context, $fallback);
 120                  if (!$raw_fallback) {
 121                      $lang->error = true;
 122                  }
 123                  $depth--;
 124              }
 125          }
 126          $lang->code = $code;
 127          return $lang;
 128      }
 129  
 130      /**

 131       * Returns the fallback language for language

 132       * @note Loads the original language into cache

 133       * @param string $code language code

 134       * @return string|bool

 135       */
 136      public function getFallbackFor($code)
 137      {
 138          $this->loadLanguage($code);
 139          return $this->cache[$code]['fallback'];
 140      }
 141  
 142      /**

 143       * Loads language into the cache, handles message file and fallbacks

 144       * @param string $code language code

 145       */
 146      public function loadLanguage($code)
 147      {
 148          static $languages_seen = array(); // recursion guard

 149  
 150          // abort if we've already loaded it

 151          if (isset($this->cache[$code])) {
 152              return;
 153          }
 154  
 155          // generate filename

 156          $filename = $this->dir . '/Language/messages/' . $code . '.php';
 157  
 158          // default fallback : may be overwritten by the ensuing include

 159          $fallback = ($code != 'en') ? 'en' : false;
 160  
 161          // load primary localisation

 162          if (!file_exists($filename)) {
 163              // skip the include: will rely solely on fallback

 164              $filename = $this->dir . '/Language/messages/en.php';
 165              $cache = array();
 166          } else {
 167              include $filename;
 168              $cache = compact($this->keys);
 169          }
 170  
 171          // load fallback localisation

 172          if (!empty($fallback)) {
 173  
 174              // infinite recursion guard

 175              if (isset($languages_seen[$code])) {
 176                  trigger_error(
 177                      'Circular fallback reference in language ' .
 178                      $code,
 179                      E_USER_ERROR
 180                  );
 181                  $fallback = 'en';
 182              }
 183              $language_seen[$code] = true;
 184  
 185              // load the fallback recursively

 186              $this->loadLanguage($fallback);
 187              $fallback_cache = $this->cache[$fallback];
 188  
 189              // merge fallback with current language

 190              foreach ($this->keys as $key) {
 191                  if (isset($cache[$key]) && isset($fallback_cache[$key])) {
 192                      if (isset($this->mergeable_keys_map[$key])) {
 193                          $cache[$key] = $cache[$key] + $fallback_cache[$key];
 194                      } elseif (isset($this->mergeable_keys_list[$key])) {
 195                          $cache[$key] = array_merge($fallback_cache[$key], $cache[$key]);
 196                      }
 197                  } else {
 198                      $cache[$key] = $fallback_cache[$key];
 199                  }
 200              }
 201          }
 202  
 203          // save to cache for later retrieval

 204          $this->cache[$code] = $cache;
 205          return;
 206      }
 207  }
 208  
 209  // vim: et sw=4 sts=4