5 A template parser supporting includes, translations, Lua code blocks
6 and more. It can be used either as a compiler or as an interpreter.
11 Copyright 2008 Steven Barth <steven@midlink.org>
13 Licensed under the Apache License, Version 2.0 (the "License");
14 you may not use this file except in compliance with the License.
15 You may obtain a copy of the License at
17 http://www.apache.org/licenses/LICENSE-2.0
19 Unless required by applicable law or agreed to in writing, software
20 distributed under the License is distributed on an "AS IS" BASIS,
21 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
22 See the License for the specific language governing permissions and
23 limitations under the License.
26 module("luci.template", package.seeall)
28 require("luci.config")
33 luci.config.template = luci.config.template or {}
35 viewdir = luci.config.template.viewdir or luci.sys.libpath() .. "/view"
36 compiledir = luci.config.template.compiledir or luci.sys.libpath() .. "/view"
40 -- none: Never compile, only use precompiled data from files
41 -- memory: Always compile, do not save compiled files, ignore precompiled
42 -- file: Compile on demand, save compiled files, update precompiled
43 compiler_mode = luci.config.template.compiler_mode or "memory"
46 -- Define the namespace for template modules
47 context = luci.util.threadlocal()
50 include = function(name) Template(name):render(getfenv(2)) end,
53 -- Compiles a given template into an executable Lua module
54 function compile(template)
55 -- Search all <% %> expressions (remember: Lua table indexes begin with #1)
56 local function expr_add(command)
57 table.insert(expr, command)
58 return "<%" .. tostring(#expr) .. "%>"
61 -- As "expr" should be local, we have to assign it to the "expr_add" scope
63 luci.util.extfenv(expr_add, "expr", expr)
65 -- Save all expressiosn to table "expr"
66 template = template:gsub("<%%(.-)%%>", expr_add)
68 local function sanitize(s)
69 s = luci.util.escape(s)
70 s = luci.util.escape(s, "'")
71 s = luci.util.escape(s, "\n")
75 -- Escape and sanitize all the template (all non-expressions)
76 template = sanitize(template)
78 -- Template module header/footer declaration
79 local header = "write('"
82 template = header .. template .. footer
85 local r_include = "')\ninclude('%s')\nwrite('"
86 local r_i18n = "'..translate('%1','%2')..'"
87 local r_i18n2 = "'..translate('%1', '')..'"
88 local r_pexec = "'..(%s or '')..'"
89 local r_exec = "')\n%s\nwrite('"
91 -- Parse the expressions
92 for k,v in pairs(expr) do
96 re = r_include:format(sanitize(string.sub(v, 2)))
99 re = sanitize(v):gsub(":(.-) (.*)", r_i18n)
101 re = sanitize(v):gsub(":(.+)", r_i18n2)
104 re = r_pexec:format(v:sub(2))
106 re = r_exec:format(v)
108 template = template:gsub("<%%"..tostring(k).."%%>", re)
111 return loadstring(template)
114 -- Oldstyle render shortcut
115 function render(name, scope, ...)
116 scope = scope or getfenv(2)
117 local s, t = luci.util.copcall(Template, name)
127 Template = luci.util.class()
129 -- Shared template cache to store templates in to avoid unnecessary reloading
133 -- Constructor - Reads and compiles the template on-demand
134 function Template.__init__(self, name)
135 if self.cache[name] then
136 self.template = self.cache[name]
141 -- Create a new namespace for this template
144 -- Copy over from general namespace
145 luci.util.update(self.viewns, viewns)
146 if context.viewns then
147 luci.util.update(self.viewns, context.viewns)
150 -- If we have a cached template, skip compiling and loading
151 if self.template then
155 -- Enforce cache security
156 local cdir = compiledir .. "/" .. luci.sys.process.info("uid")
159 local sourcefile = viewdir .. "/" .. name .. ".htm"
160 local compiledfile = cdir .. "/" .. luci.http.urlencode(name) .. ".lua"
163 if compiler_mode == "file" then
164 local tplmt = luci.fs.mtime(sourcefile)
165 local commt = luci.fs.mtime(compiledfile)
167 if not luci.fs.mtime(cdir) then
168 luci.fs.mkdir(cdir, true)
169 luci.fs.chmod(luci.fs.dirname(cdir), "a+rxw")
172 -- Build if there is no compiled file or if compiled file is outdated
173 if ((commt == nil) and not (tplmt == nil))
174 or (not (commt == nil) and not (tplmt == nil) and commt < tplmt) then
176 source, err = luci.fs.readfile(sourcefile)
179 local compiled, err = compile(source)
181 luci.fs.writefile(compiledfile, luci.util.dump(compiled))
182 self.template = compiled
185 self.template, err = loadfile(compiledfile)
188 elseif compiler_mode == "none" then
189 self.template, err = loadfile(self.compiledfile)
191 elseif compiler_mode == "memory" then
193 source, err = luci.fs.readfile(sourcefile)
195 self.template, err = compile(source)
200 -- If we have no valid template throw error, otherwise cache the template
201 if not self.template then
204 self.cache[name] = self.template
209 -- Renders a template
210 function Template.render(self, scope)
211 scope = scope or getfenv(2)
213 -- Save old environment
214 local oldfenv = getfenv(self.template)
216 -- Put our predefined objects in the scope of the template
217 luci.util.resfenv(self.template)
218 luci.util.updfenv(self.template, scope)
219 luci.util.updfenv(self.template, self.viewns)
221 -- Now finally render the thing
225 setfenv(self.template, oldfenv)