library/HTMLPurifier/Language.php

   1 <?php
   2
   3 /**
   4  * Represents a language and defines localizable string formatting and
   5  * other functions, as well as the localized messages for HTML Purifier.
   6  */
   7 class HTMLPurifier_Language
   8 {
   9
  10     /**
  11      * ISO 639 language code of language. Prefers shortest possible version.
  12      * @type string
  13      */
  14     public $code = 'en';
  15
  16     /**
  17      * Fallback language code.
  18      * @type bool|string
  19      */
  20     public $fallback = false;
  21
  22     /**
  23      * Array of localizable messages.
  24      * @type array
  25      */
  26     public $messages = array();
  27
  28     /**
  29      * Array of localizable error codes.
  30      * @type array
  31      */
  32     public $errorNames = array();
  33
  34     /**
  35      * True if no message file was found for this language, so English
  36      * is being used instead. Check this if you'd like to notify the
  37      * user that they've used a non-supported language.
  38      * @type bool
  39      */
  40     public $error = false;
  41
  42     /**
  43      * Has the language object been loaded yet?
  44      * @type bool
  45      * @todo Make it private, fix usage in HTMLPurifier_LanguageTest
  46      */
  47     public $_loaded = false;
  48
  49     /**
  50      * @type HTMLPurifier_Config
  51      */
  52     protected $config;
  53
  54     /**
  55      * @type HTMLPurifier_Context
  56      */
  57     protected $context;
  58
  59     /**
  60      * @param HTMLPurifier_Config $config
  61      * @param HTMLPurifier_Context $context
  62      */
  63     public function __construct($config, $context)
  64     {
  65         $this->config  = $config;
  66         $this->context = $context;
  67     }
  68
  69     /**
  70      * Loads language object with necessary info from factory cache
  71      * @note This is a lazy loader
  72      */
  73     public function load()
  74     {
  75         if ($this->_loaded) {
  76             return;
  77         }
  78         $factory = HTMLPurifier_LanguageFactory::instance();
  79         $factory->loadLanguage($this->code);
  80         foreach ($factory->keys as $key) {
  81             $this->$key = $factory->cache[$this->code][$key];
  82         }
  83         $this->_loaded = true;
  84     }
  85
  86     /**
  87      * Retrieves a localised message.
  88      * @param string $key string identifier of message
  89      * @return string localised message
  90      */
  91     public function getMessage($key)
  92     {
  93         if (!$this->_loaded) {
  94             $this->load();
  95         }
  96         if (!isset($this->messages[$key])) {
  97             return "[$key]";
  98         }
  99         return $this->messages[$key];
 100     }
 101
 102     /**
 103      * Retrieves a localised error name.
 104      * @param int $int error number, corresponding to PHP's error reporting
 105      * @return string localised message
 106      */
 107     public function getErrorName($int)
 108     {
 109         if (!$this->_loaded) {
 110             $this->load();
 111         }
 112         if (!isset($this->errorNames[$int])) {
 113             return "[Error: $int]";
 114         }
 115         return $this->errorNames[$int];
 116     }
 117
 118     /**
 119      * Converts an array list into a string readable representation
 120      * @param array $array
 121      * @return string
 122      */
 123     public function listify($array)
 124     {
 125         $sep      = $this->getMessage('Item separator');
 126         $sep_last = $this->getMessage('Item separator last');
 127         $ret = '';
 128         for ($i = 0, $c = count($array); $i < $c; $i++) {
 129             if ($i == 0) {
 130             } elseif ($i + 1 < $c) {
 131                 $ret .= $sep;
 132             } else {
 133                 $ret .= $sep_last;
 134             }
 135             $ret .= $array[$i];
 136         }
 137         return $ret;
 138     }
 139
 140     /**
 141      * Formats a localised message with passed parameters
 142      * @param string $key string identifier of message
 143      * @param array $args Parameters to substitute in
 144      * @return string localised message
 145      * @todo Implement conditionals? Right now, some messages make
 146      *     reference to line numbers, but those aren't always available
 147      */
 148     public function formatMessage($key, $args = array())
 149     {
 150         if (!$this->_loaded) {
 151             $this->load();
 152         }
 153         if (!isset($this->messages[$key])) {
 154             return "[$key]";
 155         }
 156         $raw = $this->messages[$key];
 157         $subst = array();
 158         $generator = false;
 159         foreach ($args as $i => $value) {
 160             if (is_object($value)) {
 161                 if ($value instanceof HTMLPurifier_Token) {
 162                     // factor this out some time
 163                     if (!$generator) {
 164                         $generator = $this->context->get('Generator');
 165                     }
 166                     if (isset($value->name)) {
 167                         $subst['$'.$i.'.Name'] = $value->name;
 168                     }
 169                     if (isset($value->data)) {
 170                         $subst['$'.$i.'.Data'] = $value->data;
 171                     }
 172                     $subst['$'.$i.'.Compact'] =
 173                     $subst['$'.$i.'.Serialized'] = $generator->generateFromToken($value);
 174                     // a more complex algorithm for compact representation
 175                     // could be introduced for all types of tokens. This
 176                     // may need to be factored out into a dedicated class
 177                     if (!empty($value->attr)) {
 178                         $stripped_token = clone $value;
 179                         $stripped_token->attr = array();
 180                         $subst['$'.$i.'.Compact'] = $generator->generateFromToken($stripped_token);
 181                     }
 182                     $subst['$'.$i.'.Line'] = $value->line ? $value->line : 'unknown';
 183                 }
 184                 continue;
 185             } elseif (is_array($value)) {
 186                 $keys = array_keys($value);
 187                 if (array_keys($keys) === $keys) {
 188                     // list
 189                     $subst['$'.$i] = $this->listify($value);
 190                 } else {
 191                     // associative array
 192                     // no $i implementation yet, sorry
 193                     $subst['$'.$i.'.Keys'] = $this->listify($keys);
 194                     $subst['$'.$i.'.Values'] = $this->listify(array_values($value));
 195                 }
 196                 continue;
 197             }
 198             $subst['$' . $i] = $value;
 199         }
 200         return strtr($raw, $subst);
 201     }
 202 }
 203
 204 // vim: et sw=4 sts=4