HTMLPurifier_Injector_AutoParagraph Class Reference

Injector that auto paragraphs text in the root node based on double-spacing. More...

Inheritance diagram for HTMLPurifier_Injector_AutoParagraph:

Collaboration diagram for HTMLPurifier_Injector_AutoParagraph:

Public Member Functions
	handleText (&$token)
	Handler that is called when a text token is processed.
	handleElement (&$token)
	Handler that is called when a start or empty token is processed.
Public Member Functions inherited from HTMLPurifier_Injector
	rewind ($index)
	Rewind to a spot to re-perform processing.
	getRewind ()
	Retrieves rewind, and then unsets it.
	prepare ($config, $context)
	Prepares the injector by giving it the config and context objects: this allows references to important variables to be made within the injector.
	checkNeeded ($config)
	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.
	allowsElement ($name)
	Tests if the context node allows a certain element.
	handleEnd (&$token)
	Handler that is called when an end token is processed.
	notifyEnd ($token)
	Notifier that is called when an end token is processed.

Data Fields
	$name = 'AutoParagraph'
	$needed = array('p')
Data Fields inherited from HTMLPurifier_Injector
	$name
	Advisory name of injector, this is for friendly error messages.
	$needed = array()
	Array of elements and attributes this injector creates and therefore need to be allowed by the definition.

Private Member Functions
	_pStart ()
	_splitText ($data, &$result)
	Splits up a text in paragraph tokens and appends them to the result stream that will replace the original.
	_isInline ($token)
	Returns true if passed token is inline (and, ergo, allowed in paragraph tags)
	_pLookAhead ()
	Looks ahead in the token list and determines whether or not we need to insert a.
	_checkNeedsP ($current)
	Determines if a particular token requires an earlier inline token to get a paragraph.

Additional Inherited Members
Protected Member Functions inherited from HTMLPurifier_Injector
	forward (&$i, &$current)
	Iterator function, which starts with the next token and continues until you reach the end of the input tokens.
	forwardUntilEndToken (&$i, &$current, &$nesting)
	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.
	backward (&$i, &$current)
	Iterator function, starts with the previous token and continues until you reach the beginning of input tokens.
	current (&$i, &$current)
	Initializes the iterator at the current position.
Protected Attributes inherited from HTMLPurifier_Injector
	$htmlDefinition
	Instance of HTMLPurifier_HTMLDefinition.
	$currentNesting
	Reference to CurrentNesting variable in Context.
	$inputTokens
	Reference to InputTokens variable in Context.
	$inputIndex
	Reference to InputIndex variable in Context.
	$rewind = false
	Index of inputTokens to rewind to.

Detailed Description

Injector that auto paragraphs text in the root node based on double-spacing.

Todo:

Ensure all states are unit tested, including variations as well.

Make a graph of the flow control for this Injector.

Definition at line 9 of file AutoParagraph.php.

Member Function Documentation

HTMLPurifier_Injector_AutoParagraph::_checkNeedsP (   $current )

private

Determines if a particular token requires an earlier inline token to get a paragraph.

This should be used with _forwardUntilEndToken

Definition at line 317 of file AutoParagraph.php.

References _isInline(), and elseif().

Referenced by _pLookAhead().

                                            {
        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;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

HTMLPurifier_Injector_AutoParagraph::_isInline (   $token )

private

Returns true if passed token is inline (and, ergo, allowed in paragraph tags)

Definition at line 290 of file AutoParagraph.php.

Referenced by _checkNeedsP(), and handleElement().

                                       {
        return isset($this->htmlDefinition->info['p']->child->elements[$token->name]);
    }

Here is the caller graph for this function:

HTMLPurifier_Injector_AutoParagraph::_pLookAhead ( )

private

Looks ahead in the token list and determines whether or not we need to insert a.

tag.

Definition at line 298 of file AutoParagraph.php.

References $ok, $result, _checkNeedsP(), HTMLPurifier_Injector\current(), and HTMLPurifier_Injector\forwardUntilEndToken().

Referenced by handleElement(), and handleText().

                                   {
        $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;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

HTMLPurifier_Injector_AutoParagraph::_pStart ( )

private

Definition at line 15 of file AutoParagraph.php.

Referenced by _splitText(), handleElement(), and handleText().

                               {
        $par = new HTMLPurifier_Token_Start('p');
        $par->armor['MakeWellFormed_TagClosedError'] = true;
        return $par;
    }

Here is the caller graph for this function:

HTMLPurifier_Injector_AutoParagraph::_splitText (   $data, &  $result  )

private

Splits up a text in paragraph tokens and appends them to the result stream that will replace the original.

Parameters

$data	String text data that will be processed into paragraphs
$result	Reference to array of tokens that the tags will be appended onto
$config	Instance of HTMLPurifier_Config
$context	Instance of HTMLPurifier_Context

Definition at line 206 of file AutoParagraph.php.

References $data, $result, _pStart(), and elseif().

Referenced by handleText().

                                                 {
        $raw_paragraphs = explode("\n\n", $data);
        $paragraphs  = array(); // without empty paragraphs
        $needs_start = false;
        $needs_end   = false;

        $c = count($raw_paragraphs);
        if ($c == 1) {
            // There were no double-newlines, abort quickly. In theory this
            // should never happen.
            $result[] = new HTMLPurifier_Token_Text($data);
            return;
        }
        for ($i = 0; $i < $c; $i++) {
            $par = $raw_paragraphs[$i];
            if (trim($par) !== '') {
                $paragraphs[] = $par;
            } else {
                if ($i == 0) {
                    // Double newline at the front
                    if (empty($result)) {
                        // The empty result indicates that the AutoParagraph
                        // injector did not add any start paragraph tokens.
                        // This means that we have been in a paragraph for
                        // a while, and the newline means we should start a new one.
                        $result[] = new HTMLPurifier_Token_End('p');
                        $result[] = new HTMLPurifier_Token_Text("\n\n");
                        // However, the start token should only be added if
                        // there is more processing to be done (i.e. there are
                        // real paragraphs in here). If there are none, the
                        // next start paragraph tag will be handled by the
                        // next call to the injector
                        $needs_start = true;
                    } else {
                        // We just started a new paragraph!
                        // Reinstate a double-newline for presentation's sake, since
                        // it was in the source code.
                        array_unshift($result, new HTMLPurifier_Token_Text("\n\n"));
                    }
                } 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 this was just a giant blob of whitespace. Move this earlier,
        // perhaps?
        if (empty($paragraphs)) {
            return;
        }

        // Add the start tag indicated by \n\n at the beginning of $data
        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[] = new HTMLPurifier_Token_Text("\n\n");
            $result[] = $this->_pStart();
        }

        // Remove trailing start token; Injector will handle this later if
        // it was indeed needed. This prevents from needing to do a lookahead,
        // at the cost of a lookbehind later.
        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>
        }

    }

Here is the call graph for this function:

Here is the caller graph for this function:

HTMLPurifier_Injector_AutoParagraph::handleElement

(

&

$token

)

Handler that is called when a start or empty token is processed.

Reimplemented from HTMLPurifier_Injector.

Definition at line 92 of file AutoParagraph.php.

References _isInline(), _pLookAhead(), _pStart(), HTMLPurifier_Injector\allowsElement(), and HTMLPurifier_Injector\backward().

                                           {
        // We don't have to check if we're already in a <p> tag for block
        // tokens, because the tag would have been autoclosed by MakeWellFormed.
        if ($this->allowsElement('p')) {
            if (!empty($this->currentNesting)) {
                if ($this->_isInline($token)) {
                    // State 1: <div>...<b>
                    //                  ---

                    // Check if this token is adjacent to the parent token
                    // (seek backwards until token isn't whitespace)
                    $i = null;
                    $this->backward($i, $prev);

                    if (!$prev instanceof HTMLPurifier_Token_Start) {
                        // Token wasn't adjacent

                        if (
                            $prev instanceof HTMLPurifier_Token_Text &&
                            substr($prev->data, -2) === "\n\n"
                        ) {
                            // State 1.1.4: <div><p>PAR1</p>\n\n<b>
                            //                                  ---

                            // Quite frankly, this should be handled by splitText
                            $token = array($this->_pStart(), $token);
                        } else {
                            // State 1.1.1: <div><p>PAR1</p><b>
                            //                              ---

                            // State 1.1.2: <div><br /><b>
                            //                         ---

                            // State 1.1.3: <div>PAR<b>
                            //                      ---
                        }

                    } else {
                        // State 1.2.1: <div><b>
                        //                   ---

                        // 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>
                            //                   ---
                        }
                    }
                } else {
                    // State 2.3: ...<div>
                    //               -----
                }
            } 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);
                } 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.
                    }
                }
            }
        } else {
            // State 2.2: <ul><li>
            //                ----

            // State 2.4: <p><b>
            //               ---
        }
    }

Here is the call graph for this function:

HTMLPurifier_Injector_AutoParagraph::handleText

(

&

$token

)

Handler that is called when a text token is processed.

Reimplemented from HTMLPurifier_Injector.

Definition at line 21 of file AutoParagraph.php.

References _pLookAhead(), _pStart(), _splitText(), HTMLPurifier_Injector\allowsElement(), elseif(), and HTMLPurifier_Injector\forwardUntilEndToken().

                                        {
        $text = $token->data;
        // Does the current parent allow <p> tags?
        if ($this->allowsElement('p')) {
            if (empty($this->currentNesting) || strpos($text, "\n\n") !== false) {
                // Note that we have differing behavior when dealing with text
                // in the anonymous root node, or a node inside the document.
                // If the text as a double-newline, the treatment is the same;
                // if it doesn't, see the next if-block if you're in the document.

                $i = $nesting = null;
                if (!$this->forwardUntilEndToken($i, $current, $nesting) && $token->is_whitespace) {
                    // State 1.1: ...    ^ (whitespace, then document end)
                    //               ----
                    // This is a degenerate case
                } else {
                    // State 1.2: PAR1
                    //            ----

                    // State 1.3: PAR1\n\nPAR2
                    //            ------------

                    // State 1.4: <div>PAR1\n\nPAR2 (see State 2)
                    //                 ------------
                    $token = array($this->_pStart());
                    $this->_splitText($text, $token);
                }
            } else {
                // State 2:   <div>PAR1... (similar to 1.4)
                //                 ----

                // 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);
                } 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
            //                  ------------
        }
    }

Here is the call graph for this function:

Field Documentation

HTMLPurifier_Injector_AutoParagraph::$name = 'AutoParagraph'

Definition at line 12 of file AutoParagraph.php.

HTMLPurifier_Injector_AutoParagraph::$needed = array('p')

Definition at line 13 of file AutoParagraph.php.

---

The documentation for this class was generated from the following file:

• Services/Html/HtmlPurifier/library/HTMLPurifier/Injector/AutoParagraph.php