2 FFLuCI - Template Parser
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("ffluci.template", package.seeall)
28 require("ffluci.config")
29 require("ffluci.util")
31 require("ffluci.i18n")
32 require("ffluci.http")
33 require("ffluci.model.uci")
35 viewdir = ffluci.config.path .. "/view/"
39 -- none: Never compile, only use precompiled data from files
40 -- memory: Always compile, do not save compiled files, ignore precompiled
41 -- file: Compile on demand, save compiled files, update precompiled
42 compiler_mode = "memory"
45 -- This applies to compiler modes "always" and "smart"
47 -- Produce compiled lua code rather than lua sourcecode
48 -- WARNING: Increases template size heavily!!!
49 -- This produces the same bytecode as luac but does not have a strip option
50 compiler_enable_bytecode = false
53 -- Define the namespace for template modules
55 translate = ffluci.i18n.translate,
56 config = function(...) return ffluci.model.uci.get(...) or "" end,
57 controller = ffluci.http.script_name(),
58 media = ffluci.config.main.mediaurlbase,
60 include = function(name) Template(name):render(getfenv(2)) end,
63 -- Compiles a given template into an executable Lua module
64 function compile(template)
65 -- Search all <% %> expressions (remember: Lua table indexes begin with #1)
66 local function expr_add(command)
67 table.insert(expr, command)
68 return "<%" .. tostring(#expr) .. "%>"
71 -- As "expr" should be local, we have to assign it to the "expr_add" scope
73 ffluci.util.extfenv(expr_add, "expr", expr)
75 -- Save all expressiosn to table "expr"
76 template = template:gsub("<%%(.-)%%>", expr_add)
78 local function sanitize(s)
79 s = ffluci.util.escape(s)
80 s = ffluci.util.escape(s, "'")
81 s = ffluci.util.escape(s, "\n")
85 -- Escape and sanitize all the template (all non-expressions)
86 template = sanitize(template)
88 -- Template module header/footer declaration
89 local header = "write('"
92 template = header .. template .. footer
95 local r_include = "')\ninclude('%s')\nwrite('"
96 local r_i18n = "'..translate('%1','%2')..'"
97 local r_uci = "'..config('%1','%2','%3')..'"
98 local r_pexec = "'..%s..'"
99 local r_exec = "')\n%s\nwrite('"
101 -- Parse the expressions
102 for k,v in pairs(expr) do
103 local p = v:sub(1, 1)
106 re = r_include:format(sanitize(string.sub(v, 2)))
108 re = sanitize(v):gsub(":(.-) (.+)", r_i18n)
110 re = sanitize(v):gsub("~(.-)%.(.-)%.(.+)", r_uci)
112 re = r_pexec:format(v:sub(2))
114 re = r_exec:format(v)
116 template = template:gsub("<%%"..tostring(k).."%%>", re)
119 if compiler_enable_bytecode then
120 tf = loadstring(template)
121 template = string.dump(tf)
127 -- Oldstyle render shortcut
128 function render(name, scope, ...)
129 scope = scope or getfenv(2)
130 local s, t = pcall(Template, name)
140 Template = ffluci.util.class()
142 -- Shared template cache to store templates in to avoid unnecessary reloading
146 -- Constructor - Reads and compiles the template on-demand
147 function Template.__init__(self, name)
148 if self.cache[name] then
149 self.template = self.cache[name]
154 -- Create a new namespace for this template
157 -- Copy over from general namespace
158 for k, v in pairs(viewns) do
162 -- If we have a cached template, skip compiling and loading
163 if self.template then
168 local sourcefile = viewdir .. name .. ".htm"
169 local compiledfile = viewdir .. name .. ".lua"
172 if compiler_mode == "file" then
173 local tplmt = ffluci.fs.mtime(sourcefile)
174 local commt = ffluci.fs.mtime(compiledfile)
176 -- Build if there is no compiled file or if compiled file is outdated
177 if ((commt == nil) and not (tplmt == nil))
178 or (not (commt == nil) and not (tplmt == nil) and commt < tplmt) then
180 source, err = ffluci.fs.readfile(sourcefile)
183 local compiled = compile(source)
184 ffluci.fs.writefile(compiledfile, compiled)
185 self.template, err = loadstring(compiled)
188 self.template, err = loadfile(compiledfile)
191 elseif compiler_mode == "none" then
192 self.template, err = loadfile(self.compiledfile)
194 elseif compiler_mode == "memory" then
196 source, err = ffluci.fs.readfile(sourcefile)
198 self.template, err = loadstring(compile(source))
203 -- If we have no valid template throw error, otherwise cache the template
204 if not self.template then
207 self.cache[name] = self.template
212 -- Renders a template
213 function Template.render(self, scope)
214 scope = scope or getfenv(2)
216 -- Save old environment
217 local oldfenv = getfenv(self.template)
219 -- Put our predefined objects in the scope of the template
220 ffluci.util.resfenv(self.template)
221 ffluci.util.updfenv(self.template, scope)
222 ffluci.util.updfenv(self.template, self.viewns)
224 -- Now finally render the thing
228 setfenv(self.template, oldfenv)