modules/base/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
  27 local util = require "luci.util"
  28 local config = require "luci.config"
  29 local tparser = require "luci.template.parser"
  30
  31 local tostring, pairs, loadstring = tostring, pairs, loadstring
  32 local setmetatable, loadfile = setmetatable, loadfile
  33 local getfenv, setfenv, rawget = getfenv, setfenv, rawget
  34 local assert, type, error = assert, type, error
  35
  36 --- LuCI template library.
  37 module "luci.template"
  38
  39 config.template = config.template or {}
  40 viewdir = config.template.viewdir or util.libpath() .. "/view"
  41
  42
  43 -- Define the namespace for template modules
  44 context = util.threadlocal()
  45
  46 --- Render a certain template.
  47 -- @param name          Template name
  48 -- @param scope         Scope to assign to template (optional)
  49 function render(name, scope)
  50         return Template(name):render(scope or getfenv(2))
  51 end
  52
  53
  54 -- Template class
  55 Template = util.class()
  56
  57 -- Shared template cache to store templates in to avoid unnecessary reloading
  58 Template.cache = setmetatable({}, {__mode = "v"})
  59
  60
  61 -- Constructor - Reads and compiles the template on-demand
  62 function Template.__init__(self, name)
  63
  64         self.template = self.cache[name]
  65         self.name = name
  66
  67         -- Create a new namespace for this template
  68         self.viewns = context.viewns
  69
  70         -- If we have a cached template, skip compiling and loading
  71         if not self.template then
  72
  73                 -- Compile template
  74                 local err
  75                 local sourcefile = viewdir .. "/" .. name .. ".htm"
  76
  77                 self.template, _, err = tparser.parse(sourcefile)
  78
  79                 -- If we have no valid template throw error, otherwise cache the template
  80                 if not self.template then
  81                         error("Failed to load template '" .. name .. "'.\n" ..
  82                               "Error while parsing template '" .. sourcefile .. "':\n" ..
  83                               (err or "Unknown syntax error"))
  84                 else
  85                         self.cache[name] = self.template
  86                 end
  87         end
  88 end
  89
  90
  91 -- Renders a template
  92 function Template.render(self, scope)
  93         scope = scope or getfenv(2)
  94
  95         -- Put our predefined objects in the scope of the template
  96         setfenv(self.template, setmetatable({}, {__index =
  97                 function(tbl, key)
  98                         return rawget(tbl, key) or self.viewns[key] or scope[key]
  99                 end}))
 100
 101         -- Now finally render the thing
 102         local stat, err = util.copcall(self.template)
 103         if not stat then
 104                 error("Failed to execute template '" .. self.name .. "'.\n" ..
 105                       "A runtime error occured: " .. tostring(err or "(nil)"))
 106         end
 107 end