17f36194fd3ac4bffa657d99302f47f322056837
[project/luci.git] / src / ffluci / template.lua
1 --[[
2 FFLuCI - Template Parser
3
4 Description:
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.
7
8 FileId: $Id$
9
10 License:
11 Copyright 2008 Steven Barth <steven@midlink.org>
12
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
16
17 http://www.apache.org/licenses/LICENSE-2.0
18
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.
24
25 ]]--
26 module("ffluci.template", package.seeall)
27
28 require("ffluci.config")
29 require("ffluci.util")
30 require("ffluci.fs")
31 require("ffluci.i18n")
32 require("ffluci.model.uci")
33
34 viewdir = ffluci.fs.dirname(ffluci.util.__file__()) .. "view/"
35
36
37 -- Compile modes:
38 -- none: Never compile, only use precompiled data from files
39 -- memory: Always compile, do not save compiled files, ignore precompiled
40 -- file: Compile on demand, save compiled files, update precompiled
41 compiler_mode = "memory"
42
43
44 -- This applies to compiler modes "always" and "smart"
45 --
46 -- Produce compiled lua code rather than lua sourcecode
47 -- WARNING: Increases template size heavily!!!
48 -- This produces the same bytecode as luac but does not have a strip option
49 compiler_enable_bytecode = false
50
51
52 -- Define the namespace for template modules
53 viewns = {
54 translate = ffluci.i18n.translate,
55 config = ffluci.model.uci.get,
56 controller = os.getenv("SCRIPT_NAME"),
57 media = ffluci.config.mediaurlbase,
58 write = io.write,
59 include = function(name) Template(name):render(getfenv(2)) end,
60 }
61
62 -- Compiles a given template into an executable Lua module
63 function compile(template)
64 -- Search all <% %> expressions (remember: Lua table indexes begin with #1)
65 local function expr_add(command)
66 table.insert(expr, command)
67 return "<%" .. tostring(#expr) .. "%>"
68 end
69
70 -- As "expr" should be local, we have to assign it to the "expr_add" scope
71 local expr = {}
72 ffluci.util.extfenv(expr_add, "expr", expr)
73
74 -- Save all expressiosn to table "expr"
75 template = template:gsub("<%%(.-)%%>", expr_add)
76
77 local function sanitize(s)
78 s = ffluci.util.escape(s)
79 s = ffluci.util.escape(s, "'")
80 s = ffluci.util.escape(s, "\n")
81 return s
82 end
83
84 -- Escape and sanitize all the template (all non-expressions)
85 template = sanitize(template)
86
87 -- Template module header/footer declaration
88 local header = "write('"
89 local footer = "')"
90
91 template = header .. template .. footer
92
93 -- Replacements
94 local r_include = "')\ninclude('%s')\nwrite('"
95 local r_i18n = "'..translate('%1','%2')..'"
96 local r_uci = "'..config('%1','%2','%3')..'"
97 local r_pexec = "'..%s..'"
98 local r_exec = "')\n%s\nwrite('"
99
100 -- Parse the expressions
101 for k,v in pairs(expr) do
102 local p = v:sub(1, 1)
103 local re = nil
104 if p == "+" then
105 re = r_include:format(sanitize(string.sub(v, 2)))
106 elseif p == ":" then
107 re = sanitize(v):gsub(":(.-) (.+)", r_i18n)
108 elseif p == "~" then
109 re = sanitize(v):gsub("~(.-)%.(.-)%.(.+)", r_uci)
110 elseif p == "=" then
111 re = r_pexec:format(string.sub(v, 2))
112 else
113 re = r_exec:format(v)
114 end
115 template = template:gsub("<%%"..tostring(k).."%%>", re)
116 end
117
118 if compiler_enable_bytecode then
119 tf = loadstring(template)
120 template = string.dump(tf)
121 end
122
123 return template
124 end
125
126 -- Oldstyle render shortcut
127 function render(name, scope, ...)
128 scope = scope or getfenv(2)
129 local s, t = pcall(Template, name)
130 if not s then
131 error(t)
132 else
133 t:render(scope, ...)
134 end
135 end
136
137
138 -- Template class
139 Template = ffluci.util.class()
140
141 -- Shared template cache to store templates in to avoid unnecessary reloading
142 Template.cache = {}
143
144
145 -- Constructor - Reads and compiles the template on-demand
146 function Template.__init__(self, name)
147 if self.cache[name] then
148 self.template = self.cache[name]
149 else
150 self.template = nil
151 end
152
153 -- Create a new namespace for this template
154 self.viewns = {}
155
156 -- Copy over from general namespace
157 for k, v in pairs(viewns) do
158 self.viewns[k] = v
159 end
160
161 -- If we have a cached template, skip compiling and loading
162 if self.template then
163 return
164 end
165
166 -- Compile and build
167 local sourcefile = viewdir .. name .. ".htm"
168 local compiledfile = viewdir .. name .. ".lua"
169 local err
170
171 if compiler_mode == "file" then
172 local tplmt = ffluci.fs.mtime(sourcefile)
173 local commt = ffluci.fs.mtime(compiledfile)
174
175 -- Build if there is no compiled file or if compiled file is outdated
176 if ((commt == nil) and not (tplmt == nil))
177 or (not (commt == nil) and not (tplmt == nil) and commt < tplmt) then
178 local compiled = compile(ffluci.fs.readfile(sourcefile))
179 ffluci.fs.writefile(compiledfile, compiled)
180 self.template, err = loadstring(compiled)
181 else
182 self.template, err = loadfile(compiledfile)
183 end
184
185 elseif compiler_mode == "none" then
186 self.template, err = loadfile(self.compiledfile)
187
188 elseif compiler_mode == "memory" then
189 self.template, err = loadstring(compile(ffluci.fs.readfile(sourcefile)))
190
191 end
192
193 -- If we have no valid template throw error, otherwise cache the template
194 if not self.template then
195 error(err)
196 else
197 self.cache[name] = self.template
198 end
199 end
200
201
202 -- Renders a template
203 function Template.render(self, scope)
204 scope = scope or getfenv(2)
205
206 -- Save old environment
207 local oldfenv = getfenv(self.template)
208
209 -- Put our predefined objects in the scope of the template
210 ffluci.util.resfenv(self.template)
211 ffluci.util.updfenv(self.template, scope)
212 ffluci.util.updfenv(self.template, self.viewns)
213
214 -- Now finally render the thing
215 self.template()
216
217 -- Reset environment
218 setfenv(self.template, oldfenv)
219 end