1 files changed, 136 insertions, 0 deletions
diff --git a/inc/3rdparty/htmlpurifier/HTMLPurifier/StringHashParser.php b/inc/3rdparty/htmlpurifier/HTMLPurifier/StringHashParser.php
new file mode 100644
index 00000000..05abd837
--- /dev/null
+++ b/inc/3rdparty/htmlpurifier/HTMLPurifier/StringHashParser.php
@@ -0,0 +1,136 @@
+<?php
+/**
+ * Parses string hash files. File format is as such:
+ *
+ *      DefaultKeyValue
+ *      KEY: Value
+ *      KEY2: Value2
+ *      --MULTILINE-KEY--
+ *      Multiline
+ *      value.
+ *
+ * Which would output something similar to:
+ *
+ *      array(
+ *          'ID' => 'DefaultKeyValue',
+ *          'KEY' => 'Value',
+ *          'KEY2' => 'Value2',
+ *          'MULTILINE-KEY' => "Multiline\nvalue.\n",
+ *      )
+ *
+ * We use this as an easy to use file-format for configuration schema
+ * files, but the class itself is usage agnostic.
+ *
+ * You can use ---- to forcibly terminate parsing of a single string-hash;
+ * this marker is used in multi string-hashes to delimit boundaries.
+ */
+class HTMLPurifier_StringHashParser
+{
+    /**
+     * @type string
+     */
+    public $default = 'ID';
+    /**
+     * Parses a file that contains a single string-hash.
+     * @param string $file
+     * @return array
+     */
+    public function parseFile($file)
+    {
+        if (!file_exists($file)) {
+            return false;
+        }
+        $fh = fopen($file, 'r');
+        if (!$fh) {
+            return false;
+        }
+        $ret = $this->parseHandle($fh);
+        fclose($fh);
+        return $ret;
+    }
+    /**
+     * Parses a file that contains multiple string-hashes delimited by '----'
+     * @param string $file
+     * @return array
+     */
+    public function parseMultiFile($file)
+    {
+        if (!file_exists($file)) {
+            return false;
+        }
+        $ret = array();
+        $fh = fopen($file, 'r');
+        if (!$fh) {
+            return false;
+        }
+        while (!feof($fh)) {
+            $ret[] = $this->parseHandle($fh);
+        }
+        fclose($fh);
+        return $ret;
+    }
+    /**
+     * Internal parser that acepts a file handle.
+     * @note While it's possible to simulate in-memory parsing by using
+     *       custom stream wrappers, if such a use-case arises we should
+     *       factor out the file handle into its own class.
+     * @param resource $fh File handle with pointer at start of valid string-hash
+     *            block.
+     * @return array
+     */
+    protected function parseHandle($fh)
+    {
+        $state   = false;
+        $single  = false;
+        $ret     = array();
+        do {
+            $line = fgets($fh);
+            if ($line === false) {
+                break;
+            }
+            $line = rtrim($line, "\n\r");
+            if (!$state && $line === '') {
+                continue;
+            }
+            if ($line === '----') {
+                break;
+            }
+            if (strncmp('--#', $line, 3) === 0) {
+                // Comment
+                continue;
+            } elseif (strncmp('--', $line, 2) === 0) {
+                // Multiline declaration
+                $state = trim($line, '- ');
+                if (!isset($ret[$state])) {
+                    $ret[$state] = '';
+                }
+                continue;
+            } elseif (!$state) {
+                $single = true;
+                if (strpos($line, ':') !== false) {
+                    // Single-line declaration
+                    list($state, $line) = explode(':', $line, 2);
+                    $line = trim($line);
+                } else {
+                    // Use default declaration
+                    $state  = $this->default;
+                }
+            }
+            if ($single) {
+                $ret[$state] = $line;
+                $single = false;
+                $state  = false;
+            } else {
+                $ret[$state] .= "$line\n";
+            }
+        } while (!feof($fh));
+        return $ret;
+    }
+}
+// vim: et sw=4 sts=4

diff --git a/inc/3rdparty/htmlpurifier/HTMLPurifier/StringHashParser.php b/inc/3rdparty/htmlpurifier/HTMLPurifier/StringHashParser.php new file mode 100644 index 00000000..05abd837 --- /dev/null +++ b/inc/3rdparty/htmlpurifier/HTMLPurifier/StringHashParser.php
@@ -0,0 +1,136 @@
	1	<?php
	2
	3	/**
	4	* Parses string hash files. File format is as such:
	5	*
	6	* DefaultKeyValue
	7	* KEY: Value
	8	* KEY2: Value2
	9	* --MULTILINE-KEY--
	10	* Multiline
	11	* value.
	12	*
	13	* Which would output something similar to:
	14	*
	15	* array(
	16	* 'ID' => 'DefaultKeyValue',
	17	* 'KEY' => 'Value',
	18	* 'KEY2' => 'Value2',
	19	* 'MULTILINE-KEY' => "Multiline\nvalue.\n",
	20	* )
	21	*
	22	* We use this as an easy to use file-format for configuration schema
	23	* files, but the class itself is usage agnostic.
	24	*
	25	* You can use ---- to forcibly terminate parsing of a single string-hash;
	26	* this marker is used in multi string-hashes to delimit boundaries.
	27	*/
	28	class HTMLPurifier_StringHashParser
	29	{
	30
	31	/**
	32	* @type string
	33	*/
	34	public $default = 'ID';
	35
	36	/**
	37	* Parses a file that contains a single string-hash.
	38	* @param string $file
	39	* @return array
	40	*/
	41	public function parseFile($file)
	42	{
	43	if (!file_exists($file)) {
	44	return false;
	45	}
	46	$fh = fopen($file, 'r');
	47	if (!$fh) {
	48	return false;
	49	}
	50	$ret = $this->parseHandle($fh);
	51	fclose($fh);
	52	return $ret;
	53	}
	54
	55	/**
	56	* Parses a file that contains multiple string-hashes delimited by '----'
	57	* @param string $file
	58	* @return array
	59	*/
	60	public function parseMultiFile($file)
	61	{
	62	if (!file_exists($file)) {
	63	return false;
	64	}
	65	$ret = array();
	66	$fh = fopen($file, 'r');
	67	if (!$fh) {
	68	return false;
	69	}
	70	while (!feof($fh)) {
	71	$ret[] = $this->parseHandle($fh);
	72	}
	73	fclose($fh);
	74	return $ret;
	75	}
	76
	77	/**
	78	* Internal parser that acepts a file handle.
	79	* @note While it's possible to simulate in-memory parsing by using
	80	* custom stream wrappers, if such a use-case arises we should
	81	* factor out the file handle into its own class.
	82	* @param resource $fh File handle with pointer at start of valid string-hash
	83	* block.
	84	* @return array
	85	*/
	86	protected function parseHandle($fh)
	87	{
	88	$state = false;
	89	$single = false;
	90	$ret = array();
	91	do {
	92	$line = fgets($fh);
	93	if ($line === false) {
	94	break;
	95	}
	96	$line = rtrim($line, "\n\r");
	97	if (!$state && $line === '') {
	98	continue;
	99	}
	100	if ($line === '----') {
	101	break;
	102	}
	103	if (strncmp('--#', $line, 3) === 0) {
	104	// Comment
	105	continue;
	106	} elseif (strncmp('--', $line, 2) === 0) {
	107	// Multiline declaration
	108	$state = trim($line, '- ');
	109	if (!isset($ret[$state])) {
	110	$ret[$state] = '';
	111	}
	112	continue;
	113	} elseif (!$state) {
	114	$single = true;
	115	if (strpos($line, ':') !== false) {
	116	// Single-line declaration
	117	list($state, $line) = explode(':', $line, 2);
	118	$line = trim($line);
	119	} else {
	120	// Use default declaration
	121	$state = $this->default;
	122	}
	123	}
	124	if ($single) {
	125	$ret[$state] = $line;
	126	$single = false;
	127	$state = false;
	128	} else {
	129	$ret[$state] .= "$line\n";
	130	}
	131	} while (!feof($fh));
	132	return $ret;
	133	}
	134	}
	135
	136	// vim: et sw=4 sts=4