Native template engine

I have been using native templates for quite some time, but for some reason, many people associate native templates with constructs like:

$title = 'My title' ; include( 'templates/index.html' ); * This source code was highlighted with Source Code Highlighter .

1. $title = 'My title' ; include( 'templates/index.html' ); * This source code was highlighted with Source Code Highlighter .
2. $title = 'My title' ; include( 'templates/index.html' ); * This source code was highlighted with Source Code Highlighter .

$title = 'My title' ; include( 'templates/index.html' ); * This source code was highlighted with Source Code Highlighter .

1. < html > < head > < title > <? php echo $ title ? > </ title > </ head >
2. <! - ... ->

* This source code was highlighted with Source Code Highlighter .

That is, the variable was determined and clicked on the html file. I think this is a completely wrong approach. Why?

')

First, all the variables passed to the template must be stored in one place (the property of the template engine class).

Secondly, in the template engine there should not be access to variables that are not passed to it, and to functions that are not defined in it.

Thirdly, the set of functions necessary for work should be defined.



Thus, I came to the conclusion that the template engine is needed, but it should not be a sophisticated Smarty-type brake.

The ideology of block template engines (XTemplate, for example) is not appealing to me because there are no branches as such, there are only cycles.



Because I wrote my own.



Let's start with the fact that we need to deal with error handling. I use exceptions for this purpose, therefore we define an exception class:

1. class STempException extends Exception {}

* This source code was highlighted with Source Code Highlighter .

Here we do not need anything else. Moving on to the template maker itself (what the methods do is briefly written in the comments, I will describe it in more detail below):

1. class STemp
2. {
3. / **
4. * Directory names templates are located.
5. *
6. * @var string.
7. * @access private.
8. * /
9. private $ path;
11. / **
12. * Name of the template.
13. *
14. * @var string.
15. * @access private.
16. * /
17. private $ template;
19. / **
20. * Where assigned template vars are kept.
21. *
22. * @var array.
23. * @access private.
24. * /
25. private $ variables = array ();
27. / **
28. * Parameters of the template engine.
29. *
30. * @var array.
31. * @access private
32. * /
33. private $ params = array (
34. 'xss_protection' => true
35. 'exit_after_display' => true
36. 'endofline_to_br' => false
37. );
39. / **
40. * File that include in template.
41. *
42. * @var string.
43. * @access private.
44. * /
45. private $ include_file;
47. / **
48. * The class constructor. Set where the templates are located.
49. *
50. * @param where the templates are located, the default 'templates /'.
51. * @access public.
52. * /
53. public function __construct ($ path = 'templates /' )
54. {
55. $ this -> path = $ path;
56. }
58. / **
59. * Set parameters of template engine.
60. *
61. * @param string $ param name of the parameter.
62. * @param bool $ value value of the parameter.
63. * @return bool TRUE if parameter set, FALSE if didn't set.
64. * @access public.
65. * /
66. public function setParam ($ param, $ value )
67. {
68. if (isset ($ this -> params [$ param])) {
69. $ this -> params [$ param] = $ value ;
70. return true ;
71. }
73. return false ;
74. }
76. / **
77. *
78. * @param string $ include_file path to include file.
79. * @access public.
80. * /
81. public function setIncludeFile ($ include_file)
82. {
83. $ this -> include_file = $ this -> path. $ include_file;
85. if (! file_exists ($ this -> path. $ include_file))
86. throw new STempException ( 'Include file' . $ this -> include_file. 'not exitst' );
87. }
89. / **
90. * Assigns values ​​to template variables.
91. *
92. * @param string $ name the template variable name.
93. * @param mixed $ value.
94. * @access public.
95. * /
96. public function assign ($ name, $ value )
97. {
98. $ this -> variables [$ name] = $ value ;
99. }
101. / **
102. * Executes and displays the template results.
103. *
104. * @param string $ template the template name.
105. * @access public.
106. * /
107. public function display ($ template)
108. {
109. $ this -> template = $ this -> path. $ template;
111. if (! file_exists ($ this -> template))
112. throw new STempException ( 'Template file' . $ template. 'not exitst' );
114. require_once ($ this -> template);
116. if ($ this -> params [ 'exit_after_display' ])
117. exit;
118. }
120. / **
121. * Get value of template variable.
122. *
123. * @param string $ name the template variable name.
124. * @return mixed variable FALSE if variable not set.
125. * @access private.
126. * /
127. private function __get ($ name)
128. {
129. if (isset ($ this -> variables [$ name])) {
130. $ variable = $ this -> variables [$ name];
132. if ($ this -> params [ 'xss_protection' ])
133. $ variable = $ this -> xssProtection ($ variable);
135. if ($ this -> params [ 'endofline_to_br' ])
136. $ variable = $ this -> endoflineToBr ($ variable);
138. return $ variable;
139. }
141. return NULL;
142. }
144. / **
145. * Include file
146. *
147. * @access private
148. * /
149. private function includeFile ()
150. {
151. if (! file_exists ($ this -> include_file))
152. throw new STempException ( 'Include file' . $ this -> include_file. 'not found' );
154. require_once ($ this -> include_file);
155. }
157. / **
158. * For the formation of endings of words.
159. *
160. * @param int $ value number.
161. * @param string $ word0 word in the singular.
162. * @param string $ word1 word in the plural (2, 3).
163. * @param string $ word2 word in the plural.
164. * @param string $ separator separator, default ''.
165. * @return string formed words
166. * @access private.
167. * /
168. private function morph ($ value , $ word0, $ word1, $ word2, $ separator = '' )
169. {
170. if (preg_match ( '/ 1 \ d $ /' , $ value ))
171. return $ value . $ separator. $ word2;
172. elseif (preg_match ( '/ 1 $ /' , $ value ))
173. return $ value . $ separator. $ word0;
174. elseif (preg_match ( '/ (2 | 3 | 4) $ /' , $ value ))
175. return $ value . $ separator. $ word1;
176. else
177. return $ value . $ separator. $ word2;
178. }
180. / **
181. * For protection from XSS.
182. *
183. * @param mixed $ variable data for protection.
184. * @return mixed protected data.
185. * @access private.
186. * /
187. private function xssProtection ($ variable)
188. {
189. if (is_array ($ variable)) {
190. $ protected = array ();
191. foreach ($ variable as $ key => $ value )
192. $ protected [$ key] = $ this -> xssProtection ($ value );
193. return $ protected ;
194. }
196. return htmlspecialchars ($ variable);
197. }
199. / **
200. * Inserts HTML line breaks before all newlines in a string.
201. *
202. * @param mixed $ variable data for protection.
203. * @return mixed data where string with <br /> inserted before all newlines.
204. * @access private.
205. * /
206. private function endoflineToBr ($ variable)
207. {
208. if (is_array ($ variable)) {
209. $ protected = array ();
210. foreach ($ variable as $ key => $ value )
211. $ protected [$ key] = $ this -> endoflineToBr ($ value );
212. return $ protected ;
213. }
215. return nl2br ($ variable);
216. }
217. }

* This source code was highlighted with Source Code Highlighter .

In the constructor, we can specify the path to the templates directory (temlates / by default).



Using the setParam method, we can set the template parameters. There are only three of them (that's enough for me, if necessary, you can add parameters). The first parameter - xss_protection - as the name implies, is needed to protect against the xss vulnerability. If the parameter value is set to true, all variables that we use in the template are automatically processed by the htmlspecialchars function (including array elements) before returning. The second parameter - exit_after_display - is needed so that, if necessary, we can stop the execution of the script after the template is displayed. The third parameter, endofline_to_br, processes all variables before return (including array elements) with the nl2br function.



With the setIncludeFile method, we can set the plugin pattern. The common template index.tpl.php is very often used, and a changeable part is connected to it, depending on the conditions. This is the way to automate this process. If the included file does not exist, an exception is thrown.



The assign method is used to transfer variables to a template.



The display method displays a pattern. If the template file does not exist, an exception is thrown. If the exit_after_display parameter is set to true, this method also terminates the script (almost always the display of the template is the last action).



The magic method __get returns the value of the variable passed to the template. If the variable is not defined, returns NULL. Depending on the parameters, variables before return can be processed.



The includeFile method includes the file assigned by the setIncludeFile method and throws an exception if this file is not found.



The morph method, not quite “template-like”, is used to form the correct ending of words relating to numerals. That is, 1 comment, 2 comments, 5 comments. In the method you need to pass the number itself, three different options and, optionally, a word delimiter (by default, non-breaking space).



The xssProtection method processes data by the htmlspecialchars function. If an array is input, then it is recursively searched and all its elements are processed.



The endoflineToBr method processes data using the nl2br function. If the array is input, then, as in the previous method, it recursively enumerates and processes all its elements.



How does it look in practice? Suppose we need to print an article and comments to it. Data on the article in the $ article array, comments - in $ comments.



Controller:

1. $ stemp = new STemp ();
3. $ stemp-> assign ( "title" , $ article [ 'title' ]);
5. $ stemp-> assign ( "article" , $ article);
6. $ stemp-> assign ( "comments" , $ comments);
8. try {
9. $ stemp-> setIncludeFile ( "article.tpl.php" );
10. $ stemp-> display ( "index.tpl.php" );
11. } catch (STempException $ e) {
12. die ( 'STemp error:' . $ e-> getMessage ());
13. }

* This source code was highlighted with Source Code Highlighter .

Template index.tpl.php:

1. < html >
2. < head >
3. < title > <? php echo $ this- > title? > </ title >
4. </ head >
5. < body >
6. <? php $ this- > includeFile ()? >
7. </ body >
8. </ html >

* This source code was highlighted with Source Code Highlighter .

Template article.tpl.php:

1. < h1 > <? php echo $ this- > article ['title']? > </ h1 >
2. <? php $ this- > setParam ('xss_protection', false); $ this- > setParam ('endofline_to_br', true)? >
3. < div class = "content" >
4. <? php echo $ this- > article ['content']? >
5. </ div >
6. < p > <? php echo $ this- > morph (count ($ this- > comments), 'comment', 'comment', 'comments')? > : </ p >
7. <? php $ this- > setParam ('xss_protecttion', true)? >
8. <? php foreach ($ this- > comments as $ key = > $ value) {? >
9. < p class = "user" > <? php echo $ value [ 'username' ]? > : </ p >
10. < p class = "comment" > <? php echo $ value [ 'text' ]? > </ p >
11. <? php }? >

* This source code was highlighted with Source Code Highlighter .

Download class .



The use of the class in personal needs is allowed without restrictions. When reprinting an article or source code, including, in part, a link to me (to my site ) is required.