libs\TexyHtml.php

  1: <?php
  2: 
  3: /**
  4:  * Texy! - human-readable text to HTML converter.
  5:  *
  6:  * @copyright  Copyright (c) 2004, 2010 David Grudl
  7:  * @license    GNU GENERAL PUBLIC LICENSE version 2 or 3
  8:  * @link       http://texy.info
  9:  * @package    Texy
 10:  */
 11: 
 12: 
 13: 
 14: /**
 15:  * HTML helper.
 16:  *
 17:  * usage:
 18:  *       $anchor = TexyHtml::el('a')->href($link)->setText('Texy');
 19:  *       $el->class = 'myclass';
 20:  *
 21:  *       echo $el->startTag(), $el->endTag();
 22:  *
 23:  * @property   mixed element's attributes
 24:  * @copyright  Copyright (c) 2004, 2010 David Grudl
 25:  * @package    Texy
 26:  */
 27: class TexyHtml extends TexyObject implements ArrayAccess, /* Countable, */ IteratorAggregate
 28: {
 29:     /** @var string  element's name */
 30:     private $name;
 31: 
 32:     /** @var bool  is element empty? */
 33:     private $isEmpty;
 34: 
 35:     /** @var array  element's attributes */
 36:     public $attrs = array();
 37: 
 38:     /** @var array  of TexyHtml | string nodes */
 39:     protected $children = array();
 40: 
 41:     /** @var bool  use XHTML syntax? */
 42:     public static $xhtml = TRUE;
 43: 
 44:     /** @var array  empty elements */
 45:     public static $emptyElements = array('img'=>1,'hr'=>1,'br'=>1,'input'=>1,'meta'=>1,'area'=>1,
 46:         'base'=>1,'col'=>1,'link'=>1,'param'=>1,'basefont'=>1,'frame'=>1,'isindex'=>1,'wbr'=>1,'embed'=>1);
 47: 
 48:     /** @var array  %inline; elements; replaced elements + br have value '1' */
 49:     public static $inlineElements = array('ins'=>0,'del'=>0,'tt'=>0,'i'=>0,'b'=>0,'big'=>0,'small'=>0,'em'=>0,
 50:         'strong'=>0,'dfn'=>0,'code'=>0,'samp'=>0,'kbd'=>0,'var'=>0,'cite'=>0,'abbr'=>0,'acronym'=>0,
 51:         'sub'=>0,'sup'=>0,'q'=>0,'span'=>0,'bdo'=>0,'a'=>0,'object'=>1,'img'=>1,'br'=>1,'script'=>1,
 52:         'map'=>0,'input'=>1,'select'=>1,'textarea'=>1,'label'=>0,'button'=>1,
 53:         'u'=>0,'s'=>0,'strike'=>0,'font'=>0,'applet'=>1,'basefont'=>0, // transitional
 54:         'embed'=>1,'wbr'=>0,'nobr'=>0,'canvas'=>1, // proprietary
 55:     );
 56: 
 57:     /** @var array  elements with optional end tag in HTML */
 58:     public static $optionalEnds = array('body'=>1,'head'=>1,'html'=>1,'colgroup'=>1,'dd'=>1,
 59:         'dt'=>1,'li'=>1,'option'=>1,'p'=>1,'tbody'=>1,'td'=>1,'tfoot'=>1,'th'=>1,'thead'=>1,'tr'=>1);
 60: 
 61:     /** @see http://www.w3.org/TR/xhtml1/prohibitions.html */
 62:     public static $prohibits = array(
 63:         'a' => array('a','button'),
 64:         'img' => array('pre'),
 65:         'object' => array('pre'),
 66:         'big' => array('pre'),
 67:         'small' => array('pre'),
 68:         'sub' => array('pre'),
 69:         'sup' => array('pre'),
 70:         'input' => array('button'),
 71:         'select' => array('button'),
 72:         'textarea' => array('button'),
 73:         'label' => array('button', 'label'),
 74:         'button' => array('button'),
 75:         'form' => array('button', 'form'),
 76:         'fieldset' => array('button'),
 77:         'iframe' => array('button'),
 78:         'isindex' => array('button'),
 79:     );
 80: 
 81: 
 82: 
 83:     /**
 84:      * Static factory.
 85:      * @param  string element name (or NULL)
 86:      * @param  array|string element's attributes (or textual content)
 87:      * @return TexyHtml
 88:      */
 89:     public static function el($name = NULL, $attrs = NULL)
 90:     {
 91:         $el = new self;
 92:         $el->setName($name);
 93:         if (is_array($attrs)) {
 94:             $el->attrs = $attrs;
 95:         } elseif ($attrs !== NULL) {
 96:             $el->setText($attrs);
 97:         }
 98:         return $el;
 99:     }
100: 
101: 
102: 
103:     /**
104:      * Changes element's name.
105:      * @param  string
106:      * @param  bool  Is element empty?
107:      * @return TexyHtml  provides a fluent interface
108:      * @throws InvalidArgumentException
109:      */
110:     final public function setName($name, $empty = NULL)
111:     {
112:         if ($name !== NULL && !is_string($name)) {
113:             throw new InvalidArgumentException("Name must be string or NULL.");
114:         }
115: 
116:         $this->name = $name;
117:         $this->isEmpty = $empty === NULL ? isset(self::$emptyElements[$name]) : (bool) $empty;
118:         return $this;
119:     }
120: 
121: 
122: 
123:     /**
124:      * Returns element's name.
125:      * @return string
126:      */
127:     final public function getName()
128:     {
129:         return $this->name;
130:     }
131: 
132: 
133: 
134:     /**
135:      * Is element empty?
136:      * @return bool
137:      */
138:     final public function isEmpty()
139:     {
140:         return $this->isEmpty;
141:     }
142: 
143: 
144: 
145:     /**
146:      * Overloaded setter for element's attribute.
147:      * @param  string    property name
148:      * @param  mixed     property value
149:      * @return void
150:      */
151:     final public function __set($name, $value)
152:     {
153:         $this->attrs[$name] = $value;
154:     }
155: 
156: 
157: 
158:     /**
159:      * Overloaded getter for element's attribute.
160:      * @param  string    property name
161:      * @return mixed    property value
162:      */
163:     final public function &__get($name)
164:     {
165:         return $this->attrs[$name];
166:     }
167: 
168: 
169: 
170:     /**
171:      * Overloaded setter for element's attribute.
172:      * @param  string attribute name
173:      * @param  array value
174:      * @return TexyHtml  provides a fluent interface
175:      */
176: /*
177:     final public function __call($m, $args)
178:     {
179:         if (count($args) !== 1) {
180:             throw new InvalidArgumentException("Just one argument is required.");
181:         }
182:         $this->attrs[$m] = $args[0];
183:         return $this;
184:     }
185: */
186: 
187: 
188:     /**
189:      * Special setter for element's attribute.
190:      * @param  string path
191:      * @param  array query
192:      * @return TexyHtml  provides a fluent interface
193:      */
194:     final public function href($path, $query = NULL)
195:     {
196:         if ($query) {
197:             $query = http_build_query($query, NULL, '&');
198:             if ($query !== '') $path .= '?' . $query;
199:         }
200:         $this->attrs['href'] = $path;
201:         return $this;
202:     }
203: 
204: 
205: 
206:     /**
207:      * Sets element's textual content.
208:      * @param  string
209:      * @return TexyHtml  provides a fluent interface
210:      */
211:     final public function setText($text)
212:     {
213:         if (is_scalar($text)) {
214:             $this->removeChildren();
215:             $this->children = array($text);
216:         } elseif ($text !== NULL) {
217:             throw new InvalidArgumentException('Content must be scalar.');
218:         }
219:         return $this;
220:     }
221: 
222: 
223: 
224:     /**
225:      * Gets element's textual content.
226:      * @return string
227:      */
228:     final public function getText()
229:     {
230:         $s = '';
231:         foreach ($this->children as $child) {
232:             if (is_object($child)) return FALSE;
233:             $s .= $child;
234:         }
235:         return $s;
236:     }
237: 
238: 
239: 
240:     /**
241:      * Adds new element's child.
242:      * @param  TexyHtml|string child node
243:      * @return TexyHtml  provides a fluent interface
244:      */
245:     final public function add($child)
246:     {
247:         return $this->insert(NULL, $child);
248:     }
249: 
250: 
251: 
252:     /**
253:      * Creates and adds a new TexyHtml child.
254:      * @param  string  elements's name
255:      * @param  array|string element's attributes (or textual content)
256:      * @return TexyHtml  created element
257:      */
258:     final public function create($name, $attrs = NULL)
259:     {
260:         $this->insert(NULL, $child = self::el($name, $attrs));
261:         return $child;
262:     }
263: 
264: 
265: 
266:     /**
267:      * Inserts child node.
268:      * @param  int
269:      * @param  TexyHtml node
270:      * @param  bool
271:      * @return TexyHtml  provides a fluent interface
272:      * @throws Exception
273:      */
274:     public function insert($index, $child, $replace = FALSE)
275:     {
276:         if ($child instanceof TexyHtml || is_string($child)) {
277:             if ($index === NULL)  { // append
278:                 $this->children[] = $child;
279: 
280:             } else { // insert or replace
281:                 array_splice($this->children, (int) $index, $replace ? 1 : 0, array($child));
282:             }
283: 
284:         } else {
285:             throw new /*::*/InvalidArgumentException('Child node must be scalar or TexyHtml object.');
286:         }
287: 
288:         return $this;
289:     }
290: 
291: 
292: 
293:     /**
294:      * Inserts (replaces) child node (ArrayAccess implementation).
295:      * @param  int
296:      * @param  TexyHtml node
297:      * @return void
298:      */
299:     final public function offsetSet($index, $child)
300:     {
301:         $this->insert($index, $child, TRUE);
302:     }
303: 
304: 
305: 
306:     /**
307:      * Returns child node (ArrayAccess implementation).
308:      * @param  int index
309:      * @return mixed
310:      */
311:     final public function offsetGet($index)
312:     {
313:         return $this->children[$index];
314:     }
315: 
316: 
317: 
318:     /**
319:      * Exists child node? (ArrayAccess implementation).
320:      * @param  int index
321:      * @return bool
322:      */
323:     final public function offsetExists($index)
324:     {
325:         return isset($this->children[$index]);
326:     }
327: 
328: 
329: 
330:     /**
331:      * Removes child node (ArrayAccess implementation).
332:      * @param  int index
333:      * @return void
334:      */
335:     public function offsetUnset($index)
336:     {
337:         if (isset($this->children[$index])) {
338:             array_splice($this->children, (int) $index, 1);
339:         }
340:     }
341: 
342: 
343: 
344:     /**
345:      * Required by the Countable interface.
346:      * @return int
347:      */
348:     final public function count()
349:     {
350:         return count($this->children);
351:     }
352: 
353: 
354: 
355:     /**
356:      * Removed all children.
357:      * @return void
358:      */
359:     public function removeChildren()
360:     {
361:         $this->children = array();
362:     }
363: 
364: 
365: 
366:     /**
367:      * Required by the IteratorAggregate interface.
368:      * @return ArrayIterator
369:      */
370:     final public function getIterator()
371:     {
372:         return new ArrayIterator($this->children);
373:     }
374: 
375: 
376: 
377:     /**
378:      * Returns all of children.
379:      * return array
380:      */
381:     final public function getChildren()
382:     {
383:         return $this->children;
384:     }
385: 
386: 
387: 
388:     /**
389:      * Renders element's start tag, content and end tag to internal string representation.
390:      * @param  Texy
391:      * @return string
392:      */
393:     final public function toString(Texy $texy)
394:     {
395:         $ct = $this->getContentType();
396:         $s = $texy->protect($this->startTag(), $ct);
397: 
398:         // empty elements are finished now
399:         if ($this->isEmpty) {
400:             return $s;
401:         }
402: 
403:         // add content
404:         foreach ($this->children as $child) {
405:             if (is_object($child)) {
406:                 $s .= $child->toString($texy);
407:             } else {
408:                 $s .= $child;
409:             }
410:         }
411: 
412:         // add end tag
413:         return $s . $texy->protect($this->endTag(), $ct);
414:     }
415: 
416: 
417: 
418:     /**
419:      * Renders to final HTML.
420:      * @param  Texy
421:      * @return string
422:      */
423:     final public function toHtml(Texy $texy)
424:     {
425:         return $texy->stringToHtml($this->toString($texy));
426:     }
427: 
428: 
429: 
430:     /**
431:      * Renders to final text.
432:      * @param  Texy
433:      * @return string
434:      */
435:     final public function toText(Texy $texy)
436:     {
437:         return $texy->stringToText($this->toString($texy));
438:     }
439: 
440: 
441: 
442:     /**
443:      * Returns element's start tag.
444:      * @return string
445:      */
446:     public function startTag()
447:     {
448:         if (!$this->name) {
449:             return '';
450:         }
451: 
452:         $s = '<' . $this->name;
453: 
454:         if (is_array($this->attrs)) {
455:             foreach ($this->attrs as $key => $value)
456:             {
457:                 // skip NULLs and false boolean attributes
458:                 if ($value === NULL || $value === FALSE) continue;
459: 
460:                 // true boolean attribute
461:                 if ($value === TRUE) {
462:                     // in XHTML must use unminimized form
463:                     if (self::$xhtml) $s .= ' ' . $key . '="' . $key . '"';
464:                     // in HTML should use minimized form
465:                     else $s .= ' ' . $key;
466:                     continue;
467: 
468:                 } elseif (is_array($value)) {
469: 
470:                     // prepare into temporary array
471:                     $tmp = NULL;
472:                     foreach ($value as $k => $v) {
473:                         // skip NULLs & empty string; composite 'style' vs. 'others'
474:                         if ($v == NULL) continue;
475: 
476:                         if (is_string($k)) $tmp[] = $k . ':' . $v;
477:                         else $tmp[] = $v;
478:                     }
479: 
480:                     if (!$tmp) continue;
481:                     $value = implode($key === 'style' ? ';' : ' ', $tmp);
482: 
483:                 } else {
484:                     $value = (string) $value;
485:                 }
486: 
487:                 // add new attribute
488:                 $value = str_replace(array('&', '"', '<', '>', '@'), array('&amp;', '&quot;', '&lt;', '&gt;', '&#64;'), $value);
489:                 $s .= ' ' . $key . '="' . Texy::freezeSpaces($value) . '"';
490:             }
491:         }
492: 
493:         // finish start tag
494:         if (self::$xhtml && $this->isEmpty) {
495:             return $s . ' />';
496:         }
497:         return $s . '>';
498:     }
499: 
500: 
501: 
502:     /**
503:      * Returns element's end tag.
504:      * @return string
505:      */
506:     public function endTag()
507:     {
508:         if ($this->name && !$this->isEmpty) {
509:             return '</' . $this->name . '>';
510:         }
511:         return '';
512:     }
513: 
514: 
515: 
516:     /**
517:      * Clones all children too.
518:      */
519:     public function __clone()
520:     {
521:         foreach ($this->children as $key => $value) {
522:             if (is_object($value)) {
523:                 $this->children[$key] = clone $value;
524:             }
525:         }
526:     }
527: 
528: 
529: 
530:     /**
531:      * @return int
532:      */
533:     final public function getContentType()
534:     {
535:         if (!isset(self::$inlineElements[$this->name])) return Texy::CONTENT_BLOCK;
536: 
537:         return self::$inlineElements[$this->name] ? Texy::CONTENT_REPLACED : Texy::CONTENT_MARKUP;
538:     }
539: 
540: 
541: 
542:     /**
543:      * @param  array
544:      * @return void
545:      */
546:     final public function validateAttrs($dtd)
547:     {
548:         if (isset($dtd[$this->name])) {
549:             $allowed = $dtd[$this->name][0];
550:             if (is_array($allowed)) {
551:                 foreach ($this->attrs as $attr => $foo) {
552:                     if (!isset($allowed[$attr])) unset($this->attrs[$attr]);
553:                 }
554:             }
555:         }
556:     }
557: 
558: 
559: 
560:     public function validateChild($child, $dtd)
561:     {
562:         if (isset($dtd[$this->name])) {
563:             if ($child instanceof TexyHtml) $child = $child->name;
564:             return isset($dtd[$this->name][1][$child]);
565:         } else {
566:             return TRUE; // unknown element
567:         }
568:     }
569: 
570: 
571: 
572:     /**
573:      * Parses text as single line.
574:      * @param  Texy
575:      * @param  string
576:      * @return void
577:      */
578:     final public function parseLine(Texy $texy, $s)
579:     {
580:         // TODO!
581:         // special escape sequences
582:         $s = str_replace(array('\)', '\*'), array('&#x29;', '&#x2A;'), $s);
583: 
584:         $parser = new TexyLineParser($texy, $this);
585:         $parser->parse($s);
586:         return $parser;
587:     }
588: 
589: 
590: 
591:     /**
592:      * Parses text as block.
593:      * @param  Texy
594:      * @param  string
595:      * @param  bool
596:      * @return void
597:      */
598:     final public function parseBlock(Texy $texy, $s, $indented = FALSE)
599:     {
600:         $parser = new TexyBlockParser($texy, $this, $indented);
601:         $parser->parse($s);
602:     }
603: 
604: }
605:
Namespaces

Classes

Interfaces
