Namespaces

Classes

Interfaces

Exceptions

Functions

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:
API documentation generated by ApiGen v7.0.0-alpha.6