[Sommaire] [Imprimer]

   1  <?php
   2  // $Id: Table.php,v 1.1 2005/01/31 15:46:52 pmjones Exp $
   3  
   4  
   5  /**
   6  * 
   7  * This class implements a Text_Wiki_Parse to find source text marked as a
   8  * set of table rows, where a line start and ends with double-pipes (||)
   9  * and uses double-pipes to separate table cells.  The rows must be on
  10  * sequential lines (no blank lines between them) -- a blank line
  11  * indicates the beginning of a new table.
  12  *
  13  * @author Paul M. Jones <pmjones@ciaweb.net>
  14  *
  15  * @package Text_Wiki
  16  *
  17  */
  18  
  19  class Text_Wiki_Parse_Table extends Text_Wiki_Parse {
  20      
  21      
  22      /**
  23      * 
  24      * The regular expression used to parse the source text and find
  25      * matches conforming to this rule.  Used by the parse() method.
  26      * 
  27      * @access public
  28      * 
  29      * @var string
  30      * 
  31      * @see parse()
  32      * 
  33      */
  34      
  35      var $regex = '/\n((\|\|).*)(\n)(?!(\|\|))/Us';
  36      
  37      
  38      /**
  39      * 
  40      * Generates a replacement for the matched text.
  41      * 
  42      * Token options are:
  43      * 
  44      * 'type' =>
  45      *     'table_start' : the start of a bullet list
  46      *     'table_end'   : the end of a bullet list
  47      *     'row_start' : the start of a number list
  48      *     'row_end'   : the end of a number list
  49      *     'cell_start'   : the start of item text (bullet or number)
  50      *     'cell_end'     : the end of item text (bullet or number)
  51      * 
  52      * 'cols' => the number of columns in the table (for 'table_start')
  53      * 
  54      * 'rows' => the number of rows in the table (for 'table_start')
  55      * 
  56      * 'span' => column span (for 'cell_start')
  57      * 
  58      * 'attr' => column attribute flag (for 'cell_start')
  59      * 
  60      * @access public
  61      *
  62      * @param array &$matches The array of matches from parse().
  63      *
  64      * @return A series of text and delimited tokens marking the different
  65      * table elements and cell text.
  66      *
  67      */
  68      
  69      function process(&$matches)
  70      {
  71          // our eventual return value
  72          $return = '';
  73          
  74          // the number of columns in the table
  75          $num_cols = 0;
  76          
  77          // the number of rows in the table
  78          $num_rows = 0;
  79          
  80          // rows are separated by newlines in the matched text
  81          $rows = explode("\n", $matches[1]);
  82          
  83          // loop through each row
  84          foreach ($rows as $row) {
  85              
  86              // increase the row count
  87              $num_rows ++;
  88              
  89              // start a new row
  90              $return .= $this->wiki->addToken(
  91                  $this->rule,
  92                  array('type' => 'row_start')
  93              );
  94              
  95              // cells are separated by double-pipes
  96              $cell = explode("||", $row);
  97              
  98              // get the number of cells (columns) in this row
  99              $last = count($cell) - 1;
 100              
 101              // is this more than the current column count?
 102              // (we decrease by 1 because we never use cell zero)
 103              if ($last - 1 > $num_cols) {
 104                  // increase the column count
 105                  $num_cols = $last - 1;
 106              }
 107              
 108              // by default, cells span only one column (their own)
 109              $span = 1;
 110              
 111              // ignore cell zero, and ignore the "last" cell; cell zero
 112              // is before the first double-pipe, and the "last" cell is
 113              // after the last double-pipe. both are always empty.
 114              for ($i = 1; $i < $last; $i ++) {
 115                  
 116                  // if there is no content at all, then it's an instance
 117                  // of two sets of || next to each other, indicating a
 118                  // span.
 119                  if ($cell[$i] == '') {
 120                      
 121                      // add to the span and loop to the next cell
 122                      $span += 1;
 123                      continue;
 124                      
 125                  } else {
 126                      
 127                      // this cell has content.
 128                      
 129                      // find any special "attr"ibute cell markers
 130                      if (substr($cell[$i], 0, 2) == '> ') {
 131                          // right-align
 132                          $attr = 'right';
 133                          $cell[$i] = substr($cell[$i], 2);
 134                      } elseif (substr($cell[$i], 0, 2) == '= ') {
 135                          // center-align
 136                          $attr = 'center';
 137                          $cell[$i] = substr($cell[$i], 2);
 138                      } elseif (substr($cell[$i], 0, 2) == '< ') {
 139                          // left-align
 140                          $attr = 'left';
 141                          $cell[$i] = substr($cell[$i], 2);
 142                      } elseif (substr($cell[$i], 0, 2) == '~ ') {
 143                          $attr = 'header';
 144                          $cell[$i] = substr($cell[$i], 2);
 145                      } else {
 146                          $attr = null;
 147                      }
 148                      
 149                      // start a new cell...
 150                      $return .= $this->wiki->addToken(
 151                          $this->rule, 
 152                          array (
 153                              'type' => 'cell_start',
 154                              'attr' => $attr,
 155                              'span' => $span
 156                          )
 157                      );
 158                      
 159                      // ...add the content...
 160                      $return .= trim($cell[$i]);
 161                      
 162                      // ...and end the cell.
 163                      $return .= $this->wiki->addToken(
 164                          $this->rule, 
 165                          array (
 166                              'type' => 'cell_end',
 167                              'attr' => $attr,
 168                              'span' => $span
 169                          )
 170                      );
 171                      
 172                      // reset the span.
 173                      $span = 1;
 174                  }
 175                      
 176              }
 177              
 178              // end the row
 179              $return .= $this->wiki->addToken(
 180                  $this->rule,
 181                  array('type' => 'row_end')
 182              );
 183              
 184          }
 185          
 186          // wrap the return value in start and end tokens 
 187          $return =
 188              $this->wiki->addToken(
 189                  $this->rule,
 190                  array(
 191                      'type' => 'table_start',
 192                      'rows' => $num_rows,
 193                      'cols' => $num_cols
 194                  )
 195              )
 196              . $return .
 197              $this->wiki->addToken(
 198                  $this->rule,
 199                  array(
 200                      'type' => 'table_end'
 201                  )
 202              );
 203          
 204          // we're done!
 205          return "\n$return\n\n";
 206      }
 207  }
 208  ?>