[github/wallabag/wallabag.git] / inc / 3rdparty / htmlpurifier / HTMLPurifier / Config.php

<?php\r
\r
/**\r
 * Configuration object that triggers customizable behavior.\r
 *\r
 * @warning This class is strongly defined: that means that the class\r
 *          will fail if an undefined directive is retrieved or set.\r
 *\r
 * @note Many classes that could (although many times don't) use the\r
 *       configuration object make it a mandatory parameter.  This is\r
 *       because a configuration object should always be forwarded,\r
 *       otherwise, you run the risk of missing a parameter and then\r
 *       being stumped when a configuration directive doesn't work.\r
 *\r
 * @todo Reconsider some of the public member variables\r
 */\r
class HTMLPurifier_Config\r
{\r
\r
    /**\r
     * HTML Purifier's version\r
     * @type string\r
     */\r
    public $version = '4.6.0';\r
\r
    /**\r
     * Whether or not to automatically finalize\r
     * the object if a read operation is done.\r
     * @type bool\r
     */\r
    public $autoFinalize = true;\r
\r
    // protected member variables\r
\r
    /**\r
     * Namespace indexed array of serials for specific namespaces.\r
     * @see getSerial() for more info.\r
     * @type string[]\r
     */\r
    protected $serials = array();\r
\r
    /**\r
     * Serial for entire configuration object.\r
     * @type string\r
     */\r
    protected $serial;\r
\r
    /**\r
     * Parser for variables.\r
     * @type HTMLPurifier_VarParser_Flexible\r
     */\r
    protected $parser = null;\r
\r
    /**\r
     * Reference HTMLPurifier_ConfigSchema for value checking.\r
     * @type HTMLPurifier_ConfigSchema\r
     * @note This is public for introspective purposes. Please don't\r
     *       abuse!\r
     */\r
    public $def;\r
\r
    /**\r
     * Indexed array of definitions.\r
     * @type HTMLPurifier_Definition[]\r
     */\r
    protected $definitions;\r
\r
    /**\r
     * Whether or not config is finalized.\r
     * @type bool\r
     */\r
    protected $finalized = false;\r
\r
    /**\r
     * Property list containing configuration directives.\r
     * @type array\r
     */\r
    protected $plist;\r
\r
    /**\r
     * Whether or not a set is taking place due to an alias lookup.\r
     * @type bool\r
     */\r
    private $aliasMode;\r
\r
    /**\r
     * Set to false if you do not want line and file numbers in errors.\r
     * (useful when unit testing).  This will also compress some errors\r
     * and exceptions.\r
     * @type bool\r
     */\r
    public $chatty = true;\r
\r
    /**\r
     * Current lock; only gets to this namespace are allowed.\r
     * @type string\r
     */\r
    private $lock;\r
\r
    /**\r
     * Constructor\r
     * @param HTMLPurifier_ConfigSchema $definition ConfigSchema that defines\r
     * what directives are allowed.\r
     * @param HTMLPurifier_PropertyList $parent\r
     */\r
    public function __construct($definition, $parent = null)\r
    {\r
        $parent = $parent ? $parent : $definition->defaultPlist;\r
        $this->plist = new HTMLPurifier_PropertyList($parent);\r
        $this->def = $definition; // keep a copy around for checking\r
        $this->parser = new HTMLPurifier_VarParser_Flexible();\r
    }\r
\r
    /**\r
     * Convenience constructor that creates a config object based on a mixed var\r
     * @param mixed $config Variable that defines the state of the config\r
     *                      object. Can be: a HTMLPurifier_Config() object,\r
     *                      an array of directives based on loadArray(),\r
     *                      or a string filename of an ini file.\r
     * @param HTMLPurifier_ConfigSchema $schema Schema object\r
     * @return HTMLPurifier_Config Configured object\r
     */\r
    public static function create($config, $schema = null)\r
    {\r
        if ($config instanceof HTMLPurifier_Config) {\r
            // pass-through\r
            return $config;\r
        }\r
        if (!$schema) {\r
            $ret = HTMLPurifier_Config::createDefault();\r
        } else {\r
            $ret = new HTMLPurifier_Config($schema);\r
        }\r
        if (is_string($config)) {\r
            $ret->loadIni($config);\r
        } elseif (is_array($config)) $ret->loadArray($config);\r
        return $ret;\r
    }\r
\r
    /**\r
     * Creates a new config object that inherits from a previous one.\r
     * @param HTMLPurifier_Config $config Configuration object to inherit from.\r
     * @return HTMLPurifier_Config object with $config as its parent.\r
     */\r
    public static function inherit(HTMLPurifier_Config $config)\r
    {\r
        return new HTMLPurifier_Config($config->def, $config->plist);\r
    }\r
\r
    /**\r
     * Convenience constructor that creates a default configuration object.\r
     * @return HTMLPurifier_Config default object.\r
     */\r
    public static function createDefault()\r
    {\r
        $definition = HTMLPurifier_ConfigSchema::instance();\r
        $config = new HTMLPurifier_Config($definition);\r
        return $config;\r
    }\r
\r
    /**\r
     * Retrieves a value from the configuration.\r
     *\r
     * @param string $key String key\r
     * @param mixed $a\r
     *\r
     * @return mixed\r
     */\r
    public function get($key, $a = null)\r
    {\r
        if ($a !== null) {\r
            $this->triggerError(\r
                "Using deprecated API: use \$config->get('$key.$a') instead",\r
                E_USER_WARNING\r
            );\r
            $key = "$key.$a";\r
        }\r
        if (!$this->finalized) {\r
            $this->autoFinalize();\r
        }\r
        if (!isset($this->def->info[$key])) {\r
            // can't add % due to SimpleTest bug\r
            $this->triggerError(\r
                'Cannot retrieve value of undefined directive ' . htmlspecialchars($key),\r
                E_USER_WARNING\r
            );\r
            return;\r
        }\r
        if (isset($this->def->info[$key]->isAlias)) {\r
            $d = $this->def->info[$key];\r
            $this->triggerError(\r
                'Cannot get value from aliased directive, use real name ' . $d->key,\r
                E_USER_ERROR\r
            );\r
            return;\r
        }\r
        if ($this->lock) {\r
            list($ns) = explode('.', $key);\r
            if ($ns !== $this->lock) {\r
                $this->triggerError(\r
                    'Cannot get value of namespace ' . $ns . ' when lock for ' .\r
                    $this->lock .\r
                    ' is active, this probably indicates a Definition setup method ' .\r
                    'is accessing directives that are not within its namespace',\r
                    E_USER_ERROR\r
                );\r
                return;\r
            }\r
        }\r
        return $this->plist->get($key);\r
    }\r
\r
    /**\r
     * Retrieves an array of directives to values from a given namespace\r
     *\r
     * @param string $namespace String namespace\r
     *\r
     * @return array\r
     */\r
    public function getBatch($namespace)\r
    {\r
        if (!$this->finalized) {\r
            $this->autoFinalize();\r
        }\r
        $full = $this->getAll();\r
        if (!isset($full[$namespace])) {\r
            $this->triggerError(\r
                'Cannot retrieve undefined namespace ' .\r
                htmlspecialchars($namespace),\r
                E_USER_WARNING\r
            );\r
            return;\r
        }\r
        return $full[$namespace];\r
    }\r
\r
    /**\r
     * Returns a SHA-1 signature of a segment of the configuration object\r
     * that uniquely identifies that particular configuration\r
     *\r
     * @param string $namespace Namespace to get serial for\r
     *\r
     * @return string\r
     * @note Revision is handled specially and is removed from the batch\r
     *       before processing!\r
     */\r
    public function getBatchSerial($namespace)\r
    {\r
        if (empty($this->serials[$namespace])) {\r
            $batch = $this->getBatch($namespace);\r
            unset($batch['DefinitionRev']);\r
            $this->serials[$namespace] = sha1(serialize($batch));\r
        }\r
        return $this->serials[$namespace];\r
    }\r
\r
    /**\r
     * Returns a SHA-1 signature for the entire configuration object\r
     * that uniquely identifies that particular configuration\r
     *\r
     * @return string\r
     */\r
    public function getSerial()\r
    {\r
        if (empty($this->serial)) {\r
            $this->serial = sha1(serialize($this->getAll()));\r
        }\r
        return $this->serial;\r
    }\r
\r
    /**\r
     * Retrieves all directives, organized by namespace\r
     *\r
     * @warning This is a pretty inefficient function, avoid if you can\r
     */\r
    public function getAll()\r
    {\r
        if (!$this->finalized) {\r
            $this->autoFinalize();\r
        }\r
        $ret = array();\r
        foreach ($this->plist->squash() as $name => $value) {\r
            list($ns, $key) = explode('.', $name, 2);\r
            $ret[$ns][$key] = $value;\r
        }\r
        return $ret;\r
    }\r
\r
    /**\r
     * Sets a value to configuration.\r
     *\r
     * @param string $key key\r
     * @param mixed $value value\r
     * @param mixed $a\r
     */\r
    public function set($key, $value, $a = null)\r
    {\r
        if (strpos($key, '.') === false) {\r
            $namespace = $key;\r
            $directive = $value;\r
            $value = $a;\r
            $key = "$key.$directive";\r
            $this->triggerError("Using deprecated API: use \$config->set('$key', ...) instead", E_USER_NOTICE);\r
        } else {\r
            list($namespace) = explode('.', $key);\r
        }\r
        if ($this->isFinalized('Cannot set directive after finalization')) {\r
            return;\r
        }\r
        if (!isset($this->def->info[$key])) {\r
            $this->triggerError(\r
                'Cannot set undefined directive ' . htmlspecialchars($key) . ' to value',\r
                E_USER_WARNING\r
            );\r
            return;\r
        }\r
        $def = $this->def->info[$key];\r
\r
        if (isset($def->isAlias)) {\r
            if ($this->aliasMode) {\r
                $this->triggerError(\r
                    'Double-aliases not allowed, please fix '.\r
                    'ConfigSchema bug with' . $key,\r
                    E_USER_ERROR\r
                );\r
                return;\r
            }\r
            $this->aliasMode = true;\r
            $this->set($def->key, $value);\r
            $this->aliasMode = false;\r
            $this->triggerError("$key is an alias, preferred directive name is {$def->key}", E_USER_NOTICE);\r
            return;\r
        }\r
\r
        // Raw type might be negative when using the fully optimized form\r
        // of stdclass, which indicates allow_null == true\r
        $rtype = is_int($def) ? $def : $def->type;\r
        if ($rtype < 0) {\r
            $type = -$rtype;\r
            $allow_null = true;\r
        } else {\r
            $type = $rtype;\r
            $allow_null = isset($def->allow_null);\r
        }\r
\r
        try {\r
            $value = $this->parser->parse($value, $type, $allow_null);\r
        } catch (HTMLPurifier_VarParserException $e) {\r
            $this->triggerError(\r
                'Value for ' . $key . ' is of invalid type, should be ' .\r
                HTMLPurifier_VarParser::getTypeName($type),\r
                E_USER_WARNING\r
            );\r
            return;\r
        }\r
        if (is_string($value) && is_object($def)) {\r
            // resolve value alias if defined\r
            if (isset($def->aliases[$value])) {\r
                $value = $def->aliases[$value];\r
            }\r
            // check to see if the value is allowed\r
            if (isset($def->allowed) && !isset($def->allowed[$value])) {\r
                $this->triggerError(\r
                    'Value not supported, valid values are: ' .\r
                    $this->_listify($def->allowed),\r
                    E_USER_WARNING\r
                );\r
                return;\r
            }\r
        }\r
        $this->plist->set($key, $value);\r
\r
        // reset definitions if the directives they depend on changed\r
        // this is a very costly process, so it's discouraged\r
        // with finalization\r
        if ($namespace == 'HTML' || $namespace == 'CSS' || $namespace == 'URI') {\r
            $this->definitions[$namespace] = null;\r
        }\r
\r
        $this->serials[$namespace] = false;\r
    }\r
\r
    /**\r
     * Convenience function for error reporting\r
     *\r
     * @param array $lookup\r
     *\r
     * @return string\r
     */\r
    private function _listify($lookup)\r
    {\r
        $list = array();\r
        foreach ($lookup as $name => $b) {\r
            $list[] = $name;\r
        }\r
        return implode(', ', $list);\r
    }\r
\r
    /**\r
     * Retrieves object reference to the HTML definition.\r
     *\r
     * @param bool $raw Return a copy that has not been setup yet. Must be\r
     *             called before it's been setup, otherwise won't work.\r
     * @param bool $optimized If true, this method may return null, to\r
     *             indicate that a cached version of the modified\r
     *             definition object is available and no further edits\r
     *             are necessary.  Consider using\r
     *             maybeGetRawHTMLDefinition, which is more explicitly\r
     *             named, instead.\r
     *\r
     * @return HTMLPurifier_HTMLDefinition\r
     */\r
    public function getHTMLDefinition($raw = false, $optimized = false)\r
    {\r
        return $this->getDefinition('HTML', $raw, $optimized);\r
    }\r
\r
    /**\r
     * Retrieves object reference to the CSS definition\r
     *\r
     * @param bool $raw Return a copy that has not been setup yet. Must be\r
     *             called before it's been setup, otherwise won't work.\r
     * @param bool $optimized If true, this method may return null, to\r
     *             indicate that a cached version of the modified\r
     *             definition object is available and no further edits\r
     *             are necessary.  Consider using\r
     *             maybeGetRawCSSDefinition, which is more explicitly\r
     *             named, instead.\r
     *\r
     * @return HTMLPurifier_CSSDefinition\r
     */\r
    public function getCSSDefinition($raw = false, $optimized = false)\r
    {\r
        return $this->getDefinition('CSS', $raw, $optimized);\r
    }\r
\r
    /**\r
     * Retrieves object reference to the URI definition\r
     *\r
     * @param bool $raw Return a copy that has not been setup yet. Must be\r
     *             called before it's been setup, otherwise won't work.\r
     * @param bool $optimized If true, this method may return null, to\r
     *             indicate that a cached version of the modified\r
     *             definition object is available and no further edits\r
     *             are necessary.  Consider using\r
     *             maybeGetRawURIDefinition, which is more explicitly\r
     *             named, instead.\r
     *\r
     * @return HTMLPurifier_URIDefinition\r
     */\r
    public function getURIDefinition($raw = false, $optimized = false)\r
    {\r
        return $this->getDefinition('URI', $raw, $optimized);\r
    }\r
\r
    /**\r
     * Retrieves a definition\r
     *\r
     * @param string $type Type of definition: HTML, CSS, etc\r
     * @param bool $raw Whether or not definition should be returned raw\r
     * @param bool $optimized Only has an effect when $raw is true.  Whether\r
     *        or not to return null if the result is already present in\r
     *        the cache.  This is off by default for backwards\r
     *        compatibility reasons, but you need to do things this\r
     *        way in order to ensure that caching is done properly.\r
     *        Check out enduser-customize.html for more details.\r
     *        We probably won't ever change this default, as much as the\r
     *        maybe semantics is the "right thing to do."\r
     *\r
     * @throws HTMLPurifier_Exception\r
     * @return HTMLPurifier_Definition\r
     */\r
    public function getDefinition($type, $raw = false, $optimized = false)\r
    {\r
        if ($optimized && !$raw) {\r
            throw new HTMLPurifier_Exception("Cannot set optimized = true when raw = false");\r
        }\r
        if (!$this->finalized) {\r
            $this->autoFinalize();\r
        }\r
        // temporarily suspend locks, so we can handle recursive definition calls\r
        $lock = $this->lock;\r
        $this->lock = null;\r
        $factory = HTMLPurifier_DefinitionCacheFactory::instance();\r
        $cache = $factory->create($type, $this);\r
        $this->lock = $lock;\r
        if (!$raw) {\r
            // full definition\r
            // ---------------\r
            // check if definition is in memory\r
            if (!empty($this->definitions[$type])) {\r
                $def = $this->definitions[$type];\r
                // check if the definition is setup\r
                if ($def->setup) {\r
                    return $def;\r
                } else {\r
                    $def->setup($this);\r
                    if ($def->optimized) {\r
                        $cache->add($def, $this);\r
                    }\r
                    return $def;\r
                }\r
            }\r
            // check if definition is in cache\r
            $def = $cache->get($this);\r
            if ($def) {\r
                // definition in cache, save to memory and return it\r
                $this->definitions[$type] = $def;\r
                return $def;\r
            }\r
            // initialize it\r
            $def = $this->initDefinition($type);\r
            // set it up\r
            $this->lock = $type;\r
            $def->setup($this);\r
            $this->lock = null;\r
            // save in cache\r
            $cache->add($def, $this);\r
            // return it\r
            return $def;\r
        } else {\r
            // raw definition\r
            // --------------\r
            // check preconditions\r
            $def = null;\r
            if ($optimized) {\r
                if (is_null($this->get($type . '.DefinitionID'))) {\r
                    // fatally error out if definition ID not set\r
                    throw new HTMLPurifier_Exception(\r
                        "Cannot retrieve raw version without specifying %$type.DefinitionID"\r
                    );\r
                }\r
            }\r
            if (!empty($this->definitions[$type])) {\r
                $def = $this->definitions[$type];\r
                if ($def->setup && !$optimized) {\r
                    $extra = $this->chatty ?\r
                        " (try moving this code block earlier in your initialization)" :\r
                        "";\r
                    throw new HTMLPurifier_Exception(\r
                        "Cannot retrieve raw definition after it has already been setup" .\r
                        $extra\r
                    );\r
                }\r
                if ($def->optimized === null) {\r
                    $extra = $this->chatty ? " (try flushing your cache)" : "";\r
                    throw new HTMLPurifier_Exception(\r
                        "Optimization status of definition is unknown" . $extra\r
                    );\r
                }\r
                if ($def->optimized !== $optimized) {\r
                    $msg = $optimized ? "optimized" : "unoptimized";\r
                    $extra = $this->chatty ?\r
                        " (this backtrace is for the first inconsistent call, which was for a $msg raw definition)"\r
                        : "";\r
                    throw new HTMLPurifier_Exception(\r
                        "Inconsistent use of optimized and unoptimized raw definition retrievals" . $extra\r
                    );\r
                }\r
            }\r
            // check if definition was in memory\r
            if ($def) {\r
                if ($def->setup) {\r
                    // invariant: $optimized === true (checked above)\r
                    return null;\r
                } else {\r
                    return $def;\r
                }\r
            }\r
            // if optimized, check if definition was in cache\r
            // (because we do the memory check first, this formulation\r
            // is prone to cache slamming, but I think\r
            // guaranteeing that either /all/ of the raw\r
            // setup code or /none/ of it is run is more important.)\r
            if ($optimized) {\r
                // This code path only gets run once; once we put\r
                // something in $definitions (which is guaranteed by the\r
                // trailing code), we always short-circuit above.\r
                $def = $cache->get($this);\r
                if ($def) {\r
                    // save the full definition for later, but don't\r
                    // return it yet\r
                    $this->definitions[$type] = $def;\r
                    return null;\r
                }\r
            }\r
            // check invariants for creation\r
            if (!$optimized) {\r
                if (!is_null($this->get($type . '.DefinitionID'))) {\r
                    if ($this->chatty) {\r
                        $this->triggerError(\r
                            'Due to a documentation error in previous version of HTML Purifier, your ' .\r
                            'definitions are not being cached.  If this is OK, you can remove the ' .\r
                            '%$type.DefinitionRev and %$type.DefinitionID declaration.  Otherwise, ' .\r
                            'modify your code to use maybeGetRawDefinition, and test if the returned ' .\r
                            'value is null before making any edits (if it is null, that means that a ' .\r
                            'cached version is available, and no raw operations are necessary).  See ' .\r
                            '<a href="http://htmlpurifier.org/docs/enduser-customize.html#optimized">' .\r
                            'Customize</a> for more details',\r
                            E_USER_WARNING\r
                        );\r
                    } else {\r
                        $this->triggerError(\r
                            "Useless DefinitionID declaration",\r
                            E_USER_WARNING\r
                        );\r
                    }\r
                }\r
            }\r
            // initialize it\r
            $def = $this->initDefinition($type);\r
            $def->optimized = $optimized;\r
            return $def;\r
        }\r
        throw new HTMLPurifier_Exception("The impossible happened!");\r
    }\r
\r
    /**\r
     * Initialise definition\r
     *\r
     * @param string $type What type of definition to create\r
     *\r
     * @return HTMLPurifier_CSSDefinition|HTMLPurifier_HTMLDefinition|HTMLPurifier_URIDefinition\r
     * @throws HTMLPurifier_Exception\r
     */\r
    private function initDefinition($type)\r
    {\r
        // quick checks failed, let's create the object\r
        if ($type == 'HTML') {\r
            $def = new HTMLPurifier_HTMLDefinition();\r
        } elseif ($type == 'CSS') {\r
            $def = new HTMLPurifier_CSSDefinition();\r
        } elseif ($type == 'URI') {\r
            $def = new HTMLPurifier_URIDefinition();\r
        } else {\r
            throw new HTMLPurifier_Exception(\r
                "Definition of $type type not supported"\r
            );\r
        }\r
        $this->definitions[$type] = $def;\r
        return $def;\r
    }\r
\r
    public function maybeGetRawDefinition($name)\r
    {\r
        return $this->getDefinition($name, true, true);\r
    }\r
\r
    public function maybeGetRawHTMLDefinition()\r
    {\r
        return $this->getDefinition('HTML', true, true);\r
    }\r
\r
    public function maybeGetRawCSSDefinition()\r
    {\r
        return $this->getDefinition('CSS', true, true);\r
    }\r
\r
    public function maybeGetRawURIDefinition()\r
    {\r
        return $this->getDefinition('URI', true, true);\r
    }\r
\r
    /**\r
     * Loads configuration values from an array with the following structure:\r
     * Namespace.Directive => Value\r
     *\r
     * @param array $config_array Configuration associative array\r
     */\r
    public function loadArray($config_array)\r
    {\r
        if ($this->isFinalized('Cannot load directives after finalization')) {\r
            return;\r
        }\r
        foreach ($config_array as $key => $value) {\r
            $key = str_replace('_', '.', $key);\r
            if (strpos($key, '.') !== false) {\r
                $this->set($key, $value);\r
            } else {\r
                $namespace = $key;\r
                $namespace_values = $value;\r
                foreach ($namespace_values as $directive => $value2) {\r
                    $this->set($namespace .'.'. $directive, $value2);\r
                }\r
            }\r
        }\r
    }\r
\r
    /**\r
     * Returns a list of array(namespace, directive) for all directives\r
     * that are allowed in a web-form context as per an allowed\r
     * namespaces/directives list.\r
     *\r
     * @param array $allowed List of allowed namespaces/directives\r
     * @param HTMLPurifier_ConfigSchema $schema Schema to use, if not global copy\r
     *\r
     * @return array\r
     */\r
    public static function getAllowedDirectivesForForm($allowed, $schema = null)\r
    {\r
        if (!$schema) {\r
            $schema = HTMLPurifier_ConfigSchema::instance();\r
        }\r
        if ($allowed !== true) {\r
            if (is_string($allowed)) {\r
                $allowed = array($allowed);\r
            }\r
            $allowed_ns = array();\r
            $allowed_directives = array();\r
            $blacklisted_directives = array();\r
            foreach ($allowed as $ns_or_directive) {\r
                if (strpos($ns_or_directive, '.') !== false) {\r
                    // directive\r
                    if ($ns_or_directive[0] == '-') {\r
                        $blacklisted_directives[substr($ns_or_directive, 1)] = true;\r
                    } else {\r
                        $allowed_directives[$ns_or_directive] = true;\r
                    }\r
                } else {\r
                    // namespace\r
                    $allowed_ns[$ns_or_directive] = true;\r
                }\r
            }\r
        }\r
        $ret = array();\r
        foreach ($schema->info as $key => $def) {\r
            list($ns, $directive) = explode('.', $key, 2);\r
            if ($allowed !== true) {\r
                if (isset($blacklisted_directives["$ns.$directive"])) {\r
                    continue;\r
                }\r
                if (!isset($allowed_directives["$ns.$directive"]) && !isset($allowed_ns[$ns])) {\r
                    continue;\r
                }\r
            }\r
            if (isset($def->isAlias)) {\r
                continue;\r
            }\r
            if ($directive == 'DefinitionID' || $directive == 'DefinitionRev') {\r
                continue;\r
            }\r
            $ret[] = array($ns, $directive);\r
        }\r
        return $ret;\r
    }\r
\r
    /**\r
     * Loads configuration values from $_GET/$_POST that were posted\r
     * via ConfigForm\r
     *\r
     * @param array $array $_GET or $_POST array to import\r
     * @param string|bool $index Index/name that the config variables are in\r
     * @param array|bool $allowed List of allowed namespaces/directives\r
     * @param bool $mq_fix Boolean whether or not to enable magic quotes fix\r
     * @param HTMLPurifier_ConfigSchema $schema Schema to use, if not global copy\r
     *\r
     * @return mixed\r
     */\r
    public static function loadArrayFromForm($array, $index = false, $allowed = true, $mq_fix = true, $schema = null)\r
    {\r
        $ret = HTMLPurifier_Config::prepareArrayFromForm($array, $index, $allowed, $mq_fix, $schema);\r
        $config = HTMLPurifier_Config::create($ret, $schema);\r
        return $config;\r
    }\r
\r
    /**\r
     * Merges in configuration values from $_GET/$_POST to object. NOT STATIC.\r
     *\r
     * @param array $array $_GET or $_POST array to import\r
     * @param string|bool $index Index/name that the config variables are in\r
     * @param array|bool $allowed List of allowed namespaces/directives\r
     * @param bool $mq_fix Boolean whether or not to enable magic quotes fix\r
     */\r
    public function mergeArrayFromForm($array, $index = false, $allowed = true, $mq_fix = true)\r
    {\r
         $ret = HTMLPurifier_Config::prepareArrayFromForm($array, $index, $allowed, $mq_fix, $this->def);\r
         $this->loadArray($ret);\r
    }\r
\r
    /**\r
     * Prepares an array from a form into something usable for the more\r
     * strict parts of HTMLPurifier_Config\r
     *\r
     * @param array $array $_GET or $_POST array to import\r
     * @param string|bool $index Index/name that the config variables are in\r
     * @param array|bool $allowed List of allowed namespaces/directives\r
     * @param bool $mq_fix Boolean whether or not to enable magic quotes fix\r
     * @param HTMLPurifier_ConfigSchema $schema Schema to use, if not global copy\r
     *\r
     * @return array\r
     */\r
    public static function prepareArrayFromForm($array, $index = false, $allowed = true, $mq_fix = true, $schema = null)\r
    {\r
        if ($index !== false) {\r
            $array = (isset($array[$index]) && is_array($array[$index])) ? $array[$index] : array();\r
        }\r
        $mq = $mq_fix && function_exists('get_magic_quotes_gpc') && get_magic_quotes_gpc();\r
\r
        $allowed = HTMLPurifier_Config::getAllowedDirectivesForForm($allowed, $schema);\r
        $ret = array();\r
        foreach ($allowed as $key) {\r
            list($ns, $directive) = $key;\r
            $skey = "$ns.$directive";\r
            if (!empty($array["Null_$skey"])) {\r
                $ret[$ns][$directive] = null;\r
                continue;\r
            }\r
            if (!isset($array[$skey])) {\r
                continue;\r
            }\r
            $value = $mq ? stripslashes($array[$skey]) : $array[$skey];\r
            $ret[$ns][$directive] = $value;\r
        }\r
        return $ret;\r
    }\r
\r
    /**\r
     * Loads configuration values from an ini file\r
     *\r
     * @param string $filename Name of ini file\r
     */\r
    public function loadIni($filename)\r
    {\r
        if ($this->isFinalized('Cannot load directives after finalization')) {\r
            return;\r
        }\r
        $array = parse_ini_file($filename, true);\r
        $this->loadArray($array);\r
    }\r
\r
    /**\r
     * Checks whether or not the configuration object is finalized.\r
     *\r
     * @param string|bool $error String error message, or false for no error\r
     *\r
     * @return bool\r
     */\r
    public function isFinalized($error = false)\r
    {\r
        if ($this->finalized && $error) {\r
            $this->triggerError($error, E_USER_ERROR);\r
        }\r
        return $this->finalized;\r
    }\r
\r
    /**\r
     * Finalizes configuration only if auto finalize is on and not\r
     * already finalized\r
     */\r
    public function autoFinalize()\r
    {\r
        if ($this->autoFinalize) {\r
            $this->finalize();\r
        } else {\r
            $this->plist->squash(true);\r
        }\r
    }\r
\r
    /**\r
     * Finalizes a configuration object, prohibiting further change\r
     */\r
    public function finalize()\r
    {\r
        $this->finalized = true;\r
        $this->parser = null;\r
    }\r
\r
    /**\r
     * Produces a nicely formatted error message by supplying the\r
     * stack frame information OUTSIDE of HTMLPurifier_Config.\r
     *\r
     * @param string $msg An error message\r
     * @param int $no An error number\r
     */\r
    protected function triggerError($msg, $no)\r
    {\r
        // determine previous stack frame\r
        $extra = '';\r
        if ($this->chatty) {\r
            $trace = debug_backtrace();\r
            // zip(tail(trace), trace) -- but PHP is not Haskell har har\r
            for ($i = 0, $c = count($trace); $i < $c - 1; $i++) {\r
                // XXX this is not correct on some versions of HTML Purifier\r
                if ($trace[$i + 1]['class'] === 'HTMLPurifier_Config') {\r
                    continue;\r
                }\r
                $frame = $trace[$i];\r
                $extra = " invoked on line {$frame['line']} in file {$frame['file']}";\r
                break;\r
            }\r
        }\r
        trigger_error($msg . $extra, $no);\r
    }\r
\r
    /**\r
     * Returns a serialized form of the configuration object that can\r
     * be reconstituted.\r
     *\r
     * @return string\r
     */\r
    public function serialize()\r
    {\r
        $this->getDefinition('HTML');\r
        $this->getDefinition('CSS');\r
        $this->getDefinition('URI');\r
        return serialize($this);\r
    }\r
\r
}\r
\r
// vim: et sw=4 sts=4\r