source: trunk/setup/inc/class.Template.inc.php @ 7681

Revision 7681, 10.3 KB checked in by douglasz, 11 years ago (diff)

Ticket #3236 - Correcoes para Best Practice: Short Open Tag e Best Practice: Always Quote Array Keys.

  • Property svn:eol-style set to native
  • Property svn:executable set to *
Line 
1<?php
2  /**************************************************************************\
3  * eGroupWare API - Template class                                          *
4  * (C) Copyright 1999-2000 NetUSE GmbH Kristian Koehntopp                   *
5  * ------------------------------------------------------------------------ *
6  * This is not part of phpGroupWare, but is used by eGroupWare.             *
7  * http://www.egroupware.org/                                               * 
8  * ------------------------------------------------------------------------ *
9  * This program is free software; you can redistribute it and/or modify it  *
10  * under the terms of the GNU Lesser General Public License as published    *
11  * by the Free Software Foundation; either version 2.1 of the License, or   *
12  * any later version.                                                       *
13  \**************************************************************************/
14
15
16        class Template
17        {
18                var $classname = 'Template';
19
20                /* if set, echo assignments */
21                var $debug = False;
22
23                /* $file['handle'] = 'filename'; */
24                var $file = array();
25
26                /* relative filenames are relative to this pathname */
27                var $root = '';
28
29                /* $varkeys['key'] = 'key'; $varvals['key'] = 'value'; */
30                var $varkeys = array();
31                var $varvals = array();
32
33                /* 'remove'  => remove undefined variables
34                 * 'comment' => replace undefined variables with comments
35                 * 'keep'    => keep undefined variables
36                 */
37                var $unknowns = 'remove';
38
39                /* 'yes' => halt, 'report' => report error, continue, 'no' => ignore error quietly */
40                var $halt_on_error = 'yes';
41
42                /* last error message is retained here */
43                var $last_error = '';
44
45                /***************************************************************************/
46                /* public: Constructor.
47                 * root:     template directory.
48                 * unknowns: how to handle unknown variables.
49                 */
50                function Template($root = '.', $unknowns = 'remove')
51                {
52                        $this->set_root($root);
53                        $this->set_unknowns($unknowns);
54                }
55
56                /* public: setroot(pathname $root)
57                 * root:   new template directory.
58                 */
59                function set_root($root)
60                {
61                        if (!is_dir($root))
62                        {
63                                $this->halt("set_root: $root is not a directory.");
64                                return false;
65                        }
66                        $this->root = $root;
67                        return true;
68                }
69
70                /* public: set_unknowns(enum $unknowns)
71                 * unknowns: 'remove', 'comment', 'keep'
72                 *
73                 */
74                function set_unknowns($unknowns = 'keep')
75                {
76                        $this->unknowns = $unknowns;
77                }
78
79                /* public: set_file(array $filelist)
80                 * filelist: array of handle, filename pairs.
81                 *
82                 * public: set_file(string $handle, string $filename)
83                 * handle: handle for a filename,
84                 * filename: name of template file
85                 */
86                function set_file($handle, $filename = '')
87                {
88                        if (!is_array($handle))
89                        {
90                                if ($filename == '')
91                                {
92                                        $this->halt("set_file: For handle $handle filename is empty.");
93                                        return false;
94                                }
95                                $this->file[$handle] = $this->filename($filename);
96                        }
97                        else
98                        {
99                                reset($handle);
100                                while(list($h, $f) = each($handle))
101                                {
102                                        $this->file[$h] = $this->filename($f);
103                                }
104                        }
105                }
106
107                /* public: set_block(string $parent, string $handle, string $name = '')
108                 * extract the template $handle from $parent,
109                 * place variable {$name} instead.
110                 */
111                function set_block($parent, $handle, $name = '')
112                {
113                        if (!$this->loadfile($parent))
114                        {
115                                $this->halt("subst: unable to load $parent.");
116                                return false;
117                        }
118                        if ($name == '')
119                        {
120                                $name = $handle;
121                        }
122                        $str = $this->get_var($parent);
123                        $reg = "/<!--\s+BEGIN $handle\s+-->(.*)\n\s*<!--\s+END $handle\s+-->/sm";
124                        preg_match_all($reg, $str, $m);
125                        $str = preg_replace($reg, '{' . "$name}", $str);
126                        $this->set_var($handle, $m[1][0]);
127                        $this->set_var($parent, $str);
128                }
129
130                /* public: set_var(array $values)
131                 * values: array of variable name, value pairs.
132                 *
133                 * public: set_var(string $varname, string $value)
134                 * varname: name of a variable that is to be defined
135                 * value:   value of that variable
136                 */
137                function set_var($varname, $value = '')
138                {
139                        if (!is_array($varname))
140                        {
141                                if (!empty($varname))
142                                {
143                                        if ($this->debug)
144                                        {
145                                                print "scalar: set *$varname* to *$value*<br>\n";
146                                        }
147                                        $this->varkeys[$varname] = $this->varname($varname);
148                                        $this->varvals[$varname] = str_replace('phpGroupWare','eGroupWare',$value);
149                                }
150                        }
151                        else
152                        {
153                                reset($varname);
154                                while(list($k, $v) = each($varname))
155                                {
156                                        if (!empty($k))
157                                        {
158                                                if ($this->debug)
159                                                {
160                                                        print "array: set *$k* to *$v*<br>\n";
161                                                }
162                                                $this->varkeys[$k] = $this->varname($k);
163                                                $this->varvals[$k] = str_replace('phpGroupWare','eGroupWare',$v);
164                                        }
165                                }
166                        }
167                }
168
169                /* public: subst(string $handle)
170                 * handle: handle of template where variables are to be substituted.
171                 */
172                function subst($handle)
173                {
174                        if (!$this->loadfile($handle))
175                        {
176                                $this->halt("subst: unable to load $handle.");
177                                return false;
178                        }
179
180                        $str = $this->get_var($handle);
181                        reset($this->varkeys);
182                        while (list($k, $v) = each($this->varkeys))
183                        {
184                                $str = str_replace($v, $this->varvals[$k], $str);
185                        }
186                        return $str;
187                }
188
189                /* public: psubst(string $handle)
190                 * handle: handle of template where variables are to be substituted.
191                 */
192                function psubst($handle)
193                {
194                        print $this->subst($handle);
195                        return false;
196                }
197
198                /* public: parse(string $target, string $handle, boolean append)
199                 * public: parse(string $target, array  $handle, boolean append)
200                 * target: handle of variable to generate
201                 * handle: handle of template to substitute
202                 * append: append to target handle
203                 */
204                function parse($target, $handle, $append = false)
205                {
206                        if (!is_array($handle))
207                        {
208                                $str = $this->subst($handle);
209                                if ($append)
210                                {
211                                        $this->set_var($target, $this->get_var($target) . $str);
212                                }
213                                else
214                                {
215                                        $this->set_var($target, $str);
216                                }
217                        }
218                        else
219                        {
220                                reset($handle);
221                                while(list($i, $h) = each($handle))
222                                {
223                                        $str = $this->subst($h);
224                                        $this->set_var($target, $str);
225                                }
226                        }
227                        return $str;
228                }
229
230                function pparse($target, $handle, $append = false)
231                {
232                        print $this->parse($target, $handle, $append);
233                        return false;
234                }
235
236                /* This is short for finish parse */
237                function fp($target, $handle, $append = False)
238                {
239                        return $this->finish($this->parse($target, $handle, $append));
240                }
241
242                /* This is a short cut for print finish parse */
243                function pfp($target, $handle, $append = False)
244                {
245                        echo $this->finish($this->parse($target, $handle, $append));
246                }
247
248                /* public: get_vars()
249                 */
250                function get_vars()
251                {
252                        reset($this->varkeys);
253                        while(list($k, $v) = each($this->varkeys))
254                        {
255                                $result[$k] = $this->varvals[$k];
256                        }
257                        return $result;
258                }
259
260                /* public: get_var(string varname)
261                 * varname: name of variable.
262                 *
263                 * public: get_var(array varname)
264                 * varname: array of variable names
265                 */
266                function get_var($varname)
267                {
268                        if (!is_array($varname))
269                        {
270                                return $this->varvals[$varname];
271                        }
272                        else
273                        {
274                                reset($varname);
275                                while(list($k, $v) = each($varname))
276                                {
277                                        $result[$k] = $this->varvals[$k];
278                                }
279                                return $result;
280                        }
281                }
282
283                /* public: get_undefined($handle)
284                 * handle: handle of a template.
285                 */
286                function get_undefined($handle)
287                {
288                        if (!$this->loadfile($handle))
289                        {
290                                $this->halt("get_undefined: unable to load $handle.");
291                                return false;
292                        }
293
294                        preg_match_all("/\{([^}]+)\}/", $this->get_var($handle), $m);
295                        $m = $m[1];
296                        if (!is_array($m))
297                        {
298                                return false;
299                        }
300                        reset($m);
301                        while(list($k, $v) = each($m))
302                        {
303                                if (!isset($this->varkeys[$v]))
304                                {
305                                        $result[$v] = $v;
306                                }
307                        }
308
309                        if (count($result))
310                        {
311                                return $result;
312                        }
313                        else
314                        {
315                                return false;
316                        }
317                }
318
319                /* public: finish(string $str)
320                 * str: string to finish.
321                 */
322                function finish($str)
323                {
324                        switch ($this->unknowns)
325                        {
326                                case 'keep':
327                                        break;
328                                case 'remove':
329                                        $str = preg_replace('/{[^ \t\r\n}]+}/', '', $str);
330                                        break;
331                                case 'comment':
332                                        $str = preg_replace('/{([^ \t\r\n}]+)}/', "<!-- Template $handle: Variable \\1 undefined -->", $str);
333                                        break;
334                        }
335
336                        return $str;
337                }
338
339                /* public: p(string $varname)
340                 * varname: name of variable to print.
341                 */
342                function p($varname)
343                {
344                        print $this->finish($this->get_var($varname));
345                }
346
347                function get($varname)
348                {
349                        return $this->finish($this->get_var($varname));
350                }
351
352                /***************************************************************************/
353                /* private: filename($filename)
354                 * filename: name to be completed.
355                 */
356                function filename($filename,$root='',$time=1)
357                {
358                        if($root=='')
359                        {
360                                $root=$this->root;
361                        }
362                        if (substr($filename, 0, 1) != '/')
363                        {
364                                $new_filename = $root.'/'.$filename;
365                        }
366                        else
367                        {
368                                $new_filename = $filename;
369                        }
370
371                        if (!file_exists($new_filename))
372                        {
373                                if($time==2)
374                                {
375                                        $this->halt("filename: file $new_filename does not exist.");
376                                }
377                                else
378                                {
379                                        $new_root = str_replace($GLOBALS['phpgw_info']['server']['template_set'],'default',$root);
380                                        $new_filename = $this->filename(str_replace($root.'/','',$new_filename),$new_root,2);
381                                }
382                        }
383                        return $new_filename;
384                }
385
386                /* private: varname($varname)
387                 * varname: name of a replacement variable to be protected.
388                 */
389                function varname($varname)
390                {
391                        return '{'.$varname.'}';
392                }
393
394                /* private: loadfile(string $handle)
395                 * handle:  load file defined by handle, if it is not loaded yet.
396                 */
397                function loadfile($handle)
398                {
399                        if (isset($this->varkeys[$handle]) and !empty($this->varvals[$handle]))
400                        {
401                                return true;
402                        }
403                        if (!isset($this->file[$handle]))
404                        {
405                                $this->halt("loadfile: $handle is not a valid handle.");
406                                return false;
407                        }
408                        $filename = $this->file[$handle];
409
410                        $str = implode('', @file($filename));
411                        if (empty($str))
412                        {
413                                $this->halt("loadfile: While loading $handle, $filename does not exist or is empty.");
414                                return false;
415                        }
416
417                        $this->set_var($handle, $str);
418                        return true;
419                }
420
421                /***************************************************************************/
422                /* public: halt(string $msg)
423                 * msg:    error message to show.
424                 */
425                function halt($msg)
426                {
427                        $this->last_error = $msg;
428
429                        if ($this->halt_on_error != 'no')
430                        {
431                                $this->haltmsg($msg);
432                        }
433
434                        if ($this->halt_on_error == 'yes')
435                        {
436                                echo('<b>Halted.</b>');
437                        }
438
439                        exit;
440                }
441
442                /* public, override: haltmsg($msg)
443                 * msg: error message to show.
444                 */
445                function haltmsg($msg)
446                {
447                        printf("<b>Template Error:</b> %s<br>\n", $msg);
448                }
449        }
Note: See TracBrowser for help on using the repository browser.