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
49 include = function(name) Template(name):render(getfenv(2)) end,
52 -- Compiles a given template into an executable Lua module
53 function compile(template)
54 -- Search all <% %> expressions (remember: Lua table indexes begin with #1)
55 local function expr_add(command)
56 table.insert(expr, command)
57 return "<%" .. tostring(#expr) .. "%>"
60 -- As "expr" should be local, we have to assign it to the "expr_add" scope
62 luci.util.extfenv(expr_add, "expr", expr)
64 -- Save all expressiosn to table "expr"
65 template = template:gsub("<%%(.-)%%>", expr_add)
67 local function sanitize(s)
68 s = luci.util.escape(s)
69 s = luci.util.escape(s, "'")
70 s = luci.util.escape(s, "\n")
74 -- Escape and sanitize all the template (all non-expressions)
75 template = sanitize(template)
77 -- Template module header/footer declaration
78 local header = "write('"
81 template = header .. template .. footer
84 local r_include = "')\ninclude('%s')\nwrite('"
85 local r_i18n = "'..translate('%1','%2')..'"
86 local r_i18n2 = "'..translate('%1', '')..'"
87 local r_pexec = "'..(%s or '')..'"
88 local r_exec = "')\n%s\nwrite('"
90 -- Parse the expressions
91 for k,v in pairs(expr) do
95 re = r_include:format(sanitize(string.sub(v, 2)))
98 re = sanitize(v):gsub(":(.-) (.*)", r_i18n)
100 re = sanitize(v):gsub(":(.+)", r_i18n2)
103 re = r_pexec:format(v:sub(2))
105 re = r_exec:format(v)
107 template = template:gsub("<%%"..tostring(k).."%%>", re)
110 return loadstring(template)
113 -- Oldstyle render shortcut
114 function render(name, scope, ...)
115 scope = scope or getfenv(2)
116 local s, t = pcall(Template, name)
126 Template = luci.util.class()
128 -- Shared template cache to store templates in to avoid unnecessary reloading
132 -- Constructor - Reads and compiles the template on-demand
133 function Template.__init__(self, name)
134 if self.cache[name] then
135 self.template = self.cache[name]
140 -- Create a new namespace for this template
143 -- Copy over from general namespace
144 for k, v in pairs(viewns) do
148 -- If we have a cached template, skip compiling and loading
149 if self.template then
153 -- Enforce cache security
154 local cdir = compiledir .. "/" .. luci.sys.process.info("uid")
157 local sourcefile = viewdir .. "/" .. name .. ".htm"
158 local compiledfile = cdir .. "/" .. luci.http.urlencode(name) .. ".lua"
161 if compiler_mode == "file" then
162 local tplmt = luci.fs.mtime(sourcefile)
163 local commt = luci.fs.mtime(compiledfile)
165 if not luci.fs.mtime(cdir) then
166 luci.fs.mkdir(cdir, true)
167 luci.fs.chmod(luci.fs.dirname(cdir), "a+rxw")
170 -- Build if there is no compiled file or if compiled file is outdated
171 if ((commt == nil) and not (tplmt == nil))
172 or (not (commt == nil) and not (tplmt == nil) and commt < tplmt) then
174 source, err = luci.fs.readfile(sourcefile)
177 local compiled, err = compile(source)
179 luci.fs.writefile(compiledfile, luci.util.dump(compiled))
180 self.template = compiled
183 self.template, err = loadfile(compiledfile)
186 elseif compiler_mode == "none" then
187 self.template, err = loadfile(self.compiledfile)
189 elseif compiler_mode == "memory" then
191 source, err = luci.fs.readfile(sourcefile)
193 self.template, err = compile(source)
198 -- If we have no valid template throw error, otherwise cache the template
199 if not self.template then
202 self.cache[name] = self.template
207 -- Renders a template
208 function Template.render(self, scope)
209 scope = scope or getfenv(2)
211 -- Save old environment
212 local oldfenv = getfenv(self.template)
214 -- Put our predefined objects in the scope of the template
215 luci.util.resfenv(self.template)
216 luci.util.updfenv(self.template, scope)
217 luci.util.updfenv(self.template, self.viewns)
219 -- Now finally render the thing
223 setfenv(self.template, oldfenv)