[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  namespace dokuwiki\Parsing\Handler;
   4  
   5  /**
   6   * Handler for paragraphs
   7   *
   8   * @author Harry Fuecks <hfuecks@gmail.com>
   9   */
  10  class Block
  11  {
  12      protected $calls = [];
  13      protected $skipEol = false;
  14      protected $inParagraph = false;
  15  
  16      // Blocks these should not be inside paragraphs
  17      protected $blockOpen = [
  18          'header', 'listu_open', 'listo_open', 'listitem_open', 'listcontent_open', 'table_open', 'tablerow_open',
  19          'tablecell_open', 'tableheader_open', 'tablethead_open', 'quote_open', 'code', 'file', 'hr', 'preformatted',
  20          'rss', 'footnote_open'
  21      ];
  22  
  23      protected $blockClose = [
  24          'header', 'listu_close', 'listo_close', 'listitem_close', 'listcontent_close', 'table_close',
  25          'tablerow_close', 'tablecell_close', 'tableheader_close', 'tablethead_close', 'quote_close', 'code', 'file',
  26          'hr', 'preformatted', 'rss', 'footnote_close'
  27      ];
  28  
  29      // Stacks can contain paragraphs
  30      protected $stackOpen = ['section_open'];
  31  
  32      protected $stackClose = ['section_close'];
  33  
  34  
  35      /**
  36       * Constructor. Adds loaded syntax plugins to the block and stack
  37       * arrays
  38       *
  39       * @author Andreas Gohr <andi@splitbrain.org>
  40       */
  41      public function __construct()
  42      {
  43          global $DOKU_PLUGINS;
  44          //check if syntax plugins were loaded
  45          if (empty($DOKU_PLUGINS['syntax'])) return;
  46          foreach ($DOKU_PLUGINS['syntax'] as $n => $p) {
  47              $ptype = $p->getPType();
  48              if ($ptype == 'block') {
  49                  $this->blockOpen[]  = 'plugin_' . $n;
  50                  $this->blockClose[] = 'plugin_' . $n;
  51              } elseif ($ptype == 'stack') {
  52                  $this->stackOpen[]  = 'plugin_' . $n;
  53                  $this->stackClose[] = 'plugin_' . $n;
  54              }
  55          }
  56      }
  57  
  58      protected function openParagraph($pos)
  59      {
  60          if ($this->inParagraph) return;
  61          $this->calls[] = ['p_open', [], $pos];
  62          $this->inParagraph = true;
  63          $this->skipEol = true;
  64      }
  65  
  66      /**
  67       * Close a paragraph if needed
  68       *
  69       * This function makes sure there are no empty paragraphs on the stack
  70       *
  71       * @author Andreas Gohr <andi@splitbrain.org>
  72       *
  73       * @param string|integer $pos
  74       */
  75      protected function closeParagraph($pos)
  76      {
  77          if (!$this->inParagraph) return;
  78          // look back if there was any content - we don't want empty paragraphs
  79          $content = '';
  80          $ccount = count($this->calls);
  81          for ($i = $ccount - 1; $i >= 0; $i--) {
  82              if ($this->calls[$i][0] == 'p_open') {
  83                  break;
  84              } elseif ($this->calls[$i][0] == 'cdata') {
  85                  $content .= $this->calls[$i][1][0];
  86              } else {
  87                  $content = 'found markup';
  88                  break;
  89              }
  90          }
  91  
  92          if (trim($content) == '') {
  93              //remove the whole paragraph
  94              //array_splice($this->calls,$i); // <- this is much slower than the loop below
  95              for (
  96                  $x = $ccount; $x > $i;
  97                  $x--
  98              ) array_pop($this->calls);
  99          } else {
 100              // remove ending linebreaks in the paragraph
 101              $i = count($this->calls) - 1;
 102              if ($this->calls[$i][0] == 'cdata') $this->calls[$i][1][0] = rtrim($this->calls[$i][1][0], "\n");
 103              $this->calls[] = ['p_close', [], $pos];
 104          }
 105  
 106          $this->inParagraph = false;
 107          $this->skipEol = true;
 108      }
 109  
 110      protected function addCall($call)
 111      {
 112          $key = count($this->calls);
 113          if ($key && $call[0] == 'cdata' && $this->calls[$key - 1][0] == 'cdata') {
 114              $this->calls[$key - 1][1][0] .= $call[1][0];
 115          } else {
 116              $this->calls[] = $call;
 117          }
 118      }
 119  
 120      // simple version of addCall, without checking cdata
 121      protected function storeCall($call)
 122      {
 123          $this->calls[] = $call;
 124      }
 125  
 126      /**
 127       * Processes the whole instruction stack to open and close paragraphs
 128       *
 129       * @author Harry Fuecks <hfuecks@gmail.com>
 130       * @author Andreas Gohr <andi@splitbrain.org>
 131       *
 132       * @param array $calls
 133       *
 134       * @return array
 135       */
 136      public function process($calls)
 137      {
 138          // open first paragraph
 139          $this->openParagraph(0);
 140          foreach ($calls as $key => $call) {
 141              $cname = $call[0];
 142              if ($cname == 'plugin') {
 143                  $cname = 'plugin_' . $call[1][0];
 144                  $plugin = true;
 145                  $plugin_open = (($call[1][2] == DOKU_LEXER_ENTER) || ($call[1][2] == DOKU_LEXER_SPECIAL));
 146                  $plugin_close = (($call[1][2] == DOKU_LEXER_EXIT) || ($call[1][2] == DOKU_LEXER_SPECIAL));
 147              } else {
 148                  $plugin = false;
 149              }
 150              /* stack */
 151              if (in_array($cname, $this->stackClose) && (!$plugin || $plugin_close)) {
 152                  $this->closeParagraph($call[2]);
 153                  $this->storeCall($call);
 154                  $this->openParagraph($call[2]);
 155                  continue;
 156              }
 157              if (in_array($cname, $this->stackOpen) && (!$plugin || $plugin_open)) {
 158                  $this->closeParagraph($call[2]);
 159                  $this->storeCall($call);
 160                  $this->openParagraph($call[2]);
 161                  continue;
 162              }
 163              /* block */
 164              // If it's a substition it opens and closes at the same call.
 165              // To make sure next paragraph is correctly started, let close go first.
 166              if (in_array($cname, $this->blockClose) && (!$plugin || $plugin_close)) {
 167                  $this->closeParagraph($call[2]);
 168                  $this->storeCall($call);
 169                  $this->openParagraph($call[2]);
 170                  continue;
 171              }
 172              if (in_array($cname, $this->blockOpen) && (!$plugin || $plugin_open)) {
 173                  $this->closeParagraph($call[2]);
 174                  $this->storeCall($call);
 175                  continue;
 176              }
 177              /* eol */
 178              if ($cname == 'eol') {
 179                  // Check this isn't an eol instruction to skip...
 180                  if (!$this->skipEol) {
 181                      // Next is EOL => double eol => mark as paragraph
 182                      if (isset($calls[$key + 1]) && $calls[$key + 1][0] == 'eol') {
 183                          $this->closeParagraph($call[2]);
 184                          $this->openParagraph($call[2]);
 185                      } else {
 186                          //if this is just a single eol make a space from it
 187                          $this->addCall(['cdata', ["\n"], $call[2]]);
 188                      }
 189                  }
 190                  continue;
 191              }
 192              /* normal */
 193              $this->addCall($call);
 194              $this->skipEol = false;
 195          }
 196          // close last paragraph
 197          $call = end($this->calls);
 198          $this->closeParagraph($call[2]);
 199          return $this->calls;
 200      }
 201  }