Admin Control Panel v2.0

✎ Editing: LanguageFactory.php ← Back

<?php

/**

* Class responsible for generating HTMLPurifier_Language objects, managing

* caching and fallbacks.

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

*       has been entirely rewritten

* @todo Serialized cache for languages

class HTMLPurifier_LanguageFactory

{

/**

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

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

* @type array

public $cache;

/**

* Valid keys in the HTMLPurifier_Language object. Designates which

* variables to slurp out of a message file.

* @type array

public $keys = array('fallback', 'messages', 'errorNames');

/**

* Instance to validate language codes.

* @type HTMLPurifier_AttrDef_Lang

protected $validator;

/**

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

* trailing slash.

* @type string

protected $dir;

/**

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

* @type array

protected $mergeable_keys_map = array('messages' => true, 'errorNames' => true);

/**

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

* @value array lookup

protected $mergeable_keys_list = array();

/**

* Retrieve sole instance of the factory.

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

*                   or bool true to reset to default factory.

* @return HTMLPurifier_LanguageFactory

public static function instance($prototype = null)

{

static $instance = null;

if ($prototype !== null) {

$instance = $prototype;

} elseif ($instance === null || $prototype == true) {

$instance = new HTMLPurifier_LanguageFactory();

$instance->setup();

}

return $instance;

}

/**

* Sets up the singleton, much like a constructor

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

public function setup()

{

$this->validator = new HTMLPurifier_AttrDef_Lang();

$this->dir = HTMLPURIFIER_PREFIX . '/HTMLPurifier';

}

/**

* Creates a language object, handles class fallbacks

* @param HTMLPurifier_Config $config

* @param HTMLPurifier_Context $context

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

* @return HTMLPurifier_Language

public function create($config, $context, $code = false)

{

// validate language code

if ($code === false) {

$code = $this->validator->validate(

$config->get('Core.Language'),

$config,

$context

);

} else {

$code = $this->validator->validate($code, $config, $context);

}

if ($code === false) {

$code = 'en'; // malformed code becomes English

}

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

static $depth = 0; // recursion protection

if ($code == 'en') {

$lang = new HTMLPurifier_Language($config, $context);

} else {

$class = 'HTMLPurifier_Language_' . $pcode;

$file  = $this->dir . '/Language/classes/' . $code . '.php';

if (file_exists($file) || class_exists($class, false)) {

$lang = new $class($config, $context);

} else {

// Go fallback

$raw_fallback = $this->getFallbackFor($code);

$fallback = $raw_fallback ? $raw_fallback : 'en';

$depth++;

$lang = $this->create($config, $context, $fallback);

if (!$raw_fallback) {

$lang->error = true;

}

$depth--;

}

$lang->code = $code;

return $lang;

}

/**

* Returns the fallback language for language

* @note Loads the original language into cache

* @param string $code language code

* @return string|bool

public function getFallbackFor($code)

{

$this->loadLanguage($code);

return $this->cache[$code]['fallback'];

}

/**

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

* @param string $code language code

public function loadLanguage($code)

{

static $languages_seen = array(); // recursion guard

// abort if we've already loaded it

if (isset($this->cache[$code])) {

return;

}

// generate filename

$filename = $this->dir . '/Language/messages/' . $code . '.php';

// default fallback : may be overwritten by the ensuing include

$fallback = ($code != 'en') ? 'en' : false;

// load primary localisation

if (!file_exists($filename)) {

// skip the include: will rely solely on fallback

$filename = $this->dir . '/Language/messages/en.php';

$cache = array();

} else {

include $filename;

$cache = compact($this->keys);

}

// load fallback localisation

if (!empty($fallback)) {

// infinite recursion guard

if (isset($languages_seen[$code])) {

trigger_error(

'Circular fallback reference in language ' .

$code,

E_USER_ERROR

);

$fallback = 'en';

}

$language_seen[$code] = true;

// load the fallback recursively

$this->loadLanguage($fallback);

$fallback_cache = $this->cache[$fallback];

// merge fallback with current language

foreach ($this->keys as $key) {

if (isset($cache[$key]) && isset($fallback_cache[$key])) {

if (isset($this->mergeable_keys_map[$key])) {

$cache[$key] = $cache[$key] + $fallback_cache[$key];

} elseif (isset($this->mergeable_keys_list[$key])) {

$cache[$key] = array_merge($fallback_cache[$key], $cache[$key]);

}

} else {

$cache[$key] = $fallback_cache[$key];

}

// save to cache for later retrieval

$this->cache[$code] = $cache;

return;

}

// vim: et sw=4 sts=4

Cancel