Proyectos de Subversion Moodle

<?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)) {

                $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