libs/web/luasrc/template.lua

   1 --[[
   2 LuCI - 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("luci.template", package.seeall)
  27
  28 require("luci.config")
  29 require("luci.util")
  30 require("luci.fs")
  31 require("luci.http")
  32
  33 luci.config.template = luci.config.template or {}
  34
  35 viewdir    = luci.config.template.viewdir or luci.sys.libpath() .. "/view"
  36 compiledir = luci.config.template.compiledir or luci.sys.libpath() .. "/view"
  37
  38
  39 -- Compile modes:
  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"
  44
  45
  46 -- Define the namespace for template modules
  47 context = luci.util.threadlocal()
  48
  49 viewns = {
  50         include    = function(name) Template(name):render(getfenv(2)) end,
  51 }
  52
  53 -- Compiles a given template into an executable Lua module
  54 function compile(template)
  55         -- Search all <% %> expressions (remember: Lua table indexes begin with #1)
  56         local function expr_add(command)
  57                 table.insert(expr, command)
  58                 return "<%" .. tostring(#expr) .. "%>"
  59         end
  60
  61         -- As "expr" should be local, we have to assign it to the "expr_add" scope
  62         local expr = {}
  63         luci.util.extfenv(expr_add, "expr", expr)
  64
  65         -- Save all expressiosn to table "expr"
  66         template = template:gsub("<%%(.-)%%>", expr_add)
  67
  68         local function sanitize(s)
  69                 s = luci.util.escape(s)
  70                 s = luci.util.escape(s, "'")
  71                 s = luci.util.escape(s, "\n")
  72                 return s
  73         end
  74
  75         -- Escape and sanitize all the template (all non-expressions)
  76         template = sanitize(template)
  77
  78         -- Template module header/footer declaration
  79         local header = "write('"
  80         local footer = "')"
  81
  82         template = header .. template .. footer
  83
  84         -- Replacements
  85         local r_include = "')\ninclude('%s')\nwrite('"
  86         local r_i18n    = "'..translate('%1','%2')..'"
  87         local r_i18n2    = "'..translate('%1', '')..'"
  88         local r_pexec   = "'..(%s or '')..'"
  89         local r_exec    = "')\n%s\nwrite('"
  90
  91         -- Parse the expressions
  92         for k,v in pairs(expr) do
  93                 local p = v:sub(1, 1)
  94                 local re = nil
  95                 if p == "+" then
  96                         re = r_include:format(sanitize(string.sub(v, 2)))
  97                 elseif p == ":" then
  98                         if v:find(" ") then
  99                                 re = sanitize(v):gsub(":(.-) (.*)", r_i18n)
 100                         else
 101                                 re = sanitize(v):gsub(":(.+)", r_i18n2)
 102                         end
 103                 elseif p == "=" then
 104                         re = r_pexec:format(v:sub(2))
 105                 elseif p == "#" then
 106                         re = ""
 107                 else
 108                         re = r_exec:format(v)
 109                 end
 110                 template = template:gsub("<%%"..tostring(k).."%%>", re)
 111         end
 112
 113         return loadstring(template)
 114 end
 115
 116 -- Oldstyle render shortcut
 117 function render(name, scope, ...)
 118         scope = scope or getfenv(2)
 119         local s, t = luci.util.copcall(Template, name)
 120         if not s then
 121                 error(t)
 122         else
 123                 t:render(scope, ...)
 124         end
 125 end
 126
 127
 128 -- Template class
 129 Template = luci.util.class()
 130
 131 -- Shared template cache to store templates in to avoid unnecessary reloading
 132 Template.cache = {}
 133 setmetatable(Template.cache, {__mode = "v"})
 134
 135
 136 -- Constructor - Reads and compiles the template on-demand
 137 function Template.__init__(self, name)
 138         self.template = self.cache[name]
 139
 140         -- Create a new namespace for this template
 141         self.viewns = {}
 142
 143         -- Copy over from general namespace
 144         luci.util.update(self.viewns, viewns)
 145         if context.viewns then
 146                 luci.util.update(self.viewns, context.viewns)
 147         end
 148
 149         -- If we have a cached template, skip compiling and loading
 150         if self.template then
 151                 return
 152         end
 153
 154         -- Enforce cache security
 155         local cdir = compiledir .. "/" .. luci.sys.process.info("uid")
 156
 157         -- Compile and build
 158         local sourcefile   = viewdir    .. "/" .. name .. ".htm"
 159         local compiledfile = cdir .. "/" .. luci.http.urlencode(name) .. ".lua"
 160         local err
 161
 162         if compiler_mode == "file" then
 163                 local tplmt = luci.fs.mtime(sourcefile)
 164                 local commt = luci.fs.mtime(compiledfile)
 165
 166                 if not luci.fs.mtime(cdir) then
 167                         luci.fs.mkdir(cdir, true)
 168                         luci.fs.chmod(luci.fs.dirname(cdir), "a+rxw")
 169                 end
 170
 171                 -- Build if there is no compiled file or if compiled file is outdated
 172                 if ((commt == nil) and not (tplmt == nil))
 173                 or (not (commt == nil) and not (tplmt == nil) and commt < tplmt) then
 174                         local source
 175                         source, err = luci.fs.readfile(sourcefile)
 176
 177                         if source then
 178                                 local compiled, err = compile(source)
 179
 180                                 luci.fs.writefile(compiledfile, luci.util.dump(compiled))
 181                                 self.template = compiled
 182                         end
 183                 else
 184                         self.template, err = loadfile(compiledfile)
 185                 end
 186
 187         elseif compiler_mode == "none" then
 188                 self.template, err = loadfile(self.compiledfile)
 189
 190         elseif compiler_mode == "memory" then
 191                 local source
 192                 source, err = luci.fs.readfile(sourcefile)
 193                 if source then
 194                         self.template, err = compile(source)
 195                 end
 196
 197         end
 198
 199         -- If we have no valid template throw error, otherwise cache the template
 200         if not self.template then
 201                 error(err)
 202         else
 203                 self.cache[name] = self.template
 204         end
 205 end
 206
 207
 208 -- Renders a template
 209 function Template.render(self, scope)
 210         scope = scope or getfenv(2)
 211
 212         -- Save old environment
 213         local oldfenv = getfenv(self.template)
 214
 215         -- Put our predefined objects in the scope of the template
 216         luci.util.resfenv(self.template)
 217         luci.util.updfenv(self.template, scope)
 218         luci.util.updfenv(self.template, self.viewns)
 219
 220         -- Now finally render the thing
 221         self.template()
 222
 223         -- Reset environment
 224         setfenv(self.template, oldfenv)
 225 end