library/HTMLPurifier/Injector/AutoParagraph.php

   1 <?php
   2
   3 /**
   4  * Injector that auto paragraphs text in the root node based on
   5  * double-spacing.
   6  * @todo Ensure all states are unit tested, including variations as well.
   7  * @todo Make a graph of the flow control for this Injector.
   8  */
   9 class HTMLPurifier_Injector_AutoParagraph extends HTMLPurifier_Injector
  10 {
  11     /**
  12      * @type string
  13      */
  14     public $name = 'AutoParagraph';
  15
  16     /**
  17      * @type array
  18      */
  19     public $needed = array('p');
  20
  21     /**
  22      * @return HTMLPurifier_Token_Start
  23      */
  24     private function _pStart()
  25     {
  26         $par = new HTMLPurifier_Token_Start('p');
  27         $par->armor['MakeWellFormed_TagClosedError'] = true;
  28         return $par;
  29     }
  30
  31     /**
  32      * @param HTMLPurifier_Token_Text $token
  33      */
  34     public function handleText(&$token)
  35     {
  36         $text = $token->data;
  37         // Does the current parent allow <p> tags?
  38         if ($this->allowsElement('p')) {
  39             if (empty($this->currentNesting) || strpos($text, "\n\n") !== false) {
  40                 // Note that we have differing behavior when dealing with text
  41                 // in the anonymous root node, or a node inside the document.
  42                 // If the text as a double-newline, the treatment is the same;
  43                 // if it doesn't, see the next if-block if you're in the document.
  44
  45                 $i = $nesting = null;
  46                 if (!$this->forwardUntilEndToken($i, $current, $nesting) && $token->is_whitespace) {
  47                     // State 1.1: ...    ^ (whitespace, then document end)
  48                     //               ----
  49                     // This is a degenerate case
  50                 } else {
  51                     if (!$token->is_whitespace || $this->_isInline($current)) {
  52                         // State 1.2: PAR1
  53                         //            ----
  54
  55                         // State 1.3: PAR1\n\nPAR2
  56                         //            ------------
  57
  58                         // State 1.4: <div>PAR1\n\nPAR2 (see State 2)
  59                         //                 ------------
  60                         $token = array($this->_pStart());
  61                         $this->_splitText($text, $token);
  62                     } else {
  63                         // State 1.5: \n<hr />
  64                         //            --
  65                     }
  66                 }
  67             } else {
  68                 // State 2:   <div>PAR1... (similar to 1.4)
  69                 //                 ----
  70
  71                 // We're in an element that allows paragraph tags, but we're not
  72                 // sure if we're going to need them.
  73                 if ($this->_pLookAhead()) {
  74                     // State 2.1: <div>PAR1<b>PAR1\n\nPAR2
  75                     //                 ----
  76                     // Note: This will always be the first child, since any
  77                     // previous inline element would have triggered this very
  78                     // same routine, and found the double newline. One possible
  79                     // exception would be a comment.
  80                     $token = array($this->_pStart(), $token);
  81                 } else {
  82                     // State 2.2.1: <div>PAR1<div>
  83                     //                   ----
  84
  85                     // State 2.2.2: <div>PAR1<b>PAR1</b></div>
  86                     //                   ----
  87                 }
  88             }
  89             // Is the current parent a <p> tag?
  90         } elseif (!empty($this->currentNesting) &&
  91             $this->currentNesting[count($this->currentNesting) - 1]->name == 'p') {
  92             // State 3.1: ...<p>PAR1
  93             //                  ----
  94
  95             // State 3.2: ...<p>PAR1\n\nPAR2
  96             //                  ------------
  97             $token = array();
  98             $this->_splitText($text, $token);
  99             // Abort!
 100         } else {
 101             // State 4.1: ...<b>PAR1
 102             //                  ----
 103
 104             // State 4.2: ...<b>PAR1\n\nPAR2
 105             //                  ------------
 106         }
 107     }
 108
 109     /**
 110      * @param HTMLPurifier_Token $token
 111      */
 112     public function handleElement(&$token)
 113     {
 114         // We don't have to check if we're already in a <p> tag for block
 115         // tokens, because the tag would have been autoclosed by MakeWellFormed.
 116         if ($this->allowsElement('p')) {
 117             if (!empty($this->currentNesting)) {
 118                 if ($this->_isInline($token)) {
 119                     // State 1: <div>...<b>
 120                     //                  ---
 121                     // Check if this token is adjacent to the parent token
 122                     // (seek backwards until token isn't whitespace)
 123                     $i = null;
 124                     $this->backward($i, $prev);
 125
 126                     if (!$prev instanceof HTMLPurifier_Token_Start) {
 127                         // Token wasn't adjacent
 128                         if ($prev instanceof HTMLPurifier_Token_Text &&
 129                             substr($prev->data, -2) === "\n\n"
 130                         ) {
 131                             // State 1.1.4: <div><p>PAR1</p>\n\n<b>
 132                             //                                  ---
 133                             // Quite frankly, this should be handled by splitText
 134                             $token = array($this->_pStart(), $token);
 135                         } else {
 136                             // State 1.1.1: <div><p>PAR1</p><b>
 137                             //                              ---
 138                             // State 1.1.2: <div><br /><b>
 139                             //                         ---
 140                             // State 1.1.3: <div>PAR<b>
 141                             //                      ---
 142                         }
 143                     } else {
 144                         // State 1.2.1: <div><b>
 145                         //                   ---
 146                         // Lookahead to see if <p> is needed.
 147                         if ($this->_pLookAhead()) {
 148                             // State 1.3.1: <div><b>PAR1\n\nPAR2
 149                             //                   ---
 150                             $token = array($this->_pStart(), $token);
 151                         } else {
 152                             // State 1.3.2: <div><b>PAR1</b></div>
 153                             //                   ---
 154
 155                             // State 1.3.3: <div><b>PAR1</b><div></div>\n\n</div>
 156                             //                   ---
 157                         }
 158                     }
 159                 } else {
 160                     // State 2.3: ...<div>
 161                     //               -----
 162                 }
 163             } else {
 164                 if ($this->_isInline($token)) {
 165                     // State 3.1: <b>
 166                     //            ---
 167                     // This is where the {p} tag is inserted, not reflected in
 168                     // inputTokens yet, however.
 169                     $token = array($this->_pStart(), $token);
 170                 } else {
 171                     // State 3.2: <div>
 172                     //            -----
 173                 }
 174
 175                 $i = null;
 176                 if ($this->backward($i, $prev)) {
 177                     if (!$prev instanceof HTMLPurifier_Token_Text) {
 178                         // State 3.1.1: ...</p>{p}<b>
 179                         //                        ---
 180                         // State 3.2.1: ...</p><div>
 181                         //                     -----
 182                         if (!is_array($token)) {
 183                             $token = array($token);
 184                         }
 185                         array_unshift($token, new HTMLPurifier_Token_Text("\n\n"));
 186                     } else {
 187                         // State 3.1.2: ...</p>\n\n{p}<b>
 188                         //                            ---
 189                         // State 3.2.2: ...</p>\n\n<div>
 190                         //                         -----
 191                         // Note: PAR<ELEM> cannot occur because PAR would have been
 192                         // wrapped in <p> tags.
 193                     }
 194                 }
 195             }
 196         } else {
 197             // State 2.2: <ul><li>
 198             //                ----
 199             // State 2.4: <p><b>
 200             //               ---
 201         }
 202     }
 203
 204     /**
 205      * Splits up a text in paragraph tokens and appends them
 206      * to the result stream that will replace the original
 207      * @param string $data String text data that will be processed
 208      *    into paragraphs
 209      * @param HTMLPurifier_Token[] $result Reference to array of tokens that the
 210      *    tags will be appended onto
 211      */
 212     private function _splitText($data, &$result)
 213     {
 214         $raw_paragraphs = explode("\n\n", $data);
 215         $paragraphs = array(); // without empty paragraphs
 216         $needs_start = false;
 217         $needs_end = false;
 218
 219         $c = count($raw_paragraphs);
 220         if ($c == 1) {
 221             // There were no double-newlines, abort quickly. In theory this
 222             // should never happen.
 223             $result[] = new HTMLPurifier_Token_Text($data);
 224             return;
 225         }
 226         for ($i = 0; $i < $c; $i++) {
 227             $par = $raw_paragraphs[$i];
 228             if (trim($par) !== '') {
 229                 $paragraphs[] = $par;
 230             } else {
 231                 if ($i == 0) {
 232                     // Double newline at the front
 233                     if (empty($result)) {
 234                         // The empty result indicates that the AutoParagraph
 235                         // injector did not add any start paragraph tokens.
 236                         // This means that we have been in a paragraph for
 237                         // a while, and the newline means we should start a new one.
 238                         $result[] = new HTMLPurifier_Token_End('p');
 239                         $result[] = new HTMLPurifier_Token_Text("\n\n");
 240                         // However, the start token should only be added if
 241                         // there is more processing to be done (i.e. there are
 242                         // real paragraphs in here). If there are none, the
 243                         // next start paragraph tag will be handled by the
 244                         // next call to the injector
 245                         $needs_start = true;
 246                     } else {
 247                         // We just started a new paragraph!
 248                         // Reinstate a double-newline for presentation's sake, since
 249                         // it was in the source code.
 250                         array_unshift($result, new HTMLPurifier_Token_Text("\n\n"));
 251                     }
 252                 } elseif ($i + 1 == $c) {
 253                     // Double newline at the end
 254                     // There should be a trailing </p> when we're finally done.
 255                     $needs_end = true;
 256                 }
 257             }
 258         }
 259
 260         // Check if this was just a giant blob of whitespace. Move this earlier,
 261         // perhaps?
 262         if (empty($paragraphs)) {
 263             return;
 264         }
 265
 266         // Add the start tag indicated by \n\n at the beginning of $data
 267         if ($needs_start) {
 268             $result[] = $this->_pStart();
 269         }
 270
 271         // Append the paragraphs onto the result
 272         foreach ($paragraphs as $par) {
 273             $result[] = new HTMLPurifier_Token_Text($par);
 274             $result[] = new HTMLPurifier_Token_End('p');
 275             $result[] = new HTMLPurifier_Token_Text("\n\n");
 276             $result[] = $this->_pStart();
 277         }
 278
 279         // Remove trailing start token; Injector will handle this later if
 280         // it was indeed needed. This prevents from needing to do a lookahead,
 281         // at the cost of a lookbehind later.
 282         array_pop($result);
 283
 284         // If there is no need for an end tag, remove all of it and let
 285         // MakeWellFormed close it later.
 286         if (!$needs_end) {
 287             array_pop($result); // removes \n\n
 288             array_pop($result); // removes </p>
 289         }
 290     }
 291
 292     /**
 293      * Returns true if passed token is inline (and, ergo, allowed in
 294      * paragraph tags)
 295      * @param HTMLPurifier_Token $token
 296      * @return bool
 297      */
 298     private function _isInline($token)
 299     {
 300         return isset($this->htmlDefinition->info['p']->child->elements[$token->name]);
 301     }
 302
 303     /**
 304      * Looks ahead in the token list and determines whether or not we need
 305      * to insert a <p> tag.
 306      * @return bool
 307      */
 308     private function _pLookAhead()
 309     {
 310         if ($this->currentToken instanceof HTMLPurifier_Token_Start) {
 311             $nesting = 1;
 312         } else {
 313             $nesting = 0;
 314         }
 315         $ok = false;
 316         $i = null;
 317         while ($this->forwardUntilEndToken($i, $current, $nesting)) {
 318             $result = $this->_checkNeedsP($current);
 319             if ($result !== null) {
 320                 $ok = $result;
 321                 break;
 322             }
 323         }
 324         return $ok;
 325     }
 326
 327     /**
 328      * Determines if a particular token requires an earlier inline token
 329      * to get a paragraph. This should be used with _forwardUntilEndToken
 330      * @param HTMLPurifier_Token $current
 331      * @return bool
 332      */
 333     private function _checkNeedsP($current)
 334     {
 335         if ($current instanceof HTMLPurifier_Token_Start) {
 336             if (!$this->_isInline($current)) {
 337                 // <div>PAR1<div>
 338                 //      ----
 339                 // Terminate early, since we hit a block element
 340                 return false;
 341             }
 342         } elseif ($current instanceof HTMLPurifier_Token_Text) {
 343             if (strpos($current->data, "\n\n") !== false) {
 344                 // <div>PAR1<b>PAR1\n\nPAR2
 345                 //      ----
 346                 return true;
 347             } else {
 348                 // <div>PAR1<b>PAR1...
 349                 //      ----
 350             }
 351         }
 352         return null;
 353     }
 354 }
 355
 356 // vim: et sw=4 sts=4