1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
--[[
FFLuCI - Template Parser
Description:
A template parser supporting includes, translations, Lua code blocks
and more. It can be used either as a compiler or as an interpreter.
FileId: $Id$
License:
Copyright 2008 Steven Barth <steven@midlink.org>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
]]--
module("ffluci.template", package.seeall)
require("ffluci.config")
require("ffluci.util")
require("ffluci.fs")
require("ffluci.i18n")
require("ffluci.model.uci")
viewdir = ffluci.fs.dirname(ffluci.util.__file__()) .. "view/"
-- Compile modes:
-- none: Never compile, only render precompiled
-- memory: Always compile, do not save compiled files, ignore precompiled
-- always: Same as "memory" but also saves compiled files
-- smart: Compile on demand, save compiled files, update precompiled
compiler_mode = "memory"
-- This applies to compiler modes "always" and "smart"
--
-- Produce compiled lua code rather than lua sourcecode
-- WARNING: Increases template size heavily!!!
-- This produces the same bytecode as luac but does not have a strip option
compiler_enable_bytecode = false
-- Define the namespace for template modules
viewns = {
translate = ffluci.i18n.translate,
config = ffluci.model.uci.get,
controller = os.getenv("SCRIPT_NAME"),
media = ffluci.config.mediaurlbase,
include = function(name) return render(name, getfenv(2)) end,
write = io.write
}
-- Compiles and builds a given template
function build(template, compiled)
local template = compile(ffluci.fs.readfile(template))
if compiled then
ffluci.fs.writefile(compiled, template)
end
return template
end
-- Compiles a given template into an executable Lua module
function compile(template)
-- Search all <% %> expressions (remember: Lua table indexes begin with #1)
local function expr_add(command)
table.insert(expr, command)
return "<%" .. tostring(#expr) .. "%>"
end
-- As "expr" should be local, we have to assign it to the "expr_add" scope
local expr = {}
ffluci.util.extfenv(expr_add, "expr", expr)
-- Save all expressiosn to table "expr"
template = template:gsub("<%%(.-)%%>", expr_add)
local function sanitize(s)
s = ffluci.util.escape(s)
s = ffluci.util.escape(s, "'")
s = ffluci.util.escape(s, "\n")
return s
end
-- Escape and sanitize all the template (all non-expressions)
template = sanitize(template)
-- Template module header/footer declaration
local header = "write('"
local footer = "')"
template = header .. template .. footer
-- Replacements
local r_include = "')\ninclude('%s')\nwrite('"
local r_i18n = "'..translate('%1','%2')..'"
local r_uci = "'..config('%1','%2','%3')..'"
local r_pexec = "'..%s..'"
local r_exec = "')\n%s\nwrite('"
-- Parse the expressions
for k,v in pairs(expr) do
local p = v:sub(1, 1)
local re = nil
if p == "+" then
re = r_include:format(sanitize(string.sub(v, 2)))
elseif p == ":" then
re = sanitize(v):gsub(":(.-) (.+)", r_i18n)
elseif p == "~" then
re = sanitize(v):gsub("~(.-)%.(.-)%.(.+)", r_uci)
elseif p == "=" then
re = r_pexec:format(string.sub(v, 2))
else
re = r_exec:format(v)
end
template = template:gsub("<%%"..tostring(k).."%%>", re)
end
if compiler_enable_bytecode then
tf = loadstring(template)
template = string.dump(tf)
end
return template
end
-- Returns and builds the template for "name" depending on the compiler mode
function get(name)
local templatefile = viewdir .. name .. ".htm"
local compiledfile = viewdir .. name .. ".lua"
local template = nil
if compiler_mode == "smart" then
local tplmt = ffluci.fs.mtime(templatefile)
local commt = ffluci.fs.mtime(compiledfile)
-- Build if there is no compiled file or if compiled file is outdated
if ((commt == nil) and not (tplmt == nil))
or (not (commt == nil) and not (tplmt == nil) and commt < tplmt) then
template = loadstring(build(templatefile, compiledfile))
else
template = loadfile(compiledfile)
end
elseif compiler_mode == "none" then
template = loadfile(compiledfile)
elseif compiler_mode == "memory" then
template = loadstring(build(templatefile))
elseif compiler_mode == "always" then
template = loadstring(build(templatefile, compiledfile))
else
error("Invalid compiler mode: " .. compiler_mode)
end
return template or error("Unable to load template: " .. name)
end
-- Renders a template
function render(name, scope)
scope = scope or getfenv(2)
-- Our template module
local view = get(name)
-- Put our predefined objects in the scope of the template
ffluci.util.updfenv(view, scope)
ffluci.util.updfenv(view, viewns)
-- Now finally render the thing
return view()
end
|
