[Summary view]

   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