texy.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: define('TEXY_VERSION',  '2.1');
 14: 
 15: 
 16: /**
 17:  * Check PHP configuration.
 18:  */
 19: if (extension_loaded('mbstring')) {
 20:     if (mb_get_info('func_overload') & 2 && substr(mb_get_info('internal_encoding'), 0, 1) === 'U') { // U??
 21:         mb_internal_encoding('pass');
 22:         trigger_error("Texy: mb_internal_encoding changed to 'pass'", E_USER_WARNING);
 23:     }
 24: }
 25: 
 26: if (ini_get('zend.ze1_compatibility_mode') % 256 ||
 27:     preg_match('#on$|true$|yes$#iA', ini_get('zend.ze1_compatibility_mode'))) {
 28:     throw new RuntimeException("Texy cannot run with zend.ze1_compatibility_mode enabled.");
 29: }
 30: 
 31: 
 32: // Texy! libraries
 33: require_once dirname(__FILE__) . '/libs/RegExp.Patterns.php';
 34: require_once dirname(__FILE__) . '/libs/TexyObject.php';
 35: require_once dirname(__FILE__) . '/libs/TexyHtml.php';
 36: require_once dirname(__FILE__) . '/libs/TexyModifier.php';
 37: require_once dirname(__FILE__) . '/libs/TexyModule.php';
 38: require_once dirname(__FILE__) . '/libs/TexyParser.php';
 39: require_once dirname(__FILE__) . '/libs/TexyUtf.php';
 40: require_once dirname(__FILE__) . '/libs/TexyConfigurator.php';
 41: require_once dirname(__FILE__) . '/libs/TexyHandlerInvocation.php';
 42: require_once dirname(__FILE__) . '/modules/TexyParagraphModule.php';
 43: require_once dirname(__FILE__) . '/modules/TexyBlockModule.php';
 44: require_once dirname(__FILE__) . '/modules/TexyHeadingModule.php';
 45: require_once dirname(__FILE__) . '/modules/TexyHorizLineModule.php';
 46: require_once dirname(__FILE__) . '/modules/TexyHtmlModule.php';
 47: require_once dirname(__FILE__) . '/modules/TexyFigureModule.php';
 48: require_once dirname(__FILE__) . '/modules/TexyImageModule.php';
 49: require_once dirname(__FILE__) . '/modules/TexyLinkModule.php';
 50: require_once dirname(__FILE__) . '/modules/TexyListModule.php';
 51: require_once dirname(__FILE__) . '/modules/TexyLongWordsModule.php';
 52: require_once dirname(__FILE__) . '/modules/TexyPhraseModule.php';
 53: require_once dirname(__FILE__) . '/modules/TexyBlockQuoteModule.php';
 54: require_once dirname(__FILE__) . '/modules/TexyScriptModule.php';
 55: require_once dirname(__FILE__) . '/modules/TexyEmoticonModule.php';
 56: require_once dirname(__FILE__) . '/modules/TexyTableModule.php';
 57: require_once dirname(__FILE__) . '/modules/TexyTypographyModule.php';
 58: require_once dirname(__FILE__) . '/modules/TexyHtmlOutputModule.php';
 59: 
 60: 
 61: 
 62: /**
 63:  * Compatibility with PHP < 5.1.
 64:  */
 65: if (!class_exists('LogicException', FALSE)) {
 66:     class LogicException extends Exception {}
 67: }
 68: 
 69: if (!class_exists('InvalidArgumentException', FALSE)) {
 70:     class InvalidArgumentException extends LogicException {}
 71: }
 72: 
 73: if (!class_exists('RuntimeException', FALSE)) {
 74:     class RuntimeException extends Exception {}
 75: }
 76: 
 77: if (!class_exists('UnexpectedValueException', FALSE)) {
 78:     class UnexpectedValueException extends RuntimeException {}
 79: }
 80: 
 81: 
 82: 
 83: /**
 84:  * Compatibility with Nette
 85:  */
 86: if (!class_exists('NotSupportedException', FALSE)) {
 87:     class NotSupportedException extends LogicException {}
 88: }
 89: 
 90: if (!class_exists('MemberAccessException', FALSE)) {
 91:     class MemberAccessException extends LogicException {}
 92: }
 93: 
 94: if (!class_exists('InvalidStateException', FALSE)) {
 95:     class InvalidStateException extends RuntimeException {}
 96: }
 97: 
 98: 
 99: 
100: /**
101:  * For Texy 1 backward compatibility.
102:  */
103: define('TEXY_ALL',  TRUE);
104: define('TEXY_NONE',  FALSE);
105: define('TEXY_CONTENT_MARKUP',  "\x17");
106: define('TEXY_CONTENT_REPLACED',  "\x16");
107: define('TEXY_CONTENT_TEXTUAL',  "\x15");
108: define('TEXY_CONTENT_BLOCK',  "\x14");
109: 
110: 
111: 
112: 
113: /**
114:  * Texy! - Convert plain text to XHTML format using {@link process()}.
115:  *
116:  * <code>
117:  *     $texy = new Texy();
118:  *     $html = $texy->process($text);
119:  * </code>
120:  *
121:  * @copyright  Copyright (c) 2004, 2010 David Grudl
122:  * @package    Texy
123:  */
124: class Texy extends TexyObject
125: {
126:     // configuration directives
127:     const ALL = TRUE;
128:     const NONE = FALSE;
129: 
130:     // Texy version
131:     const VERSION = TEXY_VERSION;
132:     const REVISION = '9338a11 released on 2010-05-20';
133: 
134:     // types of protection marks
135:     const CONTENT_MARKUP = "\x17";
136:     const CONTENT_REPLACED = "\x16";
137:     const CONTENT_TEXTUAL = "\x15";
138:     const CONTENT_BLOCK = "\x14";
139: 
140:     // url filters
141:     const FILTER_ANCHOR = 'anchor';
142:     const FILTER_IMAGE = 'image';
143: 
144:     // HTML minor-modes
145:     const XML = 2;
146: 
147:     // HTML modes
148:     const HTML4_TRANSITIONAL = 0;
149:     const HTML4_STRICT = 1;
150:     const HTML5 = 4;
151:     const XHTML1_TRANSITIONAL = 2; // Texy::HTML4_TRANSITIONAL | Texy::XML;
152:     const XHTML1_STRICT = 3; // Texy::HTML4_STRICT | Texy::XML;
153:     const XHTML5 = 6; // Texy::HTML5 | Texy::XML;
154: 
155:     /** @var string  input & output text encoding */
156:     public $encoding = 'utf-8';
157: 
158:     /** @var array  Texy! syntax configuration */
159:     public $allowed = array();
160: 
161:     /** @var TRUE|FALSE|array  Allowed HTML tags */
162:     public $allowedTags;
163: 
164:     /** @var TRUE|FALSE|array  Allowed classes */
165:     public $allowedClasses = Texy::ALL; // all classes and id are allowed
166: 
167:     /** @var TRUE|FALSE|array  Allowed inline CSS style */
168:     public $allowedStyles = Texy::ALL;  // all inline styles are allowed
169: 
170:     /** @var int  TAB width (for converting tabs to spaces) */
171:     public $tabWidth = 8;
172: 
173:     /** @var boolean  Do obfuscate e-mail addresses? */
174:     public $obfuscateEmail = TRUE;
175: 
176:     /** @var array  regexps to check URL schemes */
177:     public $urlSchemeFilters = NULL; // disable URL scheme filter
178: 
179:     /** @var bool  Paragraph merging mode */
180:     public $mergeLines = TRUE;
181: 
182:     /** @var array  Parsing summary */
183:     public $summary = array(
184:         'images' => array(),
185:         'links' => array(),
186:         'preload' => array(),
187:     );
188: 
189:     /** @var string  Generated stylesheet */
190:     public $styleSheet = '';
191: 
192:     /** @var array  CSS classes for align modifiers */
193:     public $alignClasses = array(
194:         'left' => NULL,
195:         'right' => NULL,
196:         'center' => NULL,
197:         'justify' => NULL,
198:         'top' => NULL,
199:         'middle' => NULL,
200:         'bottom' => NULL,
201:     );
202: 
203:     /** @var bool  remove soft hyphens (SHY)? */
204:     public $removeSoftHyphens = TRUE;
205: 
206:     /** @var mixed */
207:     public static $advertisingNotice = 'once';
208: 
209:     /** @var string */
210:     public $nontextParagraph = 'div';
211: 
212:     /** @var TexyScriptModule */
213:     public $scriptModule;
214: 
215:     /** @var TexyParagraphModule */
216:     public $paragraphModule;
217: 
218:     /** @var TexyHtmlModule */
219:     public $htmlModule;
220: 
221:     /** @var TexyImageModule */
222:     public $imageModule;
223: 
224:     /** @var TexyLinkModule */
225:     public $linkModule;
226: 
227:     /** @var TexyPhraseModule */
228:     public $phraseModule;
229: 
230:     /** @var TexyEmoticonModule */
231:     public $emoticonModule;
232: 
233:     /** @var TexyBlockModule */
234:     public $blockModule;
235: 
236:     /** @var TexyHeadingModule */
237:     public $headingModule;
238: 
239:     /** @var TexyHorizLineModule */
240:     public $horizLineModule;
241: 
242:     /** @var TexyBlockQuoteModule */
243:     public $blockQuoteModule;
244: 
245:     /** @var TexyListModule */
246:     public $listModule;
247: 
248:     /** @var TexyTableModule */
249:     public $tableModule;
250: 
251:     /** @var TexyFigureModule */
252:     public $figureModule;
253: 
254:     /** @var TexyTypographyModule */
255:     public $typographyModule;
256: 
257:     /** @var TexyLongWordsModule */
258:     public $longWordsModule;
259: 
260:     /** @var TexyHtmlOutputModule */
261:     public $htmlOutputModule;
262: 
263: 
264:     /**
265:      * Registered regexps and associated handlers for inline parsing.
266:      * @var array of ('handler' => callback
267:      *                'pattern' => regular expression)
268:      */
269:     private $linePatterns = array();
270:     private $_linePatterns;
271: 
272:     /**
273:      * Registered regexps and associated handlers for block parsing.
274:      * @var array of ('handler' => callback
275:      *                'pattern' => regular expression)
276:      */
277:     private $blockPatterns = array();
278:     private $_blockPatterns;
279: 
280:     /** @var array */
281:     private $postHandlers = array();
282: 
283:     /** @var TexyHtml  DOM structure for parsed text */
284:     private $DOM;
285: 
286:     /** @var array  Texy protect markup table */
287:     private $marks = array();
288: 
289:     /** @var array  for internal usage */
290:     public $_classes, $_styles;
291: 
292:     /** @var bool */
293:     private $processing;
294: 
295:     /** @var array of events and registered handlers */
296:     private $handlers = array();
297: 
298:     /**
299:      * DTD descriptor.
300:      *   $dtd[element][0] - allowed attributes (as array keys)
301:      *   $dtd[element][1] - allowed content for an element (content model) (as array keys)
302:      *                    - array of allowed elements (as keys)
303:      *                    - FALSE - empty element
304:      *                    - 0 - special case for ins & del
305:      * @var array
306:      */
307:     public $dtd;
308: 
309:     /** @var array */
310:     private static $dtdCache;
311: 
312:     /** @var int  HTML mode */
313:     private $mode;
314: 
315: 
316:     /** DEPRECATED */
317:     public static $strictDTD;
318:     public $cleaner;
319:     public $xhtml;
320: 
321: 
322: 
323:     public function __construct()
324:     {
325:         // load all modules
326:         $this->loadModules();
327: 
328:         // DEPRECATED
329:         if (self::$strictDTD !== NULL) {
330:             $this->setOutputMode(self::$strictDTD ? self::XHTML1_STRICT : self::XHTML1_TRANSITIONAL);
331:         } else {
332:             $this->setOutputMode(self::XHTML1_TRANSITIONAL);
333:         }
334: 
335:         // DEPRECATED
336:         $this->cleaner = & $this->htmlOutputModule;
337: 
338:         // examples of link references ;-)
339:         $link = new TexyLink('http://texy.info/');
340:         $link->modifier->title = 'The best text -> HTML converter and formatter';
341:         $link->label = 'Texy!';
342:         $this->linkModule->addReference('texy', $link);
343: 
344:         $link = new TexyLink('http://www.google.com/search?q=%s');
345:         $this->linkModule->addReference('google', $link);
346: 
347:         $link = new TexyLink('http://en.wikipedia.org/wiki/Special:Search?search=%s');
348:         $this->linkModule->addReference('wikipedia', $link);
349:     }
350: 
351: 
352: 
353:     /**
354:      * Set HTML/XHTML output mode (overwrites self::$allowedTags)
355:      * @param  int
356:      * @return void
357:      */
358:     public function setOutputMode($mode)
359:     {
360:         if (!in_array($mode, array(self::HTML4_TRANSITIONAL, self::HTML4_STRICT,
361:             self::HTML5, self::XHTML1_TRANSITIONAL, self::XHTML1_STRICT, self::XHTML5), TRUE)) {
362:             throw new InvalidArgumentException("Invalid mode.");
363:         }
364: 
365:         if (!isset(self::$dtdCache[$mode])) {
366:             require dirname(__FILE__) . '/libs/DTD.php';
367:             self::$dtdCache[$mode] = $dtd;
368:         }
369: 
370:         $this->mode = $mode;
371:         $this->dtd = self::$dtdCache[$mode];
372:         TexyHtml::$xhtml = (bool) ($mode & self::XML); // TODO: remove?
373: 
374:         // accept all valid HTML tags and attributes by default
375:         $this->allowedTags = array();
376:         foreach ($this->dtd as $tag => $dtd) {
377:             $this->allowedTags[$tag] = self::ALL;
378:         }
379:     }
380: 
381: 
382: 
383:     /**
384:      * Get HTML/XHTML output mode
385:      * @return int
386:      */
387:     public function getOutputMode()
388:     {
389:         return $this->mode;
390:     }
391: 
392: 
393: 
394:     /**
395:      * Create array of all used modules ($this->modules).
396:      * This array can be changed by overriding this method (by subclasses)
397:      */
398:     protected function loadModules()
399:     {
400:         // line parsing
401:         $this->scriptModule = new TexyScriptModule($this);
402:         $this->htmlModule = new TexyHtmlModule($this);
403:         $this->imageModule = new TexyImageModule($this);
404:         $this->phraseModule = new TexyPhraseModule($this);
405:         $this->linkModule = new TexyLinkModule($this);
406:         $this->emoticonModule = new TexyEmoticonModule($this);
407: 
408:         // block parsing
409:         $this->paragraphModule = new TexyParagraphModule($this);
410:         $this->blockModule = new TexyBlockModule($this);
411:         $this->figureModule = new TexyFigureModule($this);
412:         $this->horizLineModule = new TexyHorizLineModule($this);
413:         $this->blockQuoteModule = new TexyBlockQuoteModule($this);
414:         $this->tableModule = new TexyTableModule($this);
415:         $this->headingModule = new TexyHeadingModule($this);
416:         $this->listModule = new TexyListModule($this);
417: 
418:         // post process
419:         $this->typographyModule = new TexyTypographyModule($this);
420:         $this->longWordsModule = new TexyLongWordsModule($this);
421:         $this->htmlOutputModule = new TexyHtmlOutputModule($this);
422:     }
423: 
424: 
425: 
426:     final public function registerLinePattern($handler, $pattern, $name, $againTest = NULL)
427:     {
428:         if (!is_callable($handler)) {
429:             $able = is_callable($handler, TRUE, $textual);
430:             throw new InvalidArgumentException("Handler '$textual' is not " . ($able ? 'callable.' : 'valid PHP callback.'));
431:         }
432: 
433:         if (!isset($this->allowed[$name])) $this->allowed[$name] = TRUE;
434: 
435:         $this->linePatterns[$name] = array(
436:             'handler'     => $handler,
437:             'pattern'     => $pattern,
438:             'again'       => $againTest,
439:         );
440:     }
441: 
442: 
443: 
444:     final public function registerBlockPattern($handler, $pattern, $name)
445:     {
446:         if (!is_callable($handler)) {
447:             $able = is_callable($handler, TRUE, $textual);
448:             throw new InvalidArgumentException("Handler '$textual' is not " . ($able ? 'callable.' : 'valid PHP callback.'));
449:         }
450: 
451:         // if (!preg_match('#(.)\^.*\$\\1[a-z]*#is', $pattern)) die("Texy: Not a block pattern $name");
452:         if (!isset($this->allowed[$name])) $this->allowed[$name] = TRUE;
453: 
454:         $this->blockPatterns[$name] = array(
455:             'handler'     => $handler,
456:             'pattern'     => $pattern  . 'm',  // force multiline
457:         );
458:     }
459: 
460: 
461: 
462:     final public function registerPostLine($handler, $name)
463:     {
464:         if (!is_callable($handler)) {
465:             $able = is_callable($handler, TRUE, $textual);
466:             throw new InvalidArgumentException("Handler '$textual' is not " . ($able ? 'callable.' : 'valid PHP callback.'));
467:         }
468: 
469:         if (!isset($this->allowed[$name])) $this->allowed[$name] = TRUE;
470: 
471:         $this->postHandlers[$name] = $handler;
472:     }
473: 
474: 
475: 
476:     /**
477:      * Converts document in Texy! to (X)HTML code.
478:      *
479:      * @param  string   input text
480:      * @param  bool     is single line?
481:      * @return string   output HTML code
482:      */
483:     public function process($text, $singleLine = FALSE)
484:     {
485:         if ($this->processing) {
486:             throw new InvalidStateException('Processing is in progress yet.');
487:         }
488: 
489:         // initialization
490:         $this->marks = array();
491:         $this->processing = TRUE;
492: 
493:         // speed-up
494:         if (is_array($this->allowedClasses)) $this->_classes = array_flip($this->allowedClasses);
495:         else $this->_classes = $this->allowedClasses;
496: 
497:         if (is_array($this->allowedStyles)) $this->_styles = array_flip($this->allowedStyles);
498:         else $this->_styles = $this->allowedStyles;
499: 
500:         // convert to UTF-8 (and check source encoding)
501:         $text = TexyUtf::toUtf($text, $this->encoding);
502: 
503:         if ($this->removeSoftHyphens) {
504:             $text = str_replace("\xC2\xAD", '', $text);
505:         }
506: 
507:         // standardize line endings and spaces
508:         $text = self::normalize($text);
509: 
510:         // replace tabs with spaces
511:         $this->tabWidth = max(1, (int) $this->tabWidth);
512:         while (strpos($text, "\t") !== FALSE) {
513:             $text = preg_replace_callback('#^(.*)\t#mU', array($this, 'tabCb'), $text);
514:         }
515: 
516:         // user before handler
517:         $this->invokeHandlers('beforeParse', array($this, & $text, $singleLine));
518: 
519:         // select patterns
520:         $this->_linePatterns = $this->linePatterns;
521:         $this->_blockPatterns = $this->blockPatterns;
522:         foreach ($this->_linePatterns as $name => $foo) {
523:             if (empty($this->allowed[$name])) unset($this->_linePatterns[$name]);
524:         }
525:         foreach ($this->_blockPatterns as $name => $foo) {
526:             if (empty($this->allowed[$name])) unset($this->_blockPatterns[$name]);
527:         }
528: 
529:         // parse Texy! document into internal DOM structure
530:         $this->DOM = TexyHtml::el();
531:         if ($singleLine) {
532:             $this->DOM->parseLine($this, $text);
533:         } else {
534:             $this->DOM->parseBlock($this, $text);
535:         }
536: 
537:         // user after handler
538:         $this->invokeHandlers('afterParse', array($this, $this->DOM, $singleLine));
539: 
540:         // converts internal DOM structure to final HTML code
541:         $html = $this->DOM->toHtml($this);
542: 
543:         // this notice should remain
544:         if (self::$advertisingNotice) {
545:             $html .= "\n<!-- by Texy2! -->";
546:             if (self::$advertisingNotice === 'once') {
547:                 self::$advertisingNotice = FALSE;
548:             }
549:         }
550: 
551:         $this->processing = FALSE;
552: 
553:         return TexyUtf::utf2html($html, $this->encoding);
554:     }
555: 
556: 
557: 
558:     /**
559:      * Converts single line in Texy! to (X)HTML code.
560:      *
561:      * @param  string   input text
562:      * @return string   output HTML code
563:      */
564:     public function processLine($text)
565:     {
566:         return $this->process($text, TRUE);
567:     }
568: 
569: 
570: 
571:     /**
572:      * Makes only typographic corrections.
573:      * @param  string   input text (in encoding defined by Texy::$encoding)
574:      * @return string   output text (in UTF-8)
575:      */
576:     public function processTypo($text)
577:     {
578:         // convert to UTF-8 (and check source encoding)
579:         $text = TexyUtf::toUtf($text, $this->encoding);
580: 
581:         // standardize line endings and spaces
582:         $text = self::normalize($text);
583: 
584:         $this->typographyModule->beforeParse($this, $text);
585:         $text = $this->typographyModule->postLine($text, TRUE);
586: 
587:         if (!empty($this->allowed['longwords'])) {
588:             $text = $this->longWordsModule->postLine($text);
589:         }
590: 
591:         return TexyUtf::utf2html($text, $this->encoding);
592:     }
593: 
594: 
595: 
596:     /**
597:      * Converts DOM structure to pure text.
598:      * @return string
599:      */
600:     public function toText()
601:     {
602:         if (!$this->DOM) {
603:             throw new InvalidStateException('Call $texy->process() first.');
604:         }
605: 
606:         return TexyUtf::utfTo($this->DOM->toText($this), $this->encoding);
607:     }
608: 
609: 
610: 
611:     /**
612:      * Converts internal string representation to final HTML code in UTF-8.
613:      * @return string
614:      */
615:     final public function stringToHtml($s)
616:     {
617:         // decode HTML entities to UTF-8
618:         $s = self::unescapeHtml($s);
619: 
620:         // line-postprocessing
621:         $blocks = explode(self::CONTENT_BLOCK, $s);
622:         foreach ($this->postHandlers as $name => $handler) {
623:             if (empty($this->allowed[$name])) continue;
624:             foreach ($blocks as $n => $s) {
625:                 if ($n % 2 === 0 && $s !== '') {
626:                     $blocks[$n] = call_user_func($handler, $s);
627:                 }
628:             }
629:         }
630:         $s = implode(self::CONTENT_BLOCK, $blocks);
631: 
632:         // encode < > &
633:         $s = self::escapeHtml($s);
634: 
635:         // replace protected marks
636:         $s = $this->unProtect($s);
637: 
638:         // wellform and reformat HTML
639:         $this->invokeHandlers('postProcess', array($this, & $s));
640: 
641:         // unfreeze spaces
642:         $s = self::unfreezeSpaces($s);
643: 
644:         return $s;
645:     }
646: 
647: 
648: 
649:     /**
650:      * Converts internal string representation to final HTML code in UTF-8.
651:      * @return string
652:      */
653:     final public function stringToText($s)
654:     {
655:         $save = $this->htmlOutputModule->lineWrap;
656:         $this->htmlOutputModule->lineWrap = FALSE;
657:         $s = $this->stringToHtml( $s );
658:         $this->htmlOutputModule->lineWrap = $save;
659: 
660:         // remove tags
661:         $s = preg_replace('#<(script|style)(.*)</\\1>#Uis', '', $s);
662:         $s = strip_tags($s);
663:         $s = preg_replace('#\n\s*\n\s*\n[\n\s]*\n#', "\n\n", $s);
664: 
665:         // entities -> chars
666:         $s = self::unescapeHtml($s);
667: 
668:         // convert nbsp to normal space and remove shy
669:         $s = strtr($s, array(
670:             "\xC2\xAD" => '',  // shy
671:             "\xC2\xA0" => ' ', // nbsp
672:         ));
673: 
674:         return $s;
675:     }
676: 
677: 
678: 
679:     /**
680:      * Add new event handler.
681:      *
682:      * @param  string   event name
683:      * @param  callback
684:      * @return void
685:      */
686:     final public function addHandler($event, $callback)
687:     {
688:         if (!is_callable($callback)) {
689:             $able = is_callable($callback, TRUE, $textual);
690:             throw new InvalidArgumentException("Handler '$textual' is not " . ($able ? 'callable.' : 'valid PHP callback.'));
691:         }
692: 
693:         $this->handlers[$event][] = $callback;
694:     }
695: 
696: 
697: 
698:     /**
699:      * Invoke registered around-handlers.
700:      *
701:      * @param  string   event name
702:      * @param  TexyParser  actual parser object
703:      * @param  array    arguments passed into handler
704:      * @return mixed
705:      */
706:     final public function invokeAroundHandlers($event, $parser, $args)
707:     {
708:         if (!isset($this->handlers[$event])) return FALSE;
709: 
710:         $invocation = new TexyHandlerInvocation($this->handlers[$event], $parser, $args);
711:         $res = $invocation->proceed();
712:         $invocation->free();
713:         return $res;
714:     }
715: 
716: 
717: 
718:     /**
719:      * Invoke registered after-handlers.
720:      *
721:      * @param  string   event name
722:      * @param  array    arguments passed into handler
723:      * @return void
724:      */
725:     final public function invokeHandlers($event, $args)
726:     {
727:         if (!isset($this->handlers[$event])) return;
728: 
729:         foreach ($this->handlers[$event] as $handler) {
730:             call_user_func_array($handler, $args);
731:         }
732:     }
733: 
734: 
735: 
736:     /**
737:      * Translate all white spaces (\t \n \r space) to meta-spaces \x01-\x04.
738:      * which are ignored by TexyHtmlOutputModule routine
739:      * @param  string
740:      * @return string
741:      */
742:     final public static function freezeSpaces($s)
743:     {
744:         return strtr($s, " \t\r\n", "\x01\x02\x03\x04");
745:     }
746: 
747: 
748: 
749:     /**
750:      * Reverts meta-spaces back to normal spaces.
751:      * @param  string
752:      * @return string
753:      */
754:     final public static function unfreezeSpaces($s)
755:     {
756:         return strtr($s, "\x01\x02\x03\x04", " \t\r\n");
757:     }
758: 
759: 
760: 
761:     /**
762:      * Removes special controls characters and normalizes line endings and spaces.
763:      * @param  string
764:      * @return string
765:      */
766:     final public static function normalize($s)
767:     {
768:         // standardize line endings to unix-like
769:         $s = str_replace("\r\n", "\n", $s); // DOS
770:         $s = strtr($s, "\r", "\n"); // Mac
771: 
772:         // remove special chars; leave \t + \n
773:         $s = preg_replace('#[\x00-\x08\x0B-\x1F]+#', '', $s);
774: 
775:         // right trim
776:         $s = preg_replace("#[\t ]+$#m", '', $s);
777: 
778:         // trailing spaces
779:         $s = trim($s, "\n");
780: 
781:         return $s;
782:     }
783: 
784: 
785: 
786:     /**
787:      * Converts to web safe characters [a-z0-9-] text.
788:      * @param  string
789:      * @param  string
790:      * @return string
791:      */
792:     final public static function webalize($s, $charlist = NULL)
793:     {
794:         $s = TexyUtf::utf2ascii($s);
795:         $s = strtolower($s);
796:         $s = preg_replace('#[^a-z0-9'.preg_quote($charlist, '#').']+#', '-', $s);
797:         $s = trim($s, '-');
798:         return $s;
799:     }
800: 
801: 
802: 
803:     /**
804:      * Texy! version of htmlSpecialChars (much faster than htmlSpecialChars!).
805:      * note: &quot; is not encoded!
806:      * @param  string
807:      * @return string
808:      */
809:     final public static function escapeHtml($s)
810:     {
811:         return str_replace(array('&', '<', '>'), array('&amp;', '&lt;', '&gt;'), $s);
812:     }
813: 
814: 
815: 
816:     /**
817:      * Texy! version of html_entity_decode (always UTF-8, much faster than original!).
818:      * @param  string
819:      * @return string
820:      */
821:     final public static function unescapeHtml($s)
822:     {
823:         if (strpos($s, '&') === FALSE) return $s;
824:         return html_entity_decode($s, ENT_QUOTES, 'UTF-8');
825:     }
826: 
827: 
828: 
829:     /**
830:      * Outdents text block.
831:      * @param  string
832:      * @return string
833:      */
834:     final public static function outdent($s)
835:     {
836:         $s = trim($s, "\n");
837:         $spaces = strspn($s, ' ');
838:         if ($spaces) return preg_replace("#^ {1,$spaces}#m", '', $s);
839:         return $s;
840:     }
841: 
842: 
843: 
844:     /**
845:      * Generate unique mark - useful for freezing (folding) some substrings.
846:      * @param  string   any string to froze
847:      * @param  int      Texy::CONTENT_* constant
848:      * @return string  internal mark
849:      */
850:     final public function protect($child, $contentType)
851:     {
852:         if ($child==='') return '';
853: 
854:         $key = $contentType
855:             . strtr(base_convert(count($this->marks), 10, 8), '01234567', "\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F")
856:             . $contentType;
857: 
858:         $this->marks[$key] = $child;
859: 
860:         return $key;
861:     }
862: 
863: 
864: 
865:     final public function unProtect($html)
866:     {
867:         return strtr($html, $this->marks);
868:     }
869: 
870: 
871: 
872:     /**
873:      * Filters bad URLs.
874:      * @param  string   user URL
875:      * @param  string   type: a-anchor, i-image, c-cite
876:      * @return bool
877:      */
878:     final public function checkURL($URL, $type)
879:     {
880:         // absolute URL with scheme? check scheme!
881:         if (!empty($this->urlSchemeFilters[$type])
882:             && preg_match('#'.TEXY_URLSCHEME.'#A', $URL)
883:             && !preg_match($this->urlSchemeFilters[$type], $URL))
884:             return FALSE;
885: 
886:         return TRUE;
887:     }
888: 
889: 
890: 
891:     /**
892:      * Is given URL relative?
893:      * @param  string  URL
894:      * @return bool
895:      */
896:     final public static function isRelative($URL)
897:     {
898:         // check for scheme, or absolute path, or absolute URL
899:         return !preg_match('#'.TEXY_URLSCHEME.'|[\#/?]#A', $URL);
900:     }
901: 
902: 
903: 
904:     /**
905:      * Prepends root to URL, if possible.
906:      * @param  string  URL
907:      * @param  string  root
908:      * @return string
909:      */
910:     final public static function prependRoot($URL, $root)
911:     {
912:         if ($root == NULL || !self::isRelative($URL)) return $URL;
913:         return rtrim($root, '/\\') . '/' . $URL;
914:     }
915: 
916: 
917: 
918:     final public function getLinePatterns()
919:     {
920:         return $this->_linePatterns;
921:     }
922: 
923: 
924: 
925:     final public function getBlockPatterns()
926:     {
927:         return $this->_blockPatterns;
928:     }
929: 
930: 
931: 
932:     final public function getDOM()
933:     {
934:         return $this->DOM;
935:     }
936: 
937: 
938: 
939:     private function tabCb($m)
940:     {
941:         return $m[1] . str_repeat(' ', $this->tabWidth - strlen($m[1]) % $this->tabWidth);
942:     }
943: 
944: 
945: 
946:     /**
947:      * PHP garbage collector helper.
948:      */
949:     final public function free()
950:     {
951:         if (version_compare(PHP_VERSION , '5.3', '<')) {
952:             foreach (array_keys(get_object_vars($this)) as $key) {
953:                 $this->$key = NULL;
954:             }
955:         }
956:     }
957: 
958: 
959: 
960:     final public function __clone()
961:     {
962:         throw new NotSupportedException('Clone is not supported.');
963:     }
964: 
965: }
966:
Namespaces

Classes

Interfaces
