1 files changed, 176 insertions, 0 deletions
diff --git a/inc/3rdparty/htmlpurifier/HTMLPurifier/ConfigSchema.php b/inc/3rdparty/htmlpurifier/HTMLPurifier/ConfigSchema.php
new file mode 100644
index 00000000..ab7e7c0b
--- /dev/null
+++ b/inc/3rdparty/htmlpurifier/HTMLPurifier/ConfigSchema.php
@@ -0,0 +1,176 @@
+<?php
+/**
+ * Configuration definition, defines directives and their defaults.
+ */
+class HTMLPurifier_ConfigSchema
+{
+    /**
+     * Defaults of the directives and namespaces.
+     * @type array
+     * @note This shares the exact same structure as HTMLPurifier_Config::$conf
+     */
+    public $defaults = array();
+    /**
+     * The default property list. Do not edit this property list.
+     * @type array
+     */
+    public $defaultPlist;
+    /**
+     * Definition of the directives.
+     * The structure of this is:
+     *
+     *  array(
+     *      'Namespace' => array(
+     *          'Directive' => new stdclass(),
+     *      )
+     *  )
+     *
+     * The stdclass may have the following properties:
+     *
+     *  - If isAlias isn't set:
+     *      - type: Integer type of directive, see HTMLPurifier_VarParser for definitions
+     *      - allow_null: If set, this directive allows null values
+     *      - aliases: If set, an associative array of value aliases to real values
+     *      - allowed: If set, a lookup array of allowed (string) values
+     *  - If isAlias is set:
+     *      - namespace: Namespace this directive aliases to
+     *      - name: Directive name this directive aliases to
+     *
+     * In certain degenerate cases, stdclass will actually be an integer. In
+     * that case, the value is equivalent to an stdclass with the type
+     * property set to the integer. If the integer is negative, type is
+     * equal to the absolute value of integer, and allow_null is true.
+     *
+     * This class is friendly with HTMLPurifier_Config. If you need introspection
+     * about the schema, you're better of using the ConfigSchema_Interchange,
+     * which uses more memory but has much richer information.
+     * @type array
+     */
+    public $info = array();
+    /**
+     * Application-wide singleton
+     * @type HTMLPurifier_ConfigSchema
+     */
+    protected static $singleton;
+    public function __construct()
+    {
+        $this->defaultPlist = new HTMLPurifier_PropertyList();
+    }
+    /**
+     * Unserializes the default ConfigSchema.
+     * @return HTMLPurifier_ConfigSchema
+     */
+    public static function makeFromSerial()
+    {
+        $contents = file_get_contents(HTMLPURIFIER_PREFIX . '/HTMLPurifier/ConfigSchema/schema.ser');
+        $r = unserialize($contents);
+        if (!$r) {
+            $hash = sha1($contents);
+            trigger_error("Unserialization of configuration schema failed, sha1 of file was $hash", E_USER_ERROR);
+        }
+        return $r;
+    }
+    /**
+     * Retrieves an instance of the application-wide configuration definition.
+     * @param HTMLPurifier_ConfigSchema $prototype
+     * @return HTMLPurifier_ConfigSchema
+     */
+    public static function instance($prototype = null)
+    {
+        if ($prototype !== null) {
+            HTMLPurifier_ConfigSchema::$singleton = $prototype;
+        } elseif (HTMLPurifier_ConfigSchema::$singleton === null || $prototype === true) {
+            HTMLPurifier_ConfigSchema::$singleton = HTMLPurifier_ConfigSchema::makeFromSerial();
+        }
+        return HTMLPurifier_ConfigSchema::$singleton;
+    }
+    /**
+     * Defines a directive for configuration
+     * @warning Will fail of directive's namespace is defined.
+     * @warning This method's signature is slightly different from the legacy
+     *          define() static method! Beware!
+     * @param string $key Name of directive
+     * @param mixed $default Default value of directive
+     * @param string $type Allowed type of the directive. See
+     *      HTMLPurifier_DirectiveDef::$type for allowed values
+     * @param bool $allow_null Whether or not to allow null values
+     */
+    public function add($key, $default, $type, $allow_null)
+    {
+        $obj = new stdclass();
+        $obj->type = is_int($type) ? $type : HTMLPurifier_VarParser::$types[$type];
+        if ($allow_null) {
+            $obj->allow_null = true;
+        }
+        $this->info[$key] = $obj;
+        $this->defaults[$key] = $default;
+        $this->defaultPlist->set($key, $default);
+    }
+    /**
+     * Defines a directive value alias.
+     *
+     * Directive value aliases are convenient for developers because it lets
+     * them set a directive to several values and get the same result.
+     * @param string $key Name of Directive
+     * @param array $aliases Hash of aliased values to the real alias
+     */
+    public function addValueAliases($key, $aliases)
+    {
+        if (!isset($this->info[$key]->aliases)) {
+            $this->info[$key]->aliases = array();
+        }
+        foreach ($aliases as $alias => $real) {
+            $this->info[$key]->aliases[$alias] = $real;
+        }
+    }
+    /**
+     * Defines a set of allowed values for a directive.
+     * @warning This is slightly different from the corresponding static
+     *          method definition.
+     * @param string $key Name of directive
+     * @param array $allowed Lookup array of allowed values
+     */
+    public function addAllowedValues($key, $allowed)
+    {
+        $this->info[$key]->allowed = $allowed;
+    }
+    /**
+     * Defines a directive alias for backwards compatibility
+     * @param string $key Directive that will be aliased
+     * @param string $new_key Directive that the alias will be to
+     */
+    public function addAlias($key, $new_key)
+    {
+        $obj = new stdclass;
+        $obj->key = $new_key;
+        $obj->isAlias = true;
+        $this->info[$key] = $obj;
+    }
+    /**
+     * Replaces any stdclass that only has the type property with type integer.
+     */
+    public function postProcess()
+    {
+        foreach ($this->info as $key => $v) {
+            if (count((array) $v) == 1) {
+                $this->info[$key] = $v->type;
+            } elseif (count((array) $v) == 2 && isset($v->allow_null)) {
+                $this->info[$key] = -$v->type;
+            }
+        }
+    }
+}
+// vim: et sw=4 sts=4

diff --git a/inc/3rdparty/htmlpurifier/HTMLPurifier/ConfigSchema.php b/inc/3rdparty/htmlpurifier/HTMLPurifier/ConfigSchema.php new file mode 100644 index 00000000..ab7e7c0b --- /dev/null +++ b/inc/3rdparty/htmlpurifier/HTMLPurifier/ConfigSchema.php
@@ -0,0 +1,176 @@
	1	<?php
	2
	3	/**
	4	* Configuration definition, defines directives and their defaults.
	5	*/
	6	class HTMLPurifier_ConfigSchema
	7	{
	8	/**
	9	* Defaults of the directives and namespaces.
	10	* @type array
	11	* @note This shares the exact same structure as HTMLPurifier_Config::$conf
	12	*/
	13	public $defaults = array();
	14
	15	/**
	16	* The default property list. Do not edit this property list.
	17	* @type array
	18	*/
	19	public $defaultPlist;
	20
	21	/**
	22	* Definition of the directives.
	23	* The structure of this is:
	24	*
	25	* array(
	26	* 'Namespace' => array(
	27	* 'Directive' => new stdclass(),
	28	* )
	29	* )
	30	*
	31	* The stdclass may have the following properties:
	32	*
	33	* - If isAlias isn't set:
	34	* - type: Integer type of directive, see HTMLPurifier_VarParser for definitions
	35	* - allow_null: If set, this directive allows null values
	36	* - aliases: If set, an associative array of value aliases to real values
	37	* - allowed: If set, a lookup array of allowed (string) values
	38	* - If isAlias is set:
	39	* - namespace: Namespace this directive aliases to
	40	* - name: Directive name this directive aliases to
	41	*
	42	* In certain degenerate cases, stdclass will actually be an integer. In
	43	* that case, the value is equivalent to an stdclass with the type
	44	* property set to the integer. If the integer is negative, type is
	45	* equal to the absolute value of integer, and allow_null is true.
	46	*
	47	* This class is friendly with HTMLPurifier_Config. If you need introspection
	48	* about the schema, you're better of using the ConfigSchema_Interchange,
	49	* which uses more memory but has much richer information.
	50	* @type array
	51	*/
	52	public $info = array();
	53
	54	/**
	55	* Application-wide singleton
	56	* @type HTMLPurifier_ConfigSchema
	57	*/
	58	protected static $singleton;
	59
	60	public function __construct()
	61	{
	62	$this->defaultPlist = new HTMLPurifier_PropertyList();
	63	}
	64
	65	/**
	66	* Unserializes the default ConfigSchema.
	67	* @return HTMLPurifier_ConfigSchema
	68	*/
	69	public static function makeFromSerial()
	70	{
	71	$contents = file_get_contents(HTMLPURIFIER_PREFIX . '/HTMLPurifier/ConfigSchema/schema.ser');
	72	$r = unserialize($contents);
	73	if (!$r) {
	74	$hash = sha1($contents);
	75	trigger_error("Unserialization of configuration schema failed, sha1 of file was $hash", E_USER_ERROR);
	76	}
	77	return $r;
	78	}
	79
	80	/**
	81	* Retrieves an instance of the application-wide configuration definition.
	82	* @param HTMLPurifier_ConfigSchema $prototype
	83	* @return HTMLPurifier_ConfigSchema
	84	*/
	85	public static function instance($prototype = null)
	86	{
	87	if ($prototype !== null) {
	88	HTMLPurifier_ConfigSchema::$singleton = $prototype;
	89	} elseif (HTMLPurifier_ConfigSchema::$singleton === null \|\| $prototype === true) {
	90	HTMLPurifier_ConfigSchema::$singleton = HTMLPurifier_ConfigSchema::makeFromSerial();
	91	}
	92	return HTMLPurifier_ConfigSchema::$singleton;
	93	}
	94
	95	/**
	96	* Defines a directive for configuration
	97	* @warning Will fail of directive's namespace is defined.
	98	* @warning This method's signature is slightly different from the legacy
	99	* define() static method! Beware!
	100	* @param string $key Name of directive
	101	* @param mixed $default Default value of directive
	102	* @param string $type Allowed type of the directive. See
	103	* HTMLPurifier_DirectiveDef::$type for allowed values
	104	* @param bool $allow_null Whether or not to allow null values
	105	*/
	106	public function add($key, $default, $type, $allow_null)
	107	{
	108	$obj = new stdclass();
	109	$obj->type = is_int($type) ? $type : HTMLPurifier_VarParser::$types[$type];
	110	if ($allow_null) {
	111	$obj->allow_null = true;
	112	}
	113	$this->info[$key] = $obj;
	114	$this->defaults[$key] = $default;
	115	$this->defaultPlist->set($key, $default);
	116	}
	117
	118	/**
	119	* Defines a directive value alias.
	120	*
	121	* Directive value aliases are convenient for developers because it lets
	122	* them set a directive to several values and get the same result.
	123	* @param string $key Name of Directive
	124	* @param array $aliases Hash of aliased values to the real alias
	125	*/
	126	public function addValueAliases($key, $aliases)
	127	{
	128	if (!isset($this->info[$key]->aliases)) {
	129	$this->info[$key]->aliases = array();
	130	}
	131	foreach ($aliases as $alias => $real) {
	132	$this->info[$key]->aliases[$alias] = $real;
	133	}
	134	}
	135
	136	/**
	137	* Defines a set of allowed values for a directive.
	138	* @warning This is slightly different from the corresponding static
	139	* method definition.
	140	* @param string $key Name of directive
	141	* @param array $allowed Lookup array of allowed values
	142	*/
	143	public function addAllowedValues($key, $allowed)
	144	{
	145	$this->info[$key]->allowed = $allowed;
	146	}
	147
	148	/**
	149	* Defines a directive alias for backwards compatibility
	150	* @param string $key Directive that will be aliased
	151	* @param string $new_key Directive that the alias will be to
	152	*/
	153	public function addAlias($key, $new_key)
	154	{
	155	$obj = new stdclass;
	156	$obj->key = $new_key;
	157	$obj->isAlias = true;
	158	$this->info[$key] = $obj;
	159	}
	160
	161	/**
	162	* Replaces any stdclass that only has the type property with type integer.
	163	*/
	164	public function postProcess()
	165	{
	166	foreach ($this->info as $key => $v) {
	167	if (count((array) $v) == 1) {
	168	$this->info[$key] = $v->type;
	169	} elseif (count((array) $v) == 2 && isset($v->allow_null)) {
	170	$this->info[$key] = -$v->type;
	171	}
	172	}
	173	}
	174	}
	175
	176	// vim: et sw=4 sts=4