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"
38 -- Enforce cache security
39 compiledir = compiledir .. "/" .. luci.sys.process.info("uid")
43 -- none: Never compile, only use precompiled data from files
44 -- memory: Always compile, do not save compiled files, ignore precompiled
45 -- file: Compile on demand, save compiled files, update precompiled
46 compiler_mode = luci.config.template.compiler_mode or "memory"
49 -- Define the namespace for template modules
52 include = function(name) Template(name):render(getfenv(2)) end,
55 -- Compiles a given template into an executable Lua module
56 function compile(template)
57 -- Search all <% %> expressions (remember: Lua table indexes begin with #1)
58 local function expr_add(command)
59 table.insert(expr, command)
60 return "<%" .. tostring(#expr) .. "%>"
63 -- As "expr" should be local, we have to assign it to the "expr_add" scope
65 luci.util.extfenv(expr_add, "expr", expr)
67 -- Save all expressiosn to table "expr"
68 template = template:gsub("<%%(.-)%%>", expr_add)
70 local function sanitize(s)
71 s = luci.util.escape(s)
72 s = luci.util.escape(s, "'")
73 s = luci.util.escape(s, "\n")
77 -- Escape and sanitize all the template (all non-expressions)
78 template = sanitize(template)
80 -- Template module header/footer declaration
81 local header = "write('"
84 template = header .. template .. footer
87 local r_include = "')\ninclude('%s')\nwrite('"
88 local r_i18n = "'..translate('%1','%2')..'"
89 local r_pexec = "'..(%s or '')..'"
90 local r_exec = "')\n%s\nwrite('"
92 -- Parse the expressions
93 for k,v in pairs(expr) do
97 re = r_include:format(sanitize(string.sub(v, 2)))
99 re = sanitize(v):gsub(":(.-) (.+)", r_i18n)
101 re = r_pexec:format(v:sub(2))
103 re = r_exec:format(v)
105 template = template:gsub("<%%"..tostring(k).."%%>", re)
108 return loadstring(template)
111 -- Oldstyle render shortcut
112 function render(name, scope, ...)
113 scope = scope or getfenv(2)
114 local s, t = pcall(Template, name)
124 Template = luci.util.class()
126 -- Shared template cache to store templates in to avoid unnecessary reloading
130 -- Constructor - Reads and compiles the template on-demand
131 function Template.__init__(self, name)
132 if self.cache[name] then
133 self.template = self.cache[name]
138 -- Create a new namespace for this template
141 -- Copy over from general namespace
142 for k, v in pairs(viewns) do
146 -- If we have a cached template, skip compiling and loading
147 if self.template then
152 local sourcefile = viewdir .. "/" .. name .. ".htm"
153 local compiledfile = compiledir .. "/" .. luci.http.urlencode(name) .. ".lua"
156 if compiler_mode == "file" then
157 local tplmt = luci.fs.mtime(sourcefile)
158 local commt = luci.fs.mtime(compiledfile)
160 if not luci.fs.mtime(compiledir) then
161 luci.fs.mkdir(compiledir, true)
164 -- Build if there is no compiled file or if compiled file is outdated
165 if ((commt == nil) and not (tplmt == nil))
166 or (not (commt == nil) and not (tplmt == nil) and commt < tplmt) then
168 source, err = luci.fs.readfile(sourcefile)
171 local compiled, err = compile(source)
173 luci.fs.writefile(compiledfile, luci.util.dump(compiled))
174 self.template = compiled
177 self.template, err = loadfile(compiledfile)
180 elseif compiler_mode == "none" then
181 self.template, err = loadfile(self.compiledfile)
183 elseif compiler_mode == "memory" then
185 source, err = luci.fs.readfile(sourcefile)
187 self.template, err = compile(source)
192 -- If we have no valid template throw error, otherwise cache the template
193 if not self.template then
196 self.cache[name] = self.template
201 -- Renders a template
202 function Template.render(self, scope)
203 scope = scope or getfenv(2)
205 -- Save old environment
206 local oldfenv = getfenv(self.template)
208 -- Put our predefined objects in the scope of the template
209 luci.util.resfenv(self.template)
210 luci.util.updfenv(self.template, scope)
211 luci.util.updfenv(self.template, self.viewns)
213 -- Now finally render the thing
217 setfenv(self.template, oldfenv)