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