JasonWoof Got questions, comments, patches, etc.? Contact Jason Woofenden
run.php works even through symbolic links
[wfpl.git] / template.php
1 <?php
2
3 #  Copyright (C) 2005 Jason Woofenden
4 #
5 #  This file is part of wfpl.
6 #
7 #  wfpl is free software; you can redistribute it and/or modify it
8 #  under the terms of the GNU General Public License as published by
9 #  the Free Software Foundation; either version 2, or (at your option)
10 #  any later version.
11 #
12 #  wfpl is distributed in the hope that it will be useful, but
13 #  WITHOUT ANY WARRANTY; without even the implied warranty of
14 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 #  General Public License for more details.
16 #
17 #  You should have received a copy of the GNU General Public License
18 #  along with wfpl; see the file COPYING.  If not, write to the
19 #  Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
20 #  MA 02111-1307, USA.
21
22
23 # This file contains generally useful template handling code. It is wrapped in
24 # an object so that if you want/need to you can make more than one instance of
25 # it and they won't step on each other's toes. Also there are a set of global
26 # functions at the bottom so you don't have to mess around with objects if you
27 # don't want to. The documentation will be on the object methods, but just know
28 # that each has a straight function wrapper at the bottom with 'tem_' prepended
29 # to the name.
30
31 # This is designed to be as simple as it can be for your project. The simple
32 # way to use it is to set some key/value pairs with tem_set() then call
33 # tem_output('filename.html') to output the page. A more complex example
34 # including the use of sub-templates can be found in tem_test.php
35
36 # FIXME: sub-sub templates need to be cleared when the sub template containing
37 # them is run
38
39 require_once('code/wfpl/encode.php');
40 require_once('code/wfpl/misc.php'); # to get read_whole_file()
41
42 class tem {
43         var $keyval;        # an array containing key/value pairs 
44         var $filename;      # template filename (sometimes not set)
45         var $template;      # contents of template
46         var $sub_templates; # tag-name/template-string pairs
47         var $sub_subs;      # key: sub-template name  value: array of names of the sub-templates of this one
48
49         # initialize variables
50         function tem() {
51                 $this->keyval = array('' => '~'); # so that ~~ in the template creates a single ~
52                 $this->sub_templates = array();
53         }
54
55         # set a key/value pair. if a ~tag~ in the template matches key it will be replaced by value
56         function set($key, $value) {
57                 $this->keyval[$key] = $value;
58         }
59
60         # clear a value. Functionally equivalent to set($key, '') but cleaner and more efficient
61         function clear($key) {
62                 unset($this->keyval[$key]);
63         }
64
65         # grab a value you stuck in earlier with set()
66         function get($key) {
67                 return $this->keyval[$key];
68         }
69
70         # run the template engine on one of the sub-templates and append the result
71         # to the keyval in the main array. See tem_test.php for an example of how
72         # this can be used.
73         function sub($sub_template_name) {
74                 $this->keyval[$sub_template_name] .= template_run($this->sub_templates[$sub_template_name], $this->keyval);
75
76                 # after running a sub-template, clear its sub-templates
77                 if(isset($this->sub_subs[$sub_template_name])) {
78                         foreach($this->sub_subs[$sub_template_name] as $sub_sub) {
79                                 $this->clear($sub_sub);
80                         }
81                 }
82         }
83
84         # this is used by tem::load() and should be otherwise useless
85         function _load(&$in, &$out, &$parents, &$parent) {
86                 while($in) {
87                         # scan for one of: 1) the begining of a sub-template 2) the end of this one 3) the end of the file
88                         $n = strpos($in, '<!--~');
89                         if($n === false) { # not found
90                                 # we hit the end of the file
91                                 $out .= $in;
92                                 $in = '';
93                                 return;
94                         }
95
96                         # move everything up to (but not including) <!-- to the output
97                         $out .= substr($in, 0, $n);
98                         $in = substr($in, $n);
99
100                         # we found something.
101                         # is it an end tag?
102                         if(strcmp('<!--~end~-->', substr($in, 0, 12)) == 0) {
103                                 $in = substr($in, 12);
104                                 $parent = array_pop($parents);
105                                 return;
106                         }
107
108                         $matches = array();
109                         # this limits sub_template names to 50 chars
110                         if(ereg('^<!--~([^~]*) start~-->', substr($in, 0, 65), $matches)) {
111                                 list($start_tag, $tag_name) = $matches;
112
113                                 # keep track of the tree
114                                 if(!isset($this->sub_subs[$parent])) {
115                                         $this->sub_subs[$parent] = array();
116                                 }
117                                 array_push($this->sub_subs[$parent], $tag_name);
118                                 array_push($parents, $parent);
119                                 $parent = $tag_name;
120
121                                 $out .= '~' . $tag_name . '~';
122                                 $in = substr($in, strlen($start_tag));
123                                 $this->sub_templates[$tag_name] = '';
124                                 $this->_load($in, $this->sub_templates[$tag_name], $parents, $parent);
125                         } else {
126                                 # it's not a start tag or end tag, so let's pass it through:
127                                 $out .= substr($in, 0, 5);
128                                 $in = substr($in, 5);
129                         }
130                 } #repeat
131         }
132
133         # This is useful when you have sub-templates that you want to mess with
134         # before the main template is run. But can also be used to simply specify
135         # the filename ahead of time.
136         function load($filename) {
137                 $this->filename = $filename;
138                 $tmp = read_whole_file($filename);
139                 $this->template = '';
140                 $parents = array('top_level_subs' => array());
141                 $parent = 'top_level_subs';
142                 $this->_load($tmp, $this->template, $parents, $parent);
143         }
144                 
145         # Run the template. Pass a filename, or a string, unless you've already
146         # specified a template with load()
147         function run($templ = false) {
148                 if($templ !== false) {
149                         if(strlen($templ) < 150 && file_exists($templ)) {
150                                 $this->filename = $templ;
151                                 unset($this->template);
152                         } else {
153                                 $this->template = $templ;
154                         }
155                 }
156
157                 if(!$this->template) {
158                         if(!$this->filename) {
159                                 print "sorry, no template to run\n";
160                                 exit(1);
161                         }
162
163                         $this->template = read_whole_file($this->filename);
164                 }
165                 
166                 return template_run($this->template, $this->keyval);
167         }       
168
169         # same as run() except the output is print()ed
170         function output($templ = false) {
171                 print($this->run($templ));
172         }
173 }
174
175 # Below are functions so you can use the above class without allocating or
176 # keeping track of it.
177
178 # get a reference to the current template object
179 function tem_init() { 
180         if(!$GLOBALS['wfpl_template']) {
181                 $GLOBALS['wfpl_template'] = new tem();
182         }
183 }
184                 
185 function tem_set($key, $value) {
186         tem_init();
187         $GLOBALS['wfpl_template']->set($key, $value);
188 }
189         
190 function tem_get($key) {
191         tem_init();
192         return $GLOBALS['wfpl_template']->get($key);
193 }
194
195 function tem_run($templ = false) {
196         tem_init();
197         return $GLOBALS['wfpl_template']->run($templ);
198 }
199
200 function tem_sub($sub_template_name) {
201         tem_init();
202         $GLOBALS['wfpl_template']->sub($sub_template_name);
203 }
204
205 function tem_load($filename) {
206         tem_init();
207         $GLOBALS['wfpl_template']->load($filename);
208 }
209
210 function tem_output($filename = false) {
211         tem_init();
212         $GLOBALS['wfpl_template']->output($filename);
213 }
214
215
216
217 # this is used in template_run() and should be of no other use
218 function template_filler($matches) {
219         list($tag, $enc) = explode('.', $matches[1], 2);
220         $value = $GLOBALS['wfpl_template_keyval'][$tag];
221         if($enc) {
222                 $encs = explode('.', $enc);
223                 foreach($encs as $enc) {
224                         $enc = "enc_$enc";
225                         if(function_exists($enc)) {
226                                 $value = $enc($value);
227                         } else {
228                                 print "ERROR: encoder function '$enc' not found.<br>\n";
229                                 exit(1);
230                         }
231                 }
232         }
233         return $value;
234 }
235
236
237 # pass a template string and an associative array of the key/values and it
238 # returns the result.
239 function template_run($template, &$keyval) {
240         $GLOBALS['wfpl_template_keyval'] =& $keyval;
241         return preg_replace_callback(array('|<!--~([^~]*)~-->|', '|~([^~]*)~|', '|<span class="template">([^<]*)</span>|', '|<p class="template">([^<]*)</p>|'), 'template_filler', $template);
242 }
243
244
245 ?>