mirrors/htmlpurifier
0
0
Fork 0
mirror of https://github.com/ezyang/htmlpurifier.git synced 2024-12-22 08:21:52 +00:00
Code Releases Activity

Improve auto-paragraph to preserve newlines and handle edge-cases better.

Browse Source 
This is a very large commit that includes numerous improvements to the
AutoParagraph injector.  These are:

* Rewritten flow control of the injector to use almost exclusively
  binary conditionals.
* Improved inline documentation with "State" comments, which give concise
  examples of what the token stack looks like at flow points.
* Documentation for all flow branches, even those with no actions.
* Factoring out of common operations to improve readability, especially the
  new iterator private methods.
* Expanded test-suite which covers new flow points, and corrects some errors
  in previous cases.

Signed-off-by: Edward Z. Yang <edwardzyang@thewritingpot.com>
This commit is contained in:
Edward Z. Yang 2008-08-10 00:32:29 -04:00
parent 0423985b45
commit 617f70a8ac
6 changed files with 515 additions and 207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
NEWS
View File

@ -26,6 +26,10 @@ NEWS ( CHANGELOG and HISTORY ) HTMLPurifier
'phpt', 'vtest', etc. in order to only execute those tests. This supercedes 'phpt', 'vtest', etc. in order to only execute those tests. This supercedes
the --only-phpt parameter, although for backwards-compatibility the flag the --only-phpt parameter, although for backwards-compatibility the flag
will still work. will still work.
! AutoParagraph auto-formatter will now preserve double-newlines upon output.
Users who are not performing inbound filtering, this may seem a little
useless, but as a bonus, the test suite and handling of edge cases is also
improved.
- Fix two bugs in %URI.MakeAbsolute; one involving empty paths in base URLs, - Fix two bugs in %URI.MakeAbsolute; one involving empty paths in base URLs,
the other involving an undefined $is_folder error. the other involving an undefined $is_folder error.
- Throw error when %Core.Encoding is set to a spurious value. Previously, - Throw error when %Core.Encoding is set to a spurious value. Previously,

3
TODO
View File

@ -14,7 +14,8 @@ afraid to cast your vote for the next feature to be implemented!
- Investigate how early internal structures can be accessed; this would - Investigate how early internal structures can be accessed; this would
prevent structures from being parsed and serialized multiple times. prevent structures from being parsed and serialized multiple times.
- Built-in support for target="_blank" on all external links - Built-in support for target="_blank" on all external links
- Allow <a id="asdf" name="asdf'> - Allow <a id="asdf" name="asdf">
- Implement overflow CSS property (as per jlp09550)
FUTURE VERSIONS FUTURE VERSIONS
--------------- ---------------

476
library/HTMLPurifier/Injector/AutoParagraph.php
View File

@ -3,6 +3,8 @@
/** /**
* Injector that auto paragraphs text in the root node based on * Injector that auto paragraphs text in the root node based on
* double-spacing. * double-spacing.
* @todo Ensure all states are unit tested, including variations as well.
* @todo Make a graph of the flow control for this Injector.
*/ */
class HTMLPurifier_Injector_AutoParagraph extends HTMLPurifier_Injector class HTMLPurifier_Injector_AutoParagraph extends HTMLPurifier_Injector
{ {
@ -18,116 +20,177 @@ class HTMLPurifier_Injector_AutoParagraph extends HTMLPurifier_Injector
public function handleText(&$token) { public function handleText(&$token) {
$text = $token->data; $text = $token->data;
if (empty($this->currentNesting)) { // Does the current parent allow <p> tags?
if (!$this->allowsElement('p')) return; if ($this->allowsElement('p')) {
// case 1: we're in root node (and it allows paragraphs) if (empty($this->currentNesting) || strpos($text, "\n\n") !== false) {
$token = array($this->_pStart()); // Note that we have differing behavior when dealing with text
$this->_splitText($text, $token); // in the anonymous root node, or a node inside the document.
} elseif ($this->currentNesting[count($this->currentNesting)-1]->name == 'p') { // If the text as a double-newline, the treatment is the same;
// case 2: we're in a paragraph // if it doesn't, see the next if-block if you're in the document.
$token = array();
$this->_splitText($text, $token); $i = $nesting = null;
} elseif ($this->allowsElement('p')) { if (!$this->_forwardUntilEndToken($i, $current, $nesting) && $token->is_whitespace) {
// case 3: we're in an element that allows paragraphs // State 1.1: ... ^ (whitespace, then document end)
if (strpos($text, "\n\n") !== false) { // ----
// case 3.1: this text node has a double-newline // This is a degenerate case
$token = array($this->_pStart()); } else {
$this->_splitText($text, $token); // State 1.2: PAR1
} else { // ----
$ok = false;
// test if up-coming tokens are either block or have // State 1.3: PAR1\n\nPAR2
// a double newline in them // ------------
$nesting = 0;
for ($i = $this->inputIndex + 1; isset($this->inputTokens[$i]); $i++) { // State 1.4: <div>PAR1\n\nPAR2 (see State 2)
if ($this->inputTokens[$i] instanceof HTMLPurifier_Token_Start){ // ------------
if (!$this->_isInline($this->inputTokens[$i])) { $token = array($this->_pStart());
// we haven't found a double-newline, and $this->_splitText($text, $token);
// we've hit a block element, so don't paragraph
$ok = false;
break;
}
$nesting++;
}
if ($this->inputTokens[$i] instanceof HTMLPurifier_Token_End) {
if ($nesting <= 0) break;
$nesting--;
}
if ($this->inputTokens[$i] instanceof HTMLPurifier_Token_Text) {
// found it!
if (strpos($this->inputTokens[$i]->data, "\n\n") !== false) {
$ok = true;
break;
}
}
} }
if ($ok) { } else {
// case 3.2: this text node is next to another node // State 2: <div>PAR1... (similar to 1.4)
// that will start a paragraph // ----
// We're in an element that allows paragraph tags, but we're not
// sure if we're going to need them.
if ($this->_pLookAhead()) {
// State 2.1: <div>PAR1<b>PAR1\n\nPAR2
// ----
// Note: This will always be the first child, since any
// previous inline element would have triggered this very
// same routine, and found the double newline. One possible
// exception would be a comment.
$token = array($this->_pStart(), $token); $token = array($this->_pStart(), $token);
} else {
// State 2.2.1: <div>PAR1<div>
// ----
// State 2.2.2: <div>PAR1<b>PAR1</b></div>
// ----
} }
} }
// Is the current parent a <p> tag?
} elseif (
!empty($this->currentNesting) &&
$this->currentNesting[count($this->currentNesting)-1]->name == 'p'
) {
// State 3.1: ...<p>PAR1
// ----
// State 3.2: ...<p>PAR1\n\nPAR2
// ------------
$token = array();
$this->_splitText($text, $token);
// Abort!
} else {
// State 4.1: ...<b>PAR1
// ----
// State 4.2: ...<b>PAR1\n\nPAR2
// ------------
} }
} }
public function handleElement(&$token) { public function handleElement(&$token) {
// check if we're inside a tag already // We don't have to check if we're already in a <p> tag for block
if (!empty($this->currentNesting)) { // tokens, because the tag would have been autoclosed by MakeWellFormed.
if ($this->allowsElement('p')) { if ($this->allowsElement('p')) {
// special case: we're in an element that allows paragraphs if (!empty($this->currentNesting)) {
if ($this->_isInline($token)) {
// this token is already paragraph, abort // State 1: <div>...<b>
if ($token->name == 'p') return; // ---
// this token is a block level, abort // Check if this token is adjacent to the parent token
if (!$this->_isInline($token)) return; // (seek backwards until token isn't whitespace)
$i = null;
// check if this token is adjacent to the parent token $this->_backward($i, $prev);
$prev = $this->inputTokens[$this->inputIndex - 1];
if (!$prev instanceof HTMLPurifier_Token_Start) { if (!$prev instanceof HTMLPurifier_Token_Start) {
// not adjacent, we can abort early // Token wasn't adjacent
// add lead paragraph tag if our token is inline
// and the previous tag was an end paragraph if (
if ( $prev instanceof HTMLPurifier_Token_Text &&
$prev->name == 'p' && $prev instanceof HTMLPurifier_Token_End && substr($prev->data, -2) === "\n\n"
$this->_isInline($token) ) {
) { // State 1.1.4: <div><p>PAR1</p>\n\n<b>
$token = array($this->_pStart(), $token); // ---
}
return; // Quite frankly, this should be handled by splitText
} $token = array($this->_pStart(), $token);
} else {
// this token is the first child of the element that allows // State 1.1.1: <div><p>PAR1</p><b>
// paragraph. We have to peek ahead and see whether or not // ---
// there is anything inside that suggests that a paragraph
// will be needed // State 1.1.2: <div><br /><b>
$ok = false; // ---
// maintain a mini-nesting counter, this lets us bail out
// early if possible // State 1.1.3: <div>PAR<b>
$j = 1; // current nesting, one is due to parent (we recalculate current token) // ---
for ($i = $this->inputIndex; isset($this->inputTokens[$i]); $i++) { }
if ($this->inputTokens[$i] instanceof HTMLPurifier_Token_Start) $j++;
if ($this->inputTokens[$i] instanceof HTMLPurifier_Token_End) $j--; } else {
if ($this->inputTokens[$i] instanceof HTMLPurifier_Token_Text) { // State 1.2.1: <div><b>
if (strpos($this->inputTokens[$i]->data, "\n\n") !== false) { // ---
$ok = true;
break; // Lookahead to see if <p> is needed.
if ($this->_pLookAhead()) {
// State 1.3.1: <div><b>PAR1\n\nPAR2
// ---
$token = array($this->_pStart(), $token);
} else {
// State 1.3.2: <div><b>PAR1</b></div>
// ---
// State 1.3.3: <div><b>PAR1</b><div></div>\n\n</div>
// ---
} }
} }
if ($j <= 0) break; } else {
// State 2.3: ...<div>
// -----
} }
if ($ok) { } else {
if ($this->_isInline($token)) {
// State 3.1: <b>
// ---
// This is where the {p} tag is inserted, not reflected in
// inputTokens yet, however.
$token = array($this->_pStart(), $token); $token = array($this->_pStart(), $token);
} else {
// State 3.2: <div>
// -----
}
$i = null;
if ($this->_backward($i, $prev)) {
if (
!$prev instanceof HTMLPurifier_Token_Text
) {
// State 3.1.1: ...</p>{p}<b>
// ---
// State 3.2.1: ...</p><div>
// -----
if (!is_array($token)) $token = array($token);
array_unshift($token, new HTMLPurifier_Token_Text("\n\n"));
} else {
// State 3.1.2: ...</p>\n\n{p}<b>
// ---
// State 3.2.2: ...</p>\n\n<div>
// -----
// Note: PAR<ELEM> cannot occur because PAR would have been
// wrapped in <p> tags.
}
} }
} }
return; } else {
// State 2.2: <ul><li>
// ----
// State 2.4: <p><b>
// ---
} }
// check if the start tag counts as a "block" element
if (!$this->_isInline($token)) return;
// append a paragraph tag before the token
$token = array($this->_pStart(), $token);
} }
/** /**
@ -142,96 +205,80 @@ class HTMLPurifier_Injector_AutoParagraph extends HTMLPurifier_Injector
*/ */
private function _splitText($data, &$result) { private function _splitText($data, &$result) {
$raw_paragraphs = explode("\n\n", $data); $raw_paragraphs = explode("\n\n", $data);
$paragraphs = array(); // without empty paragraphs
// remove empty paragraphs
$paragraphs = array();
$needs_start = false; $needs_start = false;
$needs_end = false; $needs_end = false;
$c = count($raw_paragraphs); $c = count($raw_paragraphs);
if ($c == 1) { if ($c == 1) {
// there were no double-newlines, abort quickly // There were no double-newlines, abort quickly. In theory this
// should never happen.
$result[] = new HTMLPurifier_Token_Text($data); $result[] = new HTMLPurifier_Token_Text($data);
return; return;
} }
for ($i = 0; $i < $c; $i++) { for ($i = 0; $i < $c; $i++) {
$par = $raw_paragraphs[$i]; $par = $raw_paragraphs[$i];
if (trim($par) !== '') { if (trim($par) !== '') {
$paragraphs[] = $par; $paragraphs[] = $par;
continue; } else {
} if ($i == 0) {
if ($i == 0 && empty($result)) { // Double newline at the front
// The empty result indicates that the AutoParagraph if (empty($result)) {
// injector did not add any start paragraph tokens. // The empty result indicates that the AutoParagraph
// The fact that the first paragraph is empty indicates // injector did not add any start paragraph tokens.
// that there was a double-newline at the start of the // This means that we have been in a paragraph for
// data. // a while, and the newline means we should start a new one.
// Combined together, this means that we are in a paragraph, $result[] = new HTMLPurifier_Token_End('p');
// and the newline means we should start a new one. $result[] = new HTMLPurifier_Token_Text("\n\n");
$result[] = new HTMLPurifier_Token_End('p'); // However, the start token should only be added if
// However, the start token should only be added if // there is more processing to be done (i.e. there are
// there is more processing to be done (i.e. there are // real paragraphs in here). If there are none, the
// real paragraphs in here). If there are none, the // next start paragraph tag will be handled by the
// next start paragraph tag will be handled by the // next call to the injector
// next run-around the injector $needs_start = true;
$needs_start = true; } else {
} elseif ($i + 1 == $c) { // We just started a new paragraph!
// a double-paragraph at the end indicates that // Reinstate a double-newline for presentation's sake, since
// there is an overriding need to start a new paragraph // it was in the source code.
// for the next section. This has no effect until array_unshift($result, new HTMLPurifier_Token_Text("\n\n"));
// we've processed all of the other paragraphs though }
$needs_end = true; } elseif ($i + 1 == $c) {
// Double newline at the end
// There should be a trailing </p> when we're finally done.
$needs_end = true;
}
} }
} }
// check if there are no "real" paragraphs to be processed // Check if this was just a giant blob of whitespace. Move this earlier,
// perhaps?
if (empty($paragraphs)) { if (empty($paragraphs)) {
return; return;
} }
// add a start tag if an end tag was added while processing // Add the start tag indicated by \n\n at the beginning of $data
// the raw paragraphs (that happens if there's a leading double if ($needs_start) {
// newline)
if ($needs_start) $result[] = $this->_pStart();
// append the paragraphs onto the result
foreach ($paragraphs as $par) {
$result[] = new HTMLPurifier_Token_Text($par);
$result[] = new HTMLPurifier_Token_End('p');
$result[] = $this->_pStart(); $result[] = $this->_pStart();
} }
// remove trailing start token, if one is needed, it will // Append the paragraphs onto the result
// be handled the next time this injector is called foreach ($paragraphs as $par) {
array_pop($result); $result[] = new HTMLPurifier_Token_Text($par);
$result[] = new HTMLPurifier_Token_End('p');
// check the outside to determine whether or not the $result[] = new HTMLPurifier_Token_Text("\n\n");
// end paragraph tag should be removed. It should be removed $result[] = $this->_pStart();
// unless the next non-whitespace token is a paragraph
// or a block element.
$remove_paragraph_end = true;
if (!$needs_end) {
// Start of the checks one after the current token's index
for ($i = $this->inputIndex + 1; isset($this->inputTokens[$i]); $i++) {
if ($this->inputTokens[$i] instanceof HTMLPurifier_Token_Start || $this->inputTokens[$i] instanceof HTMLPurifier_Token_Empty) {
$remove_paragraph_end = $this->_isInline($this->inputTokens[$i]);
}
// check if we can abort early (whitespace means we carry-on!)
if ($this->inputTokens[$i] instanceof HTMLPurifier_Token_Text && !$this->inputTokens[$i]->is_whitespace) break;
// end tags will automatically be handled by MakeWellFormed,
// so we don't have to worry about them
if ($this->inputTokens[$i] instanceof HTMLPurifier_Token_End) break;
}
} else {
$remove_paragraph_end = false;
} }
// check the outside to determine whether or not the // Remove trailing start token; Injector will handle this later if
// end paragraph tag should be removed // it was indeed needed. This prevents from needing to do a lookahead,
if ($remove_paragraph_end) { // at the cost of a lookbehind later.
array_pop($result); array_pop($result);
// If there is no need for an end tag, remove all of it and let
// MakeWellFormed close it later.
if (!$needs_end) {
array_pop($result); // removes \n\n
array_pop($result); // removes </p>
} }
} }
@ -244,5 +291,112 @@ class HTMLPurifier_Injector_AutoParagraph extends HTMLPurifier_Injector
return isset($this->htmlDefinition->info['p']->child->elements[$token->name]); return isset($this->htmlDefinition->info['p']->child->elements[$token->name]);
} }
/**
* Looks ahead in the token list and determines whether or not we need
* to insert a <p> tag.
*/
private function _pLookAhead() {
$this->_current($i, $current);
if ($current instanceof HTMLPurifier_Token_Start) $nesting = 1;
else $nesting = 0;
$ok = false;
while ($this->_forwardUntilEndToken($i, $current, $nesting)) {
$result = $this->_checkNeedsP($current);
if ($result !== null) {
$ok = $result;
break;
}
}
return $ok;
}
/**
* 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 &$i Current integer index variable for inputTokens
* @param &$current Current token variable. Do NOT use $token, as that variable is also a reference
*/
private function _forward(&$i, &$current) {
if ($i === null) $i = $this->inputIndex + 1;
else $i++;
if (!isset($this->inputTokens[$i])) return false;
$current = $this->inputTokens[$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.
*/
private 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 &$i Current integer index variable for inputTokens
* @param &$current Current token variable. Do NOT use $token, as that variable is also a reference
*/
private function _backward(&$i, &$current) {
if ($i === null) $i = $this->inputIndex - 1;
else $i--;
if ($i < 0) return false;
$current = $this->inputTokens[$i];
return true;
}
/**
* Initializes the iterator at the current position. Use in a do {} while;
* loop to force the _forward and _backward functions to start at the
* current location.
* @warning Please prevent previous references from interfering with this
* functions by setting $i = null beforehand!
* @param &$i Current integer index variable for inputTokens
* @param &$current Current token variable. Do NOT use $token, as that variable is also a reference
*/
private function _current(&$i, &$current) {
if ($i === null) $i = $this->inputIndex;
$current = $this->inputTokens[$i];
}
/**
* Determines if a particular token requires an earlier inline token
* to get a paragraph. This should be used with _forwardUntilEndToken
*/
private function _checkNeedsP($current) {
if ($current instanceof HTMLPurifier_Token_Start){
if (!$this->_isInline($current)) {
// <div>PAR1<div>
// ----
// Terminate early, since we hit a block element
return false;
}
} elseif ($current instanceof HTMLPurifier_Token_Text) {
if (strpos($current->data, "\n\n") !== false) {
// <div>PAR1<b>PAR1\n\nPAR2
// ----
return true;
} else {
// <div>PAR1<b>PAR1...
// ----
}
}
return null;
}
} }

11
tests/HTMLPurifier/ComplexHarness.php
View File

@ -35,16 +35,6 @@ class HTMLPurifier_ComplexHarness extends HTMLPurifier_Harness
*/ */
protected $lexer; protected $lexer;
/**
* Default config to fall back on if no config is available
*/
protected $config;
/**
* Default context to fall back on if no context is available
*/
protected $context;
public function __construct() { public function __construct() {
$this->lexer = new HTMLPurifier_Lexer_DirectLex(); $this->lexer = new HTMLPurifier_Lexer_DirectLex();
parent::__construct(); parent::__construct();
@ -88,7 +78,6 @@ class HTMLPurifier_ComplexHarness extends HTMLPurifier_Harness
$expect = $this->generate($expect); $expect = $this->generate($expect);
} }
} }
$this->assertIdentical($expect, $result); $this->assertIdentical($expect, $result);
} }

182
tests/HTMLPurifier/Injector/AutoParagraphTest.php
View File

@ -29,7 +29,9 @@ Par 1 still</p>'
'Par1 'Par1
Par2', Par2',
'<p>Par1</p><p>Par2</p>' "<p>Par1</p>
<p>Par2</p>"
); );
} }
@ -40,7 +42,9 @@ Par2',
Par2', Par2',
'<p>Par1</p><p>Par2</p>' '<p>Par1</p>
<p>Par2</p>'
); );
} }
@ -49,7 +53,9 @@ Par2',
'<b>Par1</b> '<b>Par1</b>
<i>Par2</i>', <i>Par2</i>',
'<p><b>Par1</b></p><p><i>Par2</i></p>' '<p><b>Par1</b></p>
<p><i>Par2</i></p>'
); );
} }
@ -67,7 +73,9 @@ Par2</b></p>'
function testAddParagraphAdjacentToParagraph() { function testAddParagraphAdjacentToParagraph() {
$this->assertResult( $this->assertResult(
'Par1<p>Par2</p>', 'Par1<p>Par2</p>',
'<p>Par1</p><p>Par2</p>' '<p>Par1</p>
<p>Par2</p>'
); );
} }
@ -91,7 +99,9 @@ Par1</pre>'
'Par1 'Par1
', ',
'<p>Par1</p>' '<p>Par1</p>
'
); );
} }
@ -102,7 +112,11 @@ Par1</pre>'
<div>Par2</div> <div>Par2</div>
Par3', Par3',
'<p>Par1</p><div>Par2</div><p>Par3</p>' '<p>Par1</p>
<div>Par2</div>
<p>Par3</p>'
); );
} }
@ -113,23 +127,29 @@ Par3',
); );
} }
function testIgnoreLeadingWhitespace() { function testPreserveLeadingWhitespace() {
$this->assertResult( $this->assertResult(
' '
Par', Par',
'<p>Par</p>' '
<p>Par</p>'
); );
} }
function testIgnoreSurroundingWhitespace() { function testPreserveSurroundingWhitespace() {
$this->assertResult( $this->assertResult(
' '
Par Par
', ',
'<p>Par</p>' '
<p>Par</p>
'
); );
} }
@ -138,7 +158,9 @@ Par
'<div>Par1 '<div>Par1
Par2</div>', Par2</div>',
'<div><p>Par1</p><p>Par2</p></div>' '<div><p>Par1</p>
<p>Par2</p></div>'
); );
} }
@ -147,7 +169,9 @@ Par2</div>',
'<div><b>Par1</b> '<div><b>Par1</b>
Par2</div>', Par2</div>',
'<div><p><b>Par1</b></p><p>Par2</p></div>' '<div><p><b>Par1</b></p>
<p>Par2</p></div>'
); );
} }
@ -160,7 +184,9 @@ Par2</div>',
'<div><b>Par1</b> '<div><b>Par1</b>
<i>Par2</i></div>', <i>Par2</i></div>',
'<div><p><b>Par1</b></p><p><i>Par2</i></p></div>' '<div><p><b>Par1</b></p>
<p><i>Par2</i></p></div>'
); );
} }
@ -177,7 +203,9 @@ Par2</div>',
'<div><p>Foo '<div><p>Foo
Bar</p></div>', Bar</p></div>',
'<div><p>Foo</p><p>Bar</p></div>' '<div><p>Foo</p>
<p>Bar</p></div>'
); );
} }
@ -186,7 +214,9 @@ Bar</p></div>',
'<div><p><b>Foo</b> '<div><p><b>Foo</b>
<i>Bar</i></p></div>', <i>Bar</i></p></div>',
'<div><p><b>Foo</b></p><p><i>Bar</i></p></div>' '<div><p><b>Foo</b></p>
<p><i>Bar</i></p></div>'
); );
} }
@ -199,7 +229,9 @@ Bar</p></div>',
'<blockquote>Par1 '<blockquote>Par1
Par2</blockquote>', Par2</blockquote>',
'<blockquote><p>Par1</p><p>Par2</p></blockquote>' '<blockquote><p>Par1</p>
<p>Par2</p></blockquote>'
); );
} }
@ -218,7 +250,11 @@ Par2</blockquote>',
Bar Bar
</div>', </div>',
'<div><p>Bar</p></div>' '<div>
<p>Bar</p>
</div>'
); );
} }
@ -229,7 +265,9 @@ Bar
Par2', Par2',
'<p><b>Par1</b>a</p><p>Par2</p>' '<p><b>Par1</b>a</p>
<p>Par2</p>'
); );
} }
@ -238,7 +276,9 @@ Par2',
'Par1 'Par1
Par2</p>', Par2</p>',
'<p>Par1</p><p>Par2</p>' '<p>Par1</p>
<p>Par2</p>'
); );
} }
@ -247,7 +287,9 @@ Par2</p>',
'Par1 'Par1
Par2</div>', Par2</div>',
'<p>Par1</p><p>Par2</p>' '<p>Par1</p>
<p>Par2</p>'
); );
} }
@ -264,7 +306,9 @@ Par1
'<div>Par1 '<div>Par1
<div>Par2</div></div>', <div>Par2</div></div>',
'<div><p>Par1</p><div>Par2</div></div>' '<div><p>Par1</p>
<div>Par2</div></div>'
); );
} }
@ -280,7 +324,9 @@ Par1
'Par1 'Par1
<div>Par2</div>', <div>Par2</div>',
'<p>Par1 '<p>Par1
</p><div>Par2</div>' </p>
<div>Par2</div>'
); );
} }
@ -289,7 +335,9 @@ Par1
'Par1 'Par1
<b>Par2</b>', <b>Par2</b>',
'<p>Par1</p><p><b>Par2</b></p>' '<p>Par1</p>
<p><b>Par2</b></p>'
); );
} }
@ -323,7 +371,9 @@ Par1
'<div><div>asdf</div> '<div><div>asdf</div>
<b>asdf</b></div>', <b>asdf</b></div>',
'<div><div>asdf</div><p><b>asdf</b></p></div>' '<div><div>asdf</div>
<p><b>asdf</b></p></div>'
); );
} }
@ -354,7 +404,9 @@ Par2'
'<div><code>bar</code> mmm '<div><code>bar</code> mmm
<pre>asdf</pre></div>', <pre>asdf</pre></div>',
'<div><p><code>bar</code> mmm</p><pre>asdf</pre></div>' '<div><p><code>bar</code> mmm</p>
<pre>asdf</pre></div>'
); );
} }
@ -363,7 +415,85 @@ Par2'
'<div>asdf <code>bar</code> mmm '<div>asdf <code>bar</code> mmm
<pre>asdf</pre></div>', <pre>asdf</pre></div>',
'<div><p>asdf <code>bar</code> mmm</p><pre>asdf</pre></div>' '<div><p>asdf <code>bar</code> mmm</p>
<pre>asdf</pre></div>'
);
}
function testUpcomingTokenHasNewline() {
$this->assertResult(
'<div>Test<b>foo</b>bar<b>bing</b>bang
boo</div>',
'<div><p>Test<b>foo</b>bar<b>bing</b>bang</p>
<p>boo</p></div>'
);
}
function testEmptyTokenAtEndOfDiv() {
$this->assertResult(
'<div><p>foo</p>
</div>',
'<div><p>foo</p>
</div>'
);
}
function testEmptyDoubleLineTokenAtEndOfDiv() {
$this->assertResult(
'<div><p>foo</p>
</div>',
'<div><p>foo</p>
</div>'
);
}
function testTextState11Root() {
$this->assertResult('<div></div> ');
}
function testTextState11Element() {
$this->assertResult(
"<div><div></div>
</div>");
}
function testTextStateLikeElementState111NoWhitespace() {
$this->assertResult('<div><p>P</p>Boo</div>', '<div><p>P</p>Boo</div>');
}
function testElementState111NoWhitespace() {
$this->assertResult('<div><p>P</p><b>Boo</b></div>', '<div><p>P</p><b>Boo</b></div>');
}
function testElementState133() {
$this->assertResult(
"<div><b>B</b><pre>Ba</pre>
Bar</div>",
"<div><b>B</b><pre>Ba</pre>
<p>Bar</p></div>"
);
}
function testElementState22() {
$this->assertResult(
'<ul><li>foo</li></ul>'
);
}
function testElementState311() {
$this->assertResult(
'<p>Foo</p><b>Bar</b>',
'<p>Foo</p>
<p><b>Bar</b></p>'
); );
} }

46
tests/HTMLPurifier/Strategy/MakeWellFormed_InjectorTest.php
View File

@ -72,14 +72,18 @@ class HTMLPurifier_Strategy_MakeWellFormed_InjectorTest extends HTMLPurifier_Str
function testTwoParagraphsContainingOnlyOneLink() { function testTwoParagraphsContainingOnlyOneLink() {
$this->assertResult( $this->assertResult(
"http://example.com\n\nhttp://dev.example.com", "http://example.com\n\nhttp://dev.example.com",
'<p><a href="http://example.com">http://example.com</a></p><p><a href="http://dev.example.com">http://dev.example.com</a></p>' '<p><a href="http://example.com">http://example.com</a></p>
<p><a href="http://dev.example.com">http://dev.example.com</a></p>'
); );
} }
function testParagraphNextToDivWithLinks() { function testParagraphNextToDivWithLinks() {
$this->assertResult( $this->assertResult(
'http://example.com <div>http://example.com</div>', 'http://example.com <div>http://example.com</div>',
'<p><a href="http://example.com">http://example.com</a> </p><div><a href="http://example.com">http://example.com</a></div>' '<p><a href="http://example.com">http://example.com</a> </p>
<div><a href="http://example.com">http://example.com</a></div>'
); );
} }
@ -92,24 +96,50 @@ class HTMLPurifier_Strategy_MakeWellFormed_InjectorTest extends HTMLPurifier_Str
function testParagraphAfterLinkifiedURL() { function testParagraphAfterLinkifiedURL() {
$this->assertResult( $this->assertResult(
"http://google.com\n\n<b>b</b>", "http://google.com
"<p><a href=\"http://google.com\">http://google.com</a></p><p><b>b</b></p>"
<b>b</b>",
"<p><a href=\"http://google.com\">http://google.com</a></p>
<p><b>b</b></p>"
); );
} }
function testEmptyAndParagraph() { function testEmptyAndParagraph() {
// This is a fairly degenerate case, but it demonstrates that // This is a fairly degenerate case, but it demonstrates that
// the two don't error out together, at least. // the two don't error out together, at least.
// Change this behavior!
$this->assertResult( $this->assertResult(
"<p>asdf\n\nasdf<b></b></p>\n\n<p></p><i></i>", "<p>asdf
"<p>asdf</p><p>asdf</p>"
asdf<b></b></p>
<p></p><i></i>",
"<p>asdf</p>
<p>asdf</p>
"
); );
} }
function testRewindAndParagraph() { function testRewindAndParagraph() {
// perhaps change the behavior of this?
$this->assertResult( $this->assertResult(
"bar\n\n<p><i></i>\n\n</p>\n\nfoo", "bar
"<p>bar</p><p>foo</p>"
<p><i></i>
</p>
foo",
"<p>bar</p>
<p></p>
<p>foo</p>"
); );
} }