[add] HTML Purifier added to clean code

author: Nicolas Lœuillet <nicolas.loeuillet@gmail.com> 2014-02-21 15:43:14 +0100
committer: Nicolas Lœuillet <nicolas.loeuillet@gmail.com> 2014-02-21 15:43:14 +0100
commit: d4949327efa15b492cab1bef3fe074290a328a17 (patch)
tree: e89e0322bb1f1b06d663fd10fdded21bac867e5d /inc/3rdparty/htmlpurifier/HTMLPurifier/Injector.php
parent: c9bd17a1007bb78e5de0775efca01df0fb515031 (diff)
download: wallabag-d4949327efa15b492cab1bef3fe074290a328a17.tar.gz
wallabag-d4949327efa15b492cab1bef3fe074290a328a17.tar.zst
wallabag-d4949327efa15b492cab1bef3fe074290a328a17.zip
1 files changed, 281 insertions, 0 deletions
diff --git a/inc/3rdparty/htmlpurifier/HTMLPurifier/Injector.php b/inc/3rdparty/htmlpurifier/HTMLPurifier/Injector.php
new file mode 100644
index 00000000..f1a74a4a
--- /dev/null
+++ b/inc/3rdparty/htmlpurifier/HTMLPurifier/Injector.php
@@ -0,0 +1,281 @@
+<?php
+/**
+ * Injects tokens into the document while parsing for well-formedness.
+ * This enables "formatter-like" functionality such as auto-paragraphing,
+ * smiley-ification and linkification to take place.
+ *
+ * A note on how handlers create changes; this is done by assigning a new
+ * value to the $token reference. These values can take a variety of forms and
+ * are best described HTMLPurifier_Strategy_MakeWellFormed->processToken()
+ * documentation.
+ *
+ * @todo Allow injectors to request a re-run on their output. This
+ *       would help if an operation is recursive.
+ */
+abstract class HTMLPurifier_Injector
+{
+    /**
+     * Advisory name of injector, this is for friendly error messages.
+     * @type string
+     */
+    public $name;
+    /**
+     * @type HTMLPurifier_HTMLDefinition
+     */
+    protected $htmlDefinition;
+    /**
+     * Reference to CurrentNesting variable in Context. This is an array
+     * list of tokens that we are currently "inside"
+     * @type array
+     */
+    protected $currentNesting;
+    /**
+     * Reference to current token.
+     * @type HTMLPurifier_Token
+     */
+    protected $currentToken;
+    /**
+     * Reference to InputZipper variable in Context.
+     * @type HTMLPurifier_Zipper
+     */
+    protected $inputZipper;
+    /**
+     * Array of elements and attributes this injector creates and therefore
+     * need to be allowed by the definition. Takes form of
+     * array('element' => array('attr', 'attr2'), 'element2')
+     * @type array
+     */
+    public $needed = array();
+    /**
+     * Number of elements to rewind backwards (relative).
+     * @type bool|int
+     */
+    protected $rewindOffset = false;
+    /**
+     * Rewind to a spot to re-perform processing. This is useful if you
+     * deleted a node, and now need to see if this change affected any
+     * earlier nodes. Rewinding does not affect other injectors, and can
+     * result in infinite loops if not used carefully.
+     * @param bool|int $offset
+     * @warning HTML Purifier will prevent you from fast-forwarding with this
+     *          function.
+     */
+    public function rewindOffset($offset)
+    {
+        $this->rewindOffset = $offset;
+    }
+    /**
+     * Retrieves rewind offset, and then unsets it.
+     * @return bool|int
+     */
+    public function getRewindOffset()
+    {
+        $r = $this->rewindOffset;
+        $this->rewindOffset = false;
+        return $r;
+    }
+    /**
+     * Prepares the injector by giving it the config and context objects:
+     * this allows references to important variables to be made within
+     * the injector. This function also checks if the HTML environment
+     * will work with the Injector (see checkNeeded()).
+     * @param HTMLPurifier_Config $config
+     * @param HTMLPurifier_Context $context
+     * @return bool|string Boolean false if success, string of missing needed element/attribute if failure
+     */
+    public function prepare($config, $context)
+    {
+        $this->htmlDefinition = $config->getHTMLDefinition();
+        // Even though this might fail, some unit tests ignore this and
+        // still test checkNeeded, so be careful. Maybe get rid of that
+        // dependency.
+        $result = $this->checkNeeded($config);
+        if ($result !== false) {
+            return $result;
+        }
+        $this->currentNesting =& $context->get('CurrentNesting');
+        $this->currentToken   =& $context->get('CurrentToken');
+        $this->inputZipper    =& $context->get('InputZipper');
+        return false;
+    }
+    /**
+     * This function checks if the HTML environment
+     * will work with the Injector: if p tags are not allowed, the
+     * Auto-Paragraphing injector should not be enabled.
+     * @param HTMLPurifier_Config $config
+     * @return bool|string Boolean false if success, string of missing needed element/attribute if failure
+     */
+    public function checkNeeded($config)
+    {
+        $def = $config->getHTMLDefinition();
+        foreach ($this->needed as $element => $attributes) {
+            if (is_int($element)) {
+                $element = $attributes;
+            }
+            if (!isset($def->info[$element])) {
+                return $element;
+            }
+            if (!is_array($attributes)) {
+                continue;
+            }
+            foreach ($attributes as $name) {
+                if (!isset($def->info[$element]->attr[$name])) {
+                    return "$element.$name";
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Tests if the context node allows a certain element
+     * @param string $name Name of element to test for
+     * @return bool True if element is allowed, false if it is not
+     */
+    public function allowsElement($name)
+    {
+        if (!empty($this->currentNesting)) {
+            $parent_token = array_pop($this->currentNesting);
+            $this->currentNesting[] = $parent_token;
+            $parent = $this->htmlDefinition->info[$parent_token->name];
+        } else {
+            $parent = $this->htmlDefinition->info_parent_def;
+        }
+        if (!isset($parent->child->elements[$name]) || isset($parent->excludes[$name])) {
+            return false;
+        }
+        // check for exclusion
+        for ($i = count($this->currentNesting) - 2; $i >= 0; $i--) {
+            $node = $this->currentNesting[$i];
+            $def  = $this->htmlDefinition->info[$node->name];
+            if (isset($def->excludes[$name])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Iterator function, which starts with the next token and continues until
+     * you reach the end of the input tokens.
+     * @warning Please prevent previous references from interfering with this
+     *          functions by setting $i = null beforehand!
+     * @param int $i Current integer index variable for inputTokens
+     * @param HTMLPurifier_Token $current Current token variable.
+     *          Do NOT use $token, as that variable is also a reference
+     * @return bool
+     */
+    protected function forward(&$i, &$current)
+    {
+        if ($i === null) {
+            $i = count($this->inputZipper->back) - 1;
+        } else {
+            $i--;
+        }
+        if ($i < 0) {
+            return false;
+        }
+        $current = $this->inputZipper->back[$i];
+        return true;
+    }
+    /**
+     * Similar to _forward, but accepts a third parameter $nesting (which
+     * should be initialized at 0) and stops when we hit the end tag
+     * for the node $this->inputIndex starts in.
+     * @param int $i Current integer index variable for inputTokens
+     * @param HTMLPurifier_Token $current Current token variable.
+     *          Do NOT use $token, as that variable is also a reference
+     * @param int $nesting
+     * @return bool
+     */
+    protected function forwardUntilEndToken(&$i, &$current, &$nesting)
+    {
+        $result = $this->forward($i, $current);
+        if (!$result) {
+            return false;
+        }
+        if ($nesting === null) {
+            $nesting = 0;
+        }
+        if ($current instanceof HTMLPurifier_Token_Start) {
+            $nesting++;
+        } elseif ($current instanceof HTMLPurifier_Token_End) {
+            if ($nesting <= 0) {
+                return false;
+            }
+            $nesting--;
+        }
+        return true;
+    }
+    /**
+     * Iterator function, starts with the previous token and continues until
+     * you reach the beginning of input tokens.
+     * @warning Please prevent previous references from interfering with this
+     *          functions by setting $i = null beforehand!
+     * @param int $i Current integer index variable for inputTokens
+     * @param HTMLPurifier_Token $current Current token variable.
+     *          Do NOT use $token, as that variable is also a reference
+     * @return bool
+     */
+    protected function backward(&$i, &$current)
+    {
+        if ($i === null) {
+            $i = count($this->inputZipper->front) - 1;
+        } else {
+            $i--;
+        }
+        if ($i < 0) {
+            return false;
+        }
+        $current = $this->inputZipper->front[$i];
+        return true;
+    }
+    /**
+     * Handler that is called when a text token is processed
+     */
+    public function handleText(&$token)
+    {
+    }
+    /**
+     * Handler that is called when a start or empty token is processed
+     */
+    public function handleElement(&$token)
+    {
+    }
+    /**
+     * Handler that is called when an end token is processed
+     */
+    public function handleEnd(&$token)
+    {
+        $this->notifyEnd($token);
+    }
+    /**
+     * Notifier that is called when an end token is processed
+     * @param HTMLPurifier_Token $token Current token variable.
+     * @note This differs from handlers in that the token is read-only
+     * @deprecated
+     */
+    public function notifyEnd($token)
+    {
+    }
+}
+// vim: et sw=4 sts=4
author	Nicolas Lœuillet <nicolas.loeuillet@gmail.com>	2014-02-21 15:43:14 +0100
committer	Nicolas Lœuillet <nicolas.loeuillet@gmail.com>	2014-02-21 15:43:14 +0100
commit	d4949327efa15b492cab1bef3fe074290a328a17 (patch)
tree	e89e0322bb1f1b06d663fd10fdded21bac867e5d /inc/3rdparty/htmlpurifier/HTMLPurifier/Injector.php
parent	c9bd17a1007bb78e5de0775efca01df0fb515031 (diff)
download	wallabag-d4949327efa15b492cab1bef3fe074290a328a17.tar.gz wallabag-d4949327efa15b492cab1bef3fe074290a328a17.tar.zst wallabag-d4949327efa15b492cab1bef3fe074290a328a17.zip

diff --git a/inc/3rdparty/htmlpurifier/HTMLPurifier/Injector.php b/inc/3rdparty/htmlpurifier/HTMLPurifier/Injector.php new file mode 100644 index 00000000..f1a74a4a --- /dev/null +++ b/inc/3rdparty/htmlpurifier/HTMLPurifier/Injector.php
@@ -0,0 +1,281 @@
	1	<?php
	2
	3	/**
	4	* Injects tokens into the document while parsing for well-formedness.
	5	* This enables "formatter-like" functionality such as auto-paragraphing,
	6	* smiley-ification and linkification to take place.
	7	*
	8	* A note on how handlers create changes; this is done by assigning a new
	9	* value to the $token reference. These values can take a variety of forms and
	10	* are best described HTMLPurifier_Strategy_MakeWellFormed->processToken()
	11	* documentation.
	12	*
	13	* @todo Allow injectors to request a re-run on their output. This
	14	* would help if an operation is recursive.
	15	*/
	16	abstract class HTMLPurifier_Injector
	17	{
	18
	19	/**
	20	* Advisory name of injector, this is for friendly error messages.
	21	* @type string
	22	*/
	23	public $name;
	24
	25	/**
	26	* @type HTMLPurifier_HTMLDefinition
	27	*/
	28	protected $htmlDefinition;
	29
	30	/**
	31	* Reference to CurrentNesting variable in Context. This is an array
	32	* list of tokens that we are currently "inside"
	33	* @type array
	34	*/
	35	protected $currentNesting;
	36
	37	/**
	38	* Reference to current token.
	39	* @type HTMLPurifier_Token
	40	*/
	41	protected $currentToken;
	42
	43	/**
	44	* Reference to InputZipper variable in Context.
	45	* @type HTMLPurifier_Zipper
	46	*/
	47	protected $inputZipper;
	48
	49	/**
	50	* Array of elements and attributes this injector creates and therefore
	51	* need to be allowed by the definition. Takes form of
	52	* array('element' => array('attr', 'attr2'), 'element2')
	53	* @type array
	54	*/
	55	public $needed = array();
	56
	57	/**
	58	* Number of elements to rewind backwards (relative).
	59	* @type bool\|int
	60	*/
	61	protected $rewindOffset = false;
	62
	63	/**
	64	* Rewind to a spot to re-perform processing. This is useful if you
	65	* deleted a node, and now need to see if this change affected any
	66	* earlier nodes. Rewinding does not affect other injectors, and can
	67	* result in infinite loops if not used carefully.
	68	* @param bool\|int $offset
	69	* @warning HTML Purifier will prevent you from fast-forwarding with this
	70	* function.
	71	*/
	72	public function rewindOffset($offset)
	73	{
	74	$this->rewindOffset = $offset;
	75	}
	76
	77	/**
	78	* Retrieves rewind offset, and then unsets it.
	79	* @return bool\|int
	80	*/
	81	public function getRewindOffset()
	82	{
	83	$r = $this->rewindOffset;
	84	$this->rewindOffset = false;
	85	return $r;
	86	}
	87
	88	/**
	89	* Prepares the injector by giving it the config and context objects:
	90	* this allows references to important variables to be made within
	91	* the injector. This function also checks if the HTML environment
	92	* will work with the Injector (see checkNeeded()).
	93	* @param HTMLPurifier_Config $config
	94	* @param HTMLPurifier_Context $context
	95	* @return bool\|string Boolean false if success, string of missing needed element/attribute if failure
	96	*/
	97	public function prepare($config, $context)
	98	{
	99	$this->htmlDefinition = $config->getHTMLDefinition();
	100	// Even though this might fail, some unit tests ignore this and
	101	// still test checkNeeded, so be careful. Maybe get rid of that
	102	// dependency.
	103	$result = $this->checkNeeded($config);
	104	if ($result !== false) {
	105	return $result;
	106	}
	107	$this->currentNesting =& $context->get('CurrentNesting');
	108	$this->currentToken =& $context->get('CurrentToken');
	109	$this->inputZipper =& $context->get('InputZipper');
	110	return false;
	111	}
	112
	113	/**
	114	* This function checks if the HTML environment
	115	* will work with the Injector: if p tags are not allowed, the
	116	* Auto-Paragraphing injector should not be enabled.
	117	* @param HTMLPurifier_Config $config
	118	* @return bool\|string Boolean false if success, string of missing needed element/attribute if failure
	119	*/
	120	public function checkNeeded($config)
	121	{
	122	$def = $config->getHTMLDefinition();
	123	foreach ($this->needed as $element => $attributes) {
	124	if (is_int($element)) {
	125	$element = $attributes;
	126	}
	127	if (!isset($def->info[$element])) {
	128	return $element;
	129	}
	130	if (!is_array($attributes)) {
	131	continue;
	132	}
	133	foreach ($attributes as $name) {
	134	if (!isset($def->info[$element]->attr[$name])) {
	135	return "$element.$name";
	136	}
	137	}
	138	}
	139	return false;
	140	}
	141
	142	/**
	143	* Tests if the context node allows a certain element
	144	* @param string $name Name of element to test for
	145	* @return bool True if element is allowed, false if it is not
	146	*/
	147	public function allowsElement($name)
	148	{
	149	if (!empty($this->currentNesting)) {
	150	$parent_token = array_pop($this->currentNesting);
	151	$this->currentNesting[] = $parent_token;
	152	$parent = $this->htmlDefinition->info[$parent_token->name];
	153	} else {
	154	$parent = $this->htmlDefinition->info_parent_def;
	155	}
	156	if (!isset($parent->child->elements[$name]) \|\| isset($parent->excludes[$name])) {
	157	return false;
	158	}
	159	// check for exclusion
	160	for ($i = count($this->currentNesting) - 2; $i >= 0; $i--) {
	161	$node = $this->currentNesting[$i];
	162	$def = $this->htmlDefinition->info[$node->name];
	163	if (isset($def->excludes[$name])) {
	164	return false;
	165	}
	166	}
	167	return true;
	168	}
	169
	170	/**
	171	* Iterator function, which starts with the next token and continues until
	172	* you reach the end of the input tokens.
	173	* @warning Please prevent previous references from interfering with this
	174	* functions by setting $i = null beforehand!
	175	* @param int $i Current integer index variable for inputTokens
	176	* @param HTMLPurifier_Token $current Current token variable.
	177	* Do NOT use $token, as that variable is also a reference
	178	* @return bool
	179	*/
	180	protected function forward(&$i, &$current)
	181	{
	182	if ($i === null) {
	183	$i = count($this->inputZipper->back) - 1;
	184	} else {
	185	$i--;
	186	}
	187	if ($i < 0) {
	188	return false;
	189	}
	190	$current = $this->inputZipper->back[$i];
	191	return true;
	192	}
	193
	194	/**
	195	* Similar to _forward, but accepts a third parameter $nesting (which
	196	* should be initialized at 0) and stops when we hit the end tag
	197	* for the node $this->inputIndex starts in.
	198	* @param int $i Current integer index variable for inputTokens
	199	* @param HTMLPurifier_Token $current Current token variable.
	200	* Do NOT use $token, as that variable is also a reference
	201	* @param int $nesting
	202	* @return bool
	203	*/
	204	protected function forwardUntilEndToken(&$i, &$current, &$nesting)
	205	{
	206	$result = $this->forward($i, $current);
	207	if (!$result) {
	208	return false;
	209	}
	210	if ($nesting === null) {
	211	$nesting = 0;
	212	}
	213	if ($current instanceof HTMLPurifier_Token_Start) {
	214	$nesting++;
	215	} elseif ($current instanceof HTMLPurifier_Token_End) {
	216	if ($nesting <= 0) {
	217	return false;
	218	}
	219	$nesting--;
	220	}
	221	return true;
	222	}
	223
	224	/**
	225	* Iterator function, starts with the previous token and continues until
	226	* you reach the beginning of input tokens.
	227	* @warning Please prevent previous references from interfering with this
	228	* functions by setting $i = null beforehand!
	229	* @param int $i Current integer index variable for inputTokens
	230	* @param HTMLPurifier_Token $current Current token variable.
	231	* Do NOT use $token, as that variable is also a reference
	232	* @return bool
	233	*/
	234	protected function backward(&$i, &$current)
	235	{
	236	if ($i === null) {
	237	$i = count($this->inputZipper->front) - 1;
	238	} else {
	239	$i--;
	240	}
	241	if ($i < 0) {
	242	return false;
	243	}
	244	$current = $this->inputZipper->front[$i];
	245	return true;
	246	}
	247
	248	/**
	249	* Handler that is called when a text token is processed
	250	*/
	251	public function handleText(&$token)
	252	{
	253	}
	254
	255	/**
	256	* Handler that is called when a start or empty token is processed
	257	*/
	258	public function handleElement(&$token)
	259	{
	260	}
	261
	262	/**
	263	* Handler that is called when an end token is processed
	264	*/
	265	public function handleEnd(&$token)
	266	{
	267	$this->notifyEnd($token);
	268	}
	269
	270	/**
	271	* Notifier that is called when an end token is processed
	272	* @param HTMLPurifier_Token $token Current token variable.
	273	* @note This differs from handlers in that the token is read-only
	274	* @deprecated
	275	*/
	276	public function notifyEnd($token)
	277	{
	278	}
	279	}
	280
	281	// vim: et sw=4 sts=4