[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  class HTMLPurifier_Printer_HTMLDefinition extends HTMLPurifier_Printer
   4  {
   5  
   6      /**
   7       * @type HTMLPurifier_HTMLDefinition, for easy access
   8       */
   9      protected $def;
  10  
  11      /**
  12       * @param HTMLPurifier_Config $config
  13       * @return string
  14       */
  15      public function render($config)
  16      {
  17          $ret = '';
  18          $this->config =& $config;
  19  
  20          $this->def = $config->getHTMLDefinition();
  21  
  22          $ret .= $this->start('div', array('class' => 'HTMLPurifier_Printer'));
  23  
  24          $ret .= $this->renderDoctype();
  25          $ret .= $this->renderEnvironment();
  26          $ret .= $this->renderContentSets();
  27          $ret .= $this->renderInfo();
  28  
  29          $ret .= $this->end('div');
  30  
  31          return $ret;
  32      }
  33  
  34      /**
  35       * Renders the Doctype table
  36       * @return string
  37       */
  38      protected function renderDoctype()
  39      {
  40          $doctype = $this->def->doctype;
  41          $ret = '';
  42          $ret .= $this->start('table');
  43          $ret .= $this->element('caption', 'Doctype');
  44          $ret .= $this->row('Name', $doctype->name);
  45          $ret .= $this->row('XML', $doctype->xml ? 'Yes' : 'No');
  46          $ret .= $this->row('Default Modules', implode($doctype->modules, ', '));
  47          $ret .= $this->row('Default Tidy Modules', implode($doctype->tidyModules, ', '));
  48          $ret .= $this->end('table');
  49          return $ret;
  50      }
  51  
  52  
  53      /**
  54       * Renders environment table, which is miscellaneous info
  55       * @return string
  56       */
  57      protected function renderEnvironment()
  58      {
  59          $def = $this->def;
  60  
  61          $ret = '';
  62  
  63          $ret .= $this->start('table');
  64          $ret .= $this->element('caption', 'Environment');
  65  
  66          $ret .= $this->row('Parent of fragment', $def->info_parent);
  67          $ret .= $this->renderChildren($def->info_parent_def->child);
  68          $ret .= $this->row('Block wrap name', $def->info_block_wrapper);
  69  
  70          $ret .= $this->start('tr');
  71          $ret .= $this->element('th', 'Global attributes');
  72          $ret .= $this->element('td', $this->listifyAttr($def->info_global_attr), null, 0);
  73          $ret .= $this->end('tr');
  74  
  75          $ret .= $this->start('tr');
  76          $ret .= $this->element('th', 'Tag transforms');
  77          $list = array();
  78          foreach ($def->info_tag_transform as $old => $new) {
  79              $new = $this->getClass($new, 'TagTransform_');
  80              $list[] = "<$old> with $new";
  81          }
  82          $ret .= $this->element('td', $this->listify($list));
  83          $ret .= $this->end('tr');
  84  
  85          $ret .= $this->start('tr');
  86          $ret .= $this->element('th', 'Pre-AttrTransform');
  87          $ret .= $this->element('td', $this->listifyObjectList($def->info_attr_transform_pre));
  88          $ret .= $this->end('tr');
  89  
  90          $ret .= $this->start('tr');
  91          $ret .= $this->element('th', 'Post-AttrTransform');
  92          $ret .= $this->element('td', $this->listifyObjectList($def->info_attr_transform_post));
  93          $ret .= $this->end('tr');
  94  
  95          $ret .= $this->end('table');
  96          return $ret;
  97      }
  98  
  99      /**
 100       * Renders the Content Sets table
 101       * @return string
 102       */
 103      protected function renderContentSets()
 104      {
 105          $ret = '';
 106          $ret .= $this->start('table');
 107          $ret .= $this->element('caption', 'Content Sets');
 108          foreach ($this->def->info_content_sets as $name => $lookup) {
 109              $ret .= $this->heavyHeader($name);
 110              $ret .= $this->start('tr');
 111              $ret .= $this->element('td', $this->listifyTagLookup($lookup));
 112              $ret .= $this->end('tr');
 113          }
 114          $ret .= $this->end('table');
 115          return $ret;
 116      }
 117  
 118      /**
 119       * Renders the Elements ($info) table
 120       * @return string
 121       */
 122      protected function renderInfo()
 123      {
 124          $ret = '';
 125          $ret .= $this->start('table');
 126          $ret .= $this->element('caption', 'Elements ($info)');
 127          ksort($this->def->info);
 128          $ret .= $this->heavyHeader('Allowed tags', 2);
 129          $ret .= $this->start('tr');
 130          $ret .= $this->element('td', $this->listifyTagLookup($this->def->info), array('colspan' => 2));
 131          $ret .= $this->end('tr');
 132          foreach ($this->def->info as $name => $def) {
 133              $ret .= $this->start('tr');
 134              $ret .= $this->element('th', "<$name>", array('class' => 'heavy', 'colspan' => 2));
 135              $ret .= $this->end('tr');
 136              $ret .= $this->start('tr');
 137              $ret .= $this->element('th', 'Inline content');
 138              $ret .= $this->element('td', $def->descendants_are_inline ? 'Yes' : 'No');
 139              $ret .= $this->end('tr');
 140              if (!empty($def->excludes)) {
 141                  $ret .= $this->start('tr');
 142                  $ret .= $this->element('th', 'Excludes');
 143                  $ret .= $this->element('td', $this->listifyTagLookup($def->excludes));
 144                  $ret .= $this->end('tr');
 145              }
 146              if (!empty($def->attr_transform_pre)) {
 147                  $ret .= $this->start('tr');
 148                  $ret .= $this->element('th', 'Pre-AttrTransform');
 149                  $ret .= $this->element('td', $this->listifyObjectList($def->attr_transform_pre));
 150                  $ret .= $this->end('tr');
 151              }
 152              if (!empty($def->attr_transform_post)) {
 153                  $ret .= $this->start('tr');
 154                  $ret .= $this->element('th', 'Post-AttrTransform');
 155                  $ret .= $this->element('td', $this->listifyObjectList($def->attr_transform_post));
 156                  $ret .= $this->end('tr');
 157              }
 158              if (!empty($def->auto_close)) {
 159                  $ret .= $this->start('tr');
 160                  $ret .= $this->element('th', 'Auto closed by');
 161                  $ret .= $this->element('td', $this->listifyTagLookup($def->auto_close));
 162                  $ret .= $this->end('tr');
 163              }
 164              $ret .= $this->start('tr');
 165              $ret .= $this->element('th', 'Allowed attributes');
 166              $ret .= $this->element('td', $this->listifyAttr($def->attr), array(), 0);
 167              $ret .= $this->end('tr');
 168  
 169              if (!empty($def->required_attr)) {
 170                  $ret .= $this->row('Required attributes', $this->listify($def->required_attr));
 171              }
 172  
 173              $ret .= $this->renderChildren($def->child);
 174          }
 175          $ret .= $this->end('table');
 176          return $ret;
 177      }
 178  
 179      /**
 180       * Renders a row describing the allowed children of an element
 181       * @param HTMLPurifier_ChildDef $def HTMLPurifier_ChildDef of pertinent element
 182       * @return string
 183       */
 184      protected function renderChildren($def)
 185      {
 186          $context = new HTMLPurifier_Context();
 187          $ret = '';
 188          $ret .= $this->start('tr');
 189          $elements = array();
 190          $attr = array();
 191          if (isset($def->elements)) {
 192              if ($def->type == 'strictblockquote') {
 193                  $def->validateChildren(array(), $this->config, $context);
 194              }
 195              $elements = $def->elements;
 196          }
 197          if ($def->type == 'chameleon') {
 198              $attr['rowspan'] = 2;
 199          } elseif ($def->type == 'empty') {
 200              $elements = array();
 201          } elseif ($def->type == 'table') {
 202              $elements = array_flip(
 203                  array(
 204                      'col',
 205                      'caption',
 206                      'colgroup',
 207                      'thead',
 208                      'tfoot',
 209                      'tbody',
 210                      'tr'
 211                  )
 212              );
 213          }
 214          $ret .= $this->element('th', 'Allowed children', $attr);
 215  
 216          if ($def->type == 'chameleon') {
 217  
 218              $ret .= $this->element(
 219                  'td',
 220                  '<em>Block</em>: ' .
 221                  $this->escape($this->listifyTagLookup($def->block->elements)),
 222                  null,
 223                  0
 224              );
 225              $ret .= $this->end('tr');
 226              $ret .= $this->start('tr');
 227              $ret .= $this->element(
 228                  'td',
 229                  '<em>Inline</em>: ' .
 230                  $this->escape($this->listifyTagLookup($def->inline->elements)),
 231                  null,
 232                  0
 233              );
 234  
 235          } elseif ($def->type == 'custom') {
 236  
 237              $ret .= $this->element(
 238                  'td',
 239                  '<em>' . ucfirst($def->type) . '</em>: ' .
 240                  $def->dtd_regex
 241              );
 242  
 243          } else {
 244              $ret .= $this->element(
 245                  'td',
 246                  '<em>' . ucfirst($def->type) . '</em>: ' .
 247                  $this->escape($this->listifyTagLookup($elements)),
 248                  null,
 249                  0
 250              );
 251          }
 252          $ret .= $this->end('tr');
 253          return $ret;
 254      }
 255  
 256      /**
 257       * Listifies a tag lookup table.
 258       * @param array $array Tag lookup array in form of array('tagname' => true)
 259       * @return string
 260       */
 261      protected function listifyTagLookup($array)
 262      {
 263          ksort($array);
 264          $list = array();
 265          foreach ($array as $name => $discard) {
 266              if ($name !== '#PCDATA' && !isset($this->def->info[$name])) {
 267                  continue;
 268              }
 269              $list[] = $name;
 270          }
 271          return $this->listify($list);
 272      }
 273  
 274      /**
 275       * Listifies a list of objects by retrieving class names and internal state
 276       * @param array $array List of objects
 277       * @return string
 278       * @todo Also add information about internal state
 279       */
 280      protected function listifyObjectList($array)
 281      {
 282          ksort($array);
 283          $list = array();
 284          foreach ($array as $obj) {
 285              $list[] = $this->getClass($obj, 'AttrTransform_');
 286          }
 287          return $this->listify($list);
 288      }
 289  
 290      /**
 291       * Listifies a hash of attributes to AttrDef classes
 292       * @param array $array Array hash in form of array('attrname' => HTMLPurifier_AttrDef)
 293       * @return string
 294       */
 295      protected function listifyAttr($array)
 296      {
 297          ksort($array);
 298          $list = array();
 299          foreach ($array as $name => $obj) {
 300              if ($obj === false) {
 301                  continue;
 302              }
 303              $list[] = "$name&nbsp;=&nbsp;<i>" . $this->getClass($obj, 'AttrDef_') . '</i>';
 304          }
 305          return $this->listify($list);
 306      }
 307  
 308      /**
 309       * Creates a heavy header row
 310       * @param string $text
 311       * @param int $num
 312       * @return string
 313       */
 314      protected function heavyHeader($text, $num = 1)
 315      {
 316          $ret = '';
 317          $ret .= $this->start('tr');
 318          $ret .= $this->element('th', $text, array('colspan' => $num, 'class' => 'heavy'));
 319          $ret .= $this->end('tr');
 320          return $ret;
 321      }
 322  }
 323  
 324  // vim: et sw=4 sts=4