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
325: