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     = function(...) return ffluci.model.uci.get(...) or "" end,
  56         controller = os.getenv("SCRIPT_NAME"),
  57         media      = ffluci.config.main.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(v:sub(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 source
 179                         source, err = ffluci.fs.readfile(sourcefile)
 180
 181                         if source then
 182                                 local compiled = compile(source)
 183                                 ffluci.fs.writefile(compiledfile, compiled)
 184                                 self.template, err = loadstring(compiled)
 185                         end
 186                 else
 187                         self.template, err = loadfile(compiledfile)
 188                 end
 189
 190         elseif compiler_mode == "none" then
 191                 self.template, err = loadfile(self.compiledfile)
 192
 193         elseif compiler_mode == "memory" then
 194                 local source
 195                 source, err = ffluci.fs.readfile(sourcefile)
 196                 if source then
 197                         self.template, err = loadstring(compile(source))
 198                 end
 199
 200         end
 201
 202         -- If we have no valid template throw error, otherwise cache the template
 203         if not self.template then
 204                 error(err)
 205         else
 206                 self.cache[name] = self.template
 207         end
 208 end
 209
 210
 211 -- Renders a template
 212 function Template.render(self, scope)
 213         scope = scope or getfenv(2)
 214
 215         -- Save old environment
 216         local oldfenv = getfenv(self.template)
 217
 218         -- Put our predefined objects in the scope of the template
 219         ffluci.util.resfenv(self.template)
 220         ffluci.util.updfenv(self.template, scope)
 221         ffluci.util.updfenv(self.template, self.viewns)
 222
 223         -- Now finally render the thing
 224         self.template()
 225
 226         -- Reset environment
 227         setfenv(self.template, oldfenv)
 228 end