login  Naam:   Wachtwoord: 
Registreer je!
Scripts > PHP > UBB & Smilies > BBCode parser, v. 0.1


Reacties op het script BBCode parser, v. 0.1

Offline  Meulenhof
Gepost op: 19 februari 2009 - 11:42
Lid



Wat komt dit goed uit .

Ben bezig met mijn website te vernieuwen, kan ik mooi deze gebruiken . (Die Q-bb is niet helemaal volmaakt, die gebruik ik nu )

list en quote sluit goed af (heb je bij vele parsers niet)

Klein vraagje. Komt er nog een smilie functie in? Zo nee, dan bouw ik hem zelf wel erin. Heb het idee van wel want je gebruikt nogal wat smilie tags 

Kan zo 123 geen bugs vinden. Kleine idee misschien.
Goede reseizer erin verwerken voor plaatjes?

Offline  Richard
Gepost op: 19 februari 2009 - 12:51
Crew algemeen



Resizer doe je client-side, niet server-side. Kost veel te veel load. ;)

Smilies kun je heel makkelijk verwerken: in de TextNode kun je bij getContents (net als ik al heb gedaan voor autolinking) de smilies met bijvoorbeeld str_replace vervangen. :-)

Offline  Meulenhof
Gepost op: 19 februari 2009 - 13:20
Lid



JeXuS schreef:
Resizer doe je client-side, niet server-side. Kost veel te veel load. ;)

Smilies kun je heel makkelijk verwerken: in de TextNode kun je bij getContents (net als ik al heb gedaan voor autolinking) de smilies met bijvoorbeeld str_replace vervangen. :-)


Thnx het werkt  

Offline  Koen
Gepost op: 19 februari 2009 - 17:40
PHP expert



Uitstekend script!

Offline  Bart
Gepost op: 07 mei 2009 - 22:50
PHP expert



Prachtig script, werkelijk waar geen woord te veel in de omschrijving.
Makkelijk aan te passen, uit te breiden, etc. Voor de rest sluit ik mij aan bij Meulenhof wat betreft het afsluiten van alle tags. Tevens is het een knap staaltje werk wat betreft het quote systeem en de [table]-tags.

Offline  darsstar
Gepost op: 07 juni 2009 - 22:40
Nieuw lid



ik ben vandaag tegen een probleem aan gelopen door die aanpassing toen ik bezig was om te zorgen dat binnen een tag met TagRule::LITERAL het er nog steeds stack based aan toe gaat.
hij sloot de code tag bij de eerste eind tag al af, ook al stond er nog een openings tag voor...

ook wanneer ik een tekst laat parsen zonder tags maar wel met enters er in, dan zitten de output geen enters.
dus heb ik maar de str_replace van WhitespaceNode naar TextNode verplaatst.

hier mijn huidige Parser, WhitespaceNode en TextNode class, waardoor je dus dus wel code tags binnen code tags kunt zetten:

08-06-2009 Edit:
nog even een fix, regel 146 is nieuw.
php code - Bekijk de code zonder highlighting - Klap code in 
  1. <?php
  2.  
  3. /**
  4.  * Simpele parser gebaseerd op bijbehorende klassen
  5.  *
  6.  * <code><?php
  7.  *$parser = new Parser;
  8.  *$parser->setLexer(new Lexer_Split)
  9.  *       ->addRule(
  10.  *             // doe je ding hier
  11.  *         );</code>
  12.  * @package Bbcode
  13.  * @subpackage Parser
  14.  *
  15.  * @todo Optimalisatie! Vooral het cachen van tagnamen zou al schelen :-)
  16.  */
  17. class Parser {
  18. 	/**
  19. 	 * De gebruikte {@link Lexer}
  20. 	 *
  21. 	 * @var Lexer
  22. 	 */
  23. 	private $_lexer = null;
  24. 	/**
  25. 	 * De node waarin we nu bewerkingen doen
  26. 	 *
  27. 	 * @var Node_Point
  28. 	 */
  29. 	private $_currentNode = null;
  30. 	/**
  31. 	 * De rootnode van deze tekst
  32. 	 *
  33. 	 * @var Node_Root
  34. 	 */
  35. 	private $_rootNode = null;
  36.  
  37. 	/**
  38. 	 * Een lijst van rules die we tot onze beschikking hebben
  39. 	 *
  40. 	 * @var array Array van {@link Rule_Tag}s.
  41. 	 */
  42. 	private $_tagRules = array();
  43.  
  44. 	/**
  45. 	 * Lijst van geopende tags
  46. 	 *
  47. 	 * Let op: dit is meer optimalisatie, uiteindelijk zou alles prima
  48. 	 * via {@link Node::getParent()} te doen zijn, maar dit scheelt
  49. 	 * ontzettend veel tijd
  50. 	 *
  51. 	 * @var array Array van namen
  52. 	 */
  53. 	private $_openedTags = array();
  54.  
  55. 	/**
  56. 	 * Voeg een rule toe, waar mee kan worden geparsed
  57. 	 *
  58. 	 * @param Rule_Tag $rule
  59. 	 * @return Parser
  60. 	 */
  61. 	public function addRule(Rule_Tag $rule) {
  62. 		$this->_tagRules[$rule->getName()] = $rule;
  63. 		return $this;
  64. 	}
  65.  
  66. 	/**
  67. 	 * Stel de lexer in die we gaan gebruiken
  68. 	 *
  69. 	 * @param Lexer $lexer
  70. 	 * @return Parser
  71. 	 */
  72. 	public function setLexer(Lexer $lexer) {
  73. 		$this->_lexer = $lexer;
  74. 		return $this;
  75. 	}
  76.  
  77. 	/**
  78. 	 * De kern van de parser.
  79. 	 *
  80. 	 * Men neme een stuk tekst en insert het, en krijgt een root node met
  81. 	 * compleet geparsede tree terug die door middel van de __toString methode
  82. 	 * direct geoutput kan worden.
  83. 	 *
  84. 	 * @param string $text
  85. 	 * @return Node_Root
  86. 	 */
  87. 	public function parse($text) {
  88. 		$this->_rootNode = new RootNode();
  89. 		$this->_currentNode = $this->_rootNode;
  90. 		$this->_lexer->lex($text, array_keys($this->_tagRules));
  91.  
  92. 		while(false !== $token = $this->_lexer->getToken()) {
  93. 			if($token instanceof BeginTagToken) {
  94. 				$tagRule = $this->_tagRules[$token->getTagName()];
  95.  
  96. 				$oldNode = $this->_currentNode;
  97. 				while(! $tagRule->isPermissableIn($this->_currentNode)) {
  98. 					if($this->_currentNode instanceof RootNode) {
  99. 						// we zijn bovenaan, tag is echt NIET te matchen
  100. 						$this->_currentNode->addChildNode(new TextNode($token->getContent()));
  101. 						$this->_rootNode = $oldNode;
  102. 						continue 2;
  103. 					}
  104. 					$this->_currentNode = $this->_currentNode->getParent();
  105. 				}
  106.  
  107. 				if($tagRule->getTrimWhitespace() & TagRule::TRIM_BEFORE) {
  108. 					$oldNode->removeFinalWhitespace();
  109. 				}
  110.  
  111. 				$newNode = new TagNode($tagRule, $token->getTagName(), $token->getArguments());
  112. 				$newNode->setParent($this->_currentNode);
  113. 				$this->_currentNode->addChildNode($newNode);
  114. 				$this->_setTagOpen($token->getTagName());
  115.  
  116. 				if($tagRule->getParseType() == TagRule::PARSE) {
  117. 					$this->_currentNode = $newNode;
  118. 				} else {
  119. 					$nodeContent = '';
  120. 					$finished = false;
  121. 					while(false !== $newToken = $this->_lexer->getToken()) {
  122. 						if($newToken instanceof TagToken && $newToken->getTagName() == $token->getTagName()) {
  123. 							$this->_setTagOpen($newToken->getTagName(), $newToken instanceof BeginTagToken);
  124.  
  125. 							if($newToken instanceof EndTagToken && ! isset($this->_openedTags[$token->getTagName()])) {
  126. 								$finished = true;
  127. 								$this->_setTagOpen($newToken->getTagName(), false);
  128. 								$newNode->addChildNode(new LiteralTextNode($nodeContent));
  129. 								if($this->_tagRules[$token->getTagName()]->getTrimWhitespace() & TagRule::TRIM_AFTER) {
  130. 									// probeer whitespace weg te halen bij volgende input
  131. 									if(false !== ($peek = $this->_lexer->peekToken())) {
  132. 										if($peek instanceof WhitespaceToken) {
  133. 											$this->_lexer->peekToken();
  134. 										}
  135. 									}
  136. 								}
  137.  
  138. 								break;
  139. 							}
  140. 						}
  141.  
  142. 						$nodeContent .= $newToken->getContent();
  143. 					}
  144.  
  145. 					if(!$finished) {
  146. 						$this->_setTagOpen($token->getTagName(), false);
  147. 						$newNode->addChildNode(new LiteralTextNode($nodeContent));
  148. 					}
  149. 					unset($finished);
  150. 				}
  151. 			} elseif($token instanceof EndTagToken && $this->_currentNode instanceof TagNode) {
  152. 				if(isset($this->_openedTags[$token->getTagName()])) {
  153. 					if($this->_tagRules[$token->getTagName()]->getTrimWhitespace() & TagRule::TRIM_AFTER) {
  154. 						// probeer whitespace weg te halen bij volgende input
  155. 						if(false !== ($peek = $this->_lexer->peekToken())) {
  156. 							if($peek instanceof WhitespaceToken) {
  157. 								$this->_lexer->peekToken();
  158. 							}
  159. 						}
  160. 					}
  161.  
  162. 					// check of de eindtag dezelfde naam heeft als de huidige opentag
  163. 					while($this->_currentNode instanceof TagNode && $token->getTagName() != $this->_currentNode->getTagName()) {
  164. 						$this->_setTagOpen($token->getTagName(), false);
  165. 						$this->_currentNode = $this->_currentNode->getParent();
  166. 					}
  167. 					if(! $this->_currentNode instanceof RootNode) {
  168. 						$this->_currentNode = $this->_currentNode->getParent();
  169. 					}
  170. 				} else {
  171. 					$this->_currentNode->addChildNode(new TextNode($token->getContent()));
  172. 				}
  173. 			} elseif($token instanceof WhitespaceToken) {
  174. 				// simpele whitespace
  175. 				$this->_currentNode->addChildNode(new WhitespaceNode($token->getContent()));
  176. 			} else {
  177. 				// alleen nog tekst
  178. 				$this->_currentNode->addChildNode(new TextNode($token->getContent()));
  179. 			}
  180. 		}
  181.  
  182. 		return $this->_rootNode;
  183. 	}
  184.  
  185. 	/**
  186. 	 * Stel in of een tag geopend of gesloten is
  187. 	 *
  188. 	 * @param string $tagName
  189. 	 * @param boolean $add true bij nieuw, false bij gesloten
  190. 	 */
  191. 	protected function _setTagOpen($tagName, $add = true) {
  192. 		if($add) {
  193. 			if(! isset($this->_openedTags[$tagName])) {
  194. 				$this->_openedTags[$tagName] = 1;
  195. 			} else {
  196. 				++$this->_openedTags[$tagName];
  197. 			}
  198. 		} else if(isset($this->_openedTags[$tagName])) {
  199. 			--$this->_openedTags[$tagName];
  200. 			if(! $this->_openedTags[$tagName]) {
  201. 				unset($this->_openedTags[$tagName]);
  202. 			}
  203. 		}
  204. 	}
  205. }
  206.  
  207. /**
  208.  * Node die whitespace representeert
  209.  *
  210.  * @package Bbcode
  211.  * @subpackage Node
  212.  */
  213. class WhitespaceNode extends TextNode {}
  214.  
  215. /**
  216.  * Tekstnode
  217.  *
  218.  * Representatie van een gedeelte met alleen tekst
  219.  *
  220.  * @author Richard van Velzen
  221.  * @package Bbcode
  222.  * @subpackage Node
  223.  */
  224. class TextNode extends Node {
  225.     /**
  226.      * De inhoud van deze node
  227.      *
  228.      * @var string
  229.      */
  230.     protected $_contents = '';
  231.  
  232.     /**
  233.      * Stel de contents van deze node in
  234.      *
  235.      * @param string $contents
  236.      */
  237.     public function __construct($contents) {
  238.         $this->_contents = $contents;
  239.         parent::__construct();
  240.     }
  241.  
  242.     /**
  243.      * Haal de content van deze node op
  244.      *
  245.      * @return string
  246.      */
  247.     public function getContents() {
  248.         $output = htmlspecialchars($this->_contents);
  249.  
  250.         // automatisch linken naar urls
  252.             '{(?<=\b)((?:https?|ftp)://|www\.)[\w.]+[;#&/~=\w+()?.,:%-]*[;#&/~=\w+(-]}i',
  253.             array($this, '_linkReplacement'),
  254.             $output
  255.         );
  256.  
  257.         return str_replace("\n", '<br />', $output);
  258.     }
  259.  
  260.     /**
  261.      * Haal de stringrepresenatie van deze node op
  262.      *
  263.      * @return string
  264.      */
  265.     public function __toString() {
  266.         return $this->getContents();
  267.     }
  268.  
  269.     /**
  270.      * Link replacement voor {@link TextNode::getContents()}
  271.      *
  272.      * @param array $match Input vanuit preg_match_callback
  273.      * @return string
  274.      */
  275.     protected function _linkReplacement(array $match) {
  276.         $link = $match[0];
  277.         if($match[1] == 'www.') {
  278.             $link = 'http://' . $match[0];
  279.         }
  280.  
  281.         return '<a href="' . $link . '">' . $match[0] . '</a>';
  282.     }
  283. }


verder heb ik zelf elke class in een appart bestand gezet die de autoloader automatisch include als dat nodig is.
(ik heb zelf alle namen van de classes aangepast zodat wanneer je de underscores vervangt door slashes je de juiste include pad hebt, dus Token_Tag_Begin extends Token_Tag ipv BeginTagToken extends TagToken)
en ik vond het eigenlijk niet leuk om in elk script waar ik deze bbcode parser wil gebruiken die functies te zetten, of een script te includen met al die functies er in.
ik wilde dit dus ook aan de autoloader overlaten, en dus classes hebben in plaats van functies...
simpel weg de class TagTemplate extenden heb ik niet gedaan aangezien alleen de methode render() echt verplicht is.
dus heb ik maar een abstacte class Tag aangemaakt
hier volgen dus 4 nieuwe classes (Tag, CodeTag, TagLink en ImageTag) en de aangepaste classes TagTemplate (alleen maar extends Tag) en TagRule (TagTemplate vervangen door Tag)
php code - Bekijk de code zonder highlighting - Klap code in 
  1. <?php
  2.  
  3. /**
  4.  * Een generieke regel qua wat er moet gebeuren
  5.  *
  6.  * @author Richard van Velzen
  7.  * @package Bbcode
  8.  * @subpackage TagRule
  9.  */
  10. class TagRule {
  11.     /**
  12.      * Geen whitespace trimmen
  13.      */
  14.     const TRIM_NONE = 0;
  15.     /**
  16.      * Whitespace voor de tag trimmen
  17.      */
  18.     const TRIM_BEFORE = 1;
  19.     /**
  20.      * Whitespace na de tag trimmen
  21.      */
  22.     const TRIM_AFTER = 2;
  23.     /**
  24.      * Aan beide kanten trimmen
  25.      */
  26.     const TRIM_BOTH = 3;
  27.     /**
  28.      * Binnen deze tag verder parsen
  29.      */
  30.     const PARSE = 3;
  31.     /**
  32.      * Niet parsen binnen deze tag
  33.      */
  34.     const LITERAL = 2;
  35.  
  36.     /**
  37.      * Naam van de tag
  38.      *
  39.      * @var string
  40.      */
  41.     private $_name = '';
  42.     /**
  43.      * In welke state zitten we binnen deze tag
  44.      *
  45.      * @var string
  46.      */
  47.     private $_state = '';
  48.     /**
  49.      * De states bninen welke deze tag is toegestaan
  50.      *
  51.      * @var array
  52.      */
  53.     private $_permissableIn = array();
  54.     /**
  55.      * Bijbehorende processor
  56.      *
  57.      * @var Tag|callback
  58.      */
  59.     private $_processor = null;
  60.     /**
  61.      * Manier waarop deze tag wordt geparsed
  62.      *
  63.      * @var integer Een van {@link TagRule::PARSE} en {@link TagRule::LITERAL}
  64.      */
  65.     private $_parseType = self::PARSE;
  66.     /**
  67.      * Bepaalt of en zo ja, aan welke kanten van de tag whitespace wordt getrimmed
  68.      *
  69.      * @var integer
  70.      */
  71.     private $_trimWhitespace = self::TRIM_NONE;
  72.  
  73.     /**
  74.      * Stel de waarden voor deze rule in
  75.      *
  76.      * @param string $name De naam van de rule
  77.      * @param string $state De state waarin we in deze tag zitten
  78.      * @param array $permissableIn States waarin deze rule zich mag bevinden
  79.      * @param callback|Tag $processor Ofwel een callback ofwel een TagTemplate
  80.      * @param integer $trimWhitespace Op welke wijze moeten we whitespace rondom trimmen?
  81.      * @param integer $parseType Is dit een letterlijke of parsende rule?
  82.      */
  83.     public function __construct($name, $state, array $permissableIn, $processor, $trimWhitespace = self::TRIM_NONE, $parseType = self::PARSE) {
  84.         if(!$processor instanceof Tag && !is_callable($processor)) {
  85.             throw new InvalidArgumentException('Geen geldige processor voor tag "' . $name . '"');
  86.         }
  87.         if($trimWhitespace < 0 || $trimWhitespace > 3) {
  88.             throw new InvalidArgumentException('TrimWhitespace is niet geldig voor "' . $name . '"');
  89.         }
  90.         if($parseType != self::PARSE && $parseType != self::LITERAL) {
  91.             throw new InvalidArgumentException('Parsetype is niet geldig voor "' . $name . '"');
  92.         }
  93.  
  94.         $this->_name = $name;
  95.         $this->_state = $state;
  96.         $this->_permissableIn = $permissableIn;
  97.         $this->_processor = $processor;
  98.         $this->_trimWhitespace = $trimWhitespace;
  99.         $this->_parseType = $parseType;
  100.     }
  101.  
  102.     /**
  103.      * Process de output van deze rule
  104.      *
  105.      * @param string $tagName
  106.      * @param string $content
  107.      * @param array $arguments
  108.      * @return string
  109.      */
  110.     public function processOutput($tagName, $content, array $arguments) {
  111.         if($this->_processor instanceof Tag) {
  112.             return $this->_processor->render($tagName, $content, $arguments);
  113.         }
  114.  
  115.         return call_user_func($this->_processor, $tagName, $content, $arguments);
  116.     }
  117.  
  118.     /**
  119.      * Haal de tagnaam op
  120.      *
  121.      * @return string
  122.      */
  123.     public function getName() {
  124.         return $this->_name;
  125.     }
  126.  
  127.     /**
  128.      * Haal de state op
  129.      *
  130.      * @return string
  131.      */
  132.     public function getState() {
  133.         return $this->_state;
  134.     }
  135.  
  136.     /**
  137.      * Check of deze state is toegestaan binnen een node
  138.      *
  139.      * @param PointNode $node
  140.      * @return boolean
  141.      */
  142.     public function isPermissableIn(PointNode $node) {
  143.         return in_array($node->getRule()->getState(), $this->_permissableIn);
  144.     }
  145.  
  146.     /**
  147.      * Kijk of er whitespace moet worden weggehaald voor of na
  148.      *
  149.      * @return integer
  150.      */
  151.     public function getTrimWhitespace() {
  152.         return $this->_trimWhitespace;
  153.     }
  154.  
  155.     /**
  156.      * Hoe moet deze tag worden geparsed
  157.      *
  158.      * @return integer Een van {@link TagRule::PARSE} en
  159.      *                 {@link TagRule::LITERAL}
  160.      */
  161.     public function getParseType() {
  162.         return $this->_parseType;
  163.     }
  164. }
  165.  
  166. /**
  167.  * Tag
  168.  *
  169.  * @author Dos Moonen
  170.  * @package Bbcode
  171.  * @subpackage Tag
  172.  */
  173. abstract class Tag {
  174.  
  175. 	/**
  176. 	 * Render de tag
  177. 	 *
  178. 	 * Voer de rendering uit met behulp van de argumenten
  179. 	 *
  180. 	 * @param string $tagName
  181. 	 * @param string $content
  182. 	 * @param array $arguments
  183. 	 * @return string
  184. 	 */
  185. 	abstract function render($tagName, $content, array $arguments);
  186.  
  187. }
  188.  
  189. /**
  190.  * Code Tag
  191.  *
  192.  * @author Dos Moonen
  193.  * @package Bbcode
  194.  * @subpackage Tag
  195.  */
  196.  
  197. class CodeTag extends Tag
  198. {
  199.  
  200. 	/**
  201. 	 * Verwerking voor de code tag
  202. 	 *
  203. 	 * @param string $tagName
  204. 	 * @param string $content
  205. 	 * @param array $arguments
  206. 	 * @return string
  207. 	 */
  208. 	public function render($tagName, $content, array $arguments) {
  209.  
  210. 		$lines = '<pre style="float: left; margin-top: 0px; margin-bottom: 0px;">'.implode('<br />', range(1, substr_count($content, "\n") + 1)).'</pre>';
  211.  
  212. 		$code = str_replace(
  213. 			array('<code>', '</code>', "\n"),
  214. 			array('<pre style="float: left; width: 90%; margin-left: 5px; margin-top: 0px; margin-bottom: 0px; white-space: nowrap; overflow: auto;">', '</pre>', ''),
  216. 				$content,
  217. 				true
  218. 			)
  219. 		);
  220.  
  221. 		$return = '<div style="border: 1px dotted #333; text-align: left; width: 400px;"><div style="clear: both;"></div>' . $lines . $code . '<div style="clear: both;"></div></div>';
  222.  
  223. 		return $return;
  224. 	}
  225. }
  226.  
  227. /**
  228.  * Image Tag
  229.  *
  230.  * @author Dos Moonen
  231.  * @package Bbcode
  232.  * @subpackage Tag
  233.  */
  234. class ImageTag extends Tag
  235. {
  236.  
  237. 	/**
  238. 	 * Verwerking voor een image tag
  239. 	 *
  240. 	 * @param string $tagName
  241. 	 * @param string $content
  242. 	 * @param array $arguments
  243. 	 * @return string
  244. 	 */
  245. 	public function render($tagName, $content, array $arguments) {
  246. 		$content = (empty($content) AND isset($arguments[$tagName])) ? $arguments[$tagName] : $content;
  247.  
  248. 		$match = array();
  249. 		if(!preg_match('{^(?:((?:https?|ftp)://(?:www\.)?)|\w+\.)[\w.]+[;#&/~=\w+()?.,:%-]*$}i', $content, $match)) {
  250. 			return htmlentities($content, ENT_QUOTES);
  251. 		}
  252.  
  253. 		$url = $content;
  254. 		if(empty($match[1])) {
  255. 			$url = 'http://' . $url;
  256. 		}
  257.  
  258. 		$alt = isset($arguments['alt']) ? htmlentities($arguments['alt'], ENT_QUOTES) : '';
  259.  
  260. 		return '<img src="' . htmlentities($url, ENT_QUOTES) . '" alt="' . $alt . '" />';
  261. 	}
  262. }
  263.  
  264.  /**
  265.  * Link tag
  266.  *
  267.  * @author Dos Moonen
  268.  * @package Bbcode
  269.  * @subpackage Tag
  270.  */
  271. class TagLink extends Tag
  272. {
  273.  
  274. 	/**
  275. 	 * Verwerking voor de url tag
  276. 	 *
  277. 	 * @param string $tagName
  278. 	 * @param string $content
  279. 	 * @param array $arguments
  280. 	 * @return string
  281. 	 */
  282. 	public function render($tagName, $content, array $arguments) {
  283. 		$argName = $tagName;
  284.  
  285. 		$link = &$arguments[$argName];
  286. 		$match = array();
  287. 		if(!isset($link) || !preg_match('{^(?:((?:https?|ftp)://)|\w+\.)[\w.]+[;#&/~=\w+()?.,:%-]*$}i', $link, $match)) {
  288. 			return $content;
  289. 		}
  290.  
  291. 		if(empty($match[1])) {
  292. 			$link = 'http://' . $link;
  293. 		}
  294.  
  295. 		return '<a href="' . $link . '">' . (!empty($content) ? $content : $link) . '</a>';
  296. 	}
  297. }
  298.  
  299. /**
  300.  * TagTemplate
  301.  *
  302.  * Een template die kan worden gebruikt bij een tag
  303.  *
  304.  * @author Richard van Velzen
  305.  * @package Bbcode
  306.  * @subpackage Tag
  307.  */
  308. class TagTemplate extends Tag {
  309. 	/**
  310. 	 * De originele template
  311. 	 *
  312. 	 * @var string
  313. 	 */
  314. 	private $_template = '';
  315. 	/**
  316. 	 * Argumenten bij de aanroep
  317. 	 *
  318. 	 * @var array
  319. 	 */
  320. 	private $_arguments = array();
  321.  
  322. 	/**
  323. 	 * Voer de template in
  324. 	 *
  325. 	 * @param string $template
  326. 	 */
  327. 	public function __construct($template) {
  328. 		$this->_template = $template;
  329. 	}
  330.  
  331. 	/**
  332. 	 * Render de template
  333. 	 *
  334. 	 * Voer de templaterendering uit met behulp van de argumenten
  335. 	 *
  336. 	 * @param string $tagName
  337. 	 * @param string $content
  338. 	 * @param array $arguments
  339. 	 * @return string
  340. 	 */
  341. 	public function render($tagName, $content, array $arguments) {
  342. 		$this->_arguments = $arguments;
  343. 		$this->_arguments['_tag'] = $tagName;
  344. 		$this->_arguments['_content'] = $content;
  345.  
  347. 			'~{\$([A-Za-z_][A-Za-z\d_]*)(?:/([a-z\d/]+))?}~',
  348. 			array($this, '_variableReplace'),
  349. 			$this->_template
  350. 		);
  351.  
  352. 		// geheugen vrijmaken, blij blij blij :-)
  353. 		$this->_arguments = null;
  354. 		return $return;
  355. 	}
  356.  
  357. 	/**
  358. 	 * Callback voor het vervangen van template variabelen
  359. 	 *
  360. 	 * @param array $match
  361. 	 * @return string
  362. 	 */
  363. 	private function _variableReplace(array $match) {
  364. 		if(! isset($this->_arguments[$match[1]])) {
  365. 			return '';
  366. 		}
  367.  
  368. 		$return = $this->_arguments[$match[1]];
  369.  
  370. 		if(isset($match[2])) {
  371. 			$return = $this->_applyModifiers($return, explode('/', $match[2]));
  372. 		}
  373.  
  374. 		return $return;
  375. 	}
  376.  
  377. 	/**
  378. 	 * Voer verschillende modifiers uit over de tekst
  379. 	 *
  380. 	 * @param string $text
  381. 	 * @param array $modifiers
  382. 	 * @return string
  383. 	 */
  384. 	private function _applyModifiers($text, array $modifiers) {
  385. 		$usedModifiers = array();
  386.  
  387. 		foreach($modifiers as $modifier) {
  388. 			// even checken, niet dubbel uitvoeren
  389. 			if(isset($usedModifiers[$modifier])) {
  390. 				continue;
  391. 			}
  392.  
  393. 			$usedModifiers[$modifier] = 0;
  394.  
  395. 			switch(strtolower(trim($modifier))) {
  396. 				case 'trim':
  397. 					$text = preg_replace(array('{^(?:<br />|\s+)+}', '{(?:<br />|\s+)+$}'), '', $text);
  398. 					break;
  399. 				case 'nl2br':
  400. 					$text = str_replace("\n", '<br />', $text);
  401. 					break;
  402. 				case 'html':
  403. 					$text = htmlentities($text, ENT_QUOTES);
  404. 					break;
  405. 				default:
  406. 					// oei, foutje zeker?
  407. 					throw new RuntimeException('Onbekende modifier "' . $modifier . '"');
  408. 			}
  409. 		}
  410.  
  411. 		return $text;
  412. 	}
  413. }


Enkel aanvullende informatie, vragen en antwoorden op vragen zijn welkom.
 
© 2002-2024 Sitemasters.be - Regels - Laadtijd: 0.075s