etlua.lua

-- from https://github.com/leafo/etlua
-- MIT license Copyright (C) 2014 by Leaf Corcoran
-- Modified by Jesse Rusak to remove debug library use

-- See link above for full usage. Examples from there:
--[[
  local etlua = require "etlua"
  local template = etlua.compile("my template <%= foo %>")
  template({foo = "something"})
]]

-- Other examples:
--[[
  Hello <%= name %>,
  Here are your items:
  <% for i, item_raw_html in pairs(items) do %>
   * <%- item_raw_html -%>
  <% end %> 
]]

local VERSION = "1.3.0-jder"
local insert, concat
do
  local _obj_0 = table
  insert, concat = _obj_0.insert, _obj_0.concat
end
local load, assert, type, error, tostring, tonumber, setmetatable
do
  local _obj_0 = _G
  load, assert, type, error, tostring, tonumber, setmetatable = _obj_0.load, _obj_0.assert, _obj_0.type, _obj_0.error, _obj_0.tostring, _obj_0.tonumber, _obj_0.setmetatable
end
local html_escape_entities = {
  ['&'] = '&amp;',
  ['<'] = '&lt;',
  ['>'] = '&gt;',
  ['"'] = '&quot;',
  ["'"] = '&#039;'
}
local html_escape
html_escape = function(str)
  return (str:gsub([=[["><'&]]=], html_escape_entities))
end
local get_line
get_line = function(str, line_num)
  for line in str:gmatch("([^\n]*)\n?") do
    if line_num == 1 then
      return line
    end
    line_num = line_num - 1
  end
end
local pos_to_line
pos_to_line = function(str, pos)
  local line = 1
  for _ in str:sub(1, pos):gmatch("\n") do
    line = line + 1
  end
  return line
end
local Compiler
do
  local _class_0
  local _base_0 = {
    html_escape = true,
    render = function(self)
      return table.concat(self.buffer)
    end,
    push = function(self, str, ...)
      local i = self.i + 1
      self.buffer[i] = str
      self.i = i
      if ... then
        return self:push(...)
      end
    end,
    header = function(self)
      return self:push("local _tostring, _escape, _b, _b_i = ...\n")
    end,
    footer = function(self)
      return self:push("return _b")
    end,
    increment = function(self)
      return self:push("_b_i = _b_i + 1\n")
    end,
    mark = function(self, pos)
      return self:push("--[[", tostring(pos), "]] ")
    end,
    assign = function(self, ...)
      self:push("_b[_b_i] = ", ...)
      if ... then
        return self:push("\n")
      end
    end,
    compile_chunks = function(self, chunks)
      self:header()
      for _index_0 = 1, #chunks do
        local chunk = chunks[_index_0]
        local t = type(chunk)
        if t == "table" then
          t = chunk[1]
        end
        local _exp_0 = t
        if "string" == _exp_0 then
          self:increment()
          self:assign(("%q"):format(chunk))
        elseif "code" == _exp_0 then
          self:mark(chunk[3])
          self:push(chunk[2], "\n")
        elseif "=" == _exp_0 or "-" == _exp_0 then
          self:increment()
          self:mark(chunk[3])
          self:assign()
          if t == "=" and self.html_escape then
            self:push("_escape(_tostring(", chunk[2], "))\n")
          else
            self:push("_tostring(", chunk[2], ")\n")
          end
        else
          error("unknown type " .. tostring(t))
        end
      end
      self:footer()
      return self:render()
    end
  }
  _base_0.__index = _base_0
  _class_0 = setmetatable({
    __init = function(self)
      self.buffer = { }
      self.i = 0
    end,
    __base = _base_0,
    __name = "Compiler"
  }, {
    __index = _base_0,
    __call = function(cls, ...)
      local _self_0 = setmetatable({}, _base_0)
      cls.__init(_self_0, ...)
      return _self_0
    end
  })
  _base_0.__class = _class_0
  Compiler = _class_0
end
local Parser
do
  local _class_0
  local _base_0 = {
    open_tag = "<%",
    close_tag = "%>",
    modifiers = "^[=-]",
    next_tag = function(self)
      local start, stop = self.str:find(self.open_tag, self.pos, true)
      if not (start) then
        self:push_raw(self.pos, #self.str)
        return false
      end
      if not (start == self.pos) then
        self:push_raw(self.pos, start - 1)
      end
      self.pos = stop + 1
      local modifier
      if self.str:match(self.modifiers, self.pos) then
        do
          local _with_0 = self.str:sub(self.pos, self.pos)
          self.pos = self.pos + 1
          modifier = _with_0
        end
      end
      local close_start, close_stop = self.str:find(self.close_tag, self.pos, true)
      if not (close_start) then
        return nil, self:error_for_pos(start, "failed to find closing tag")
      end
      while self:in_string(self.pos, close_start) do
        close_start, close_stop = self.str:find(self.close_tag, close_stop, true)
        if not (close_start) then
          return nil, self:error_for_pos(start, "failed to find string close")
        end
      end
      local trim_newline
      if "-" == self.str:sub(close_start - 1, close_start - 1) then
        close_start = close_start - 1
        trim_newline = true
      end
      self:push_code(modifier or "code", self.pos, close_start - 1)
      self.pos = close_stop + 1
      if trim_newline then
        do
          local match = self.str:match("^\n", self.pos)
          if match then
            self.pos = self.pos + #match
          end
        end
      end
      return true
    end,
    in_string = function(self, start, stop)
      local in_string = false
      local end_delim = nil
      local escape = false
      local pos = 0
      local skip_until = nil
      local chunk = self.str:sub(start, stop)
      for char in chunk:gmatch(".") do
        local _continue_0 = false
        repeat
          pos = pos + 1
          if skip_until then
            if pos <= skip_until then
              _continue_0 = true
              break
            end
            skip_until = nil
          end
          if end_delim then
            if end_delim == char and not escape then
              in_string = false
              end_delim = nil
            end
          else
            if char == "'" or char == '"' then
              end_delim = char
              in_string = true
            end
            if char == "[" then
              do
                local lstring = chunk:match("^%[=*%[", pos)
                if lstring then
                  local lstring_end = lstring:gsub("%[", "]")
                  local lstring_p1, lstring_p2 = chunk:find(lstring_end, pos, true)
                  if not (lstring_p1) then
                    return true
                  end
                  skip_until = lstring_p2
                end
              end
            end
          end
          escape = char == "\\"
          _continue_0 = true
        until true
        if not _continue_0 then
          break
        end
      end
      return in_string
    end,
    push_raw = function(self, start, stop)
      return insert(self.chunks, self.str:sub(start, stop))
    end,
    push_code = function(self, kind, start, stop)
      return insert(self.chunks, {
        kind,
        self.str:sub(start, stop),
        start
      })
    end,
    compile = function(self, str)
      local success, err = self:parse(str)
      if not (success) then
        return nil, err
      end
      local fn, env_holder
      env_holder = {}
      fn, err = self:load(self:chunks_to_lua(), nil, env_holder)
      if not (fn) then
        return nil, err
      end
      return function(env, ...)
        local buffer
        setmetatable(env_holder, {__index = function(t, k) return env[k] or _G[k] end, __newindex = env})
        buffer, err = self:run(fn, ...)
        if buffer then
          return concat(buffer)
        else
          return nil, err
        end
      end
    end,
    parse = function(self, str)
      self.str = str
      assert(type(self.str) == "string", "expecting string for parse")
      self.pos = 1
      self.chunks = { }
      while true do
        local found, err = self:next_tag()
        if err then
          return nil, err
        end
        if not (found) then
          break
        end
      end
      return true
    end,
    parse_error = function(self, err, code)
      local line_no, err_msg = err:match("%[.-%]:(%d+): (.*)$")
      line_no = tonumber(line_no)
      if not (line_no) then
        return 
      end
      local line = get_line(code, line_no)
      local source_pos = tonumber(line:match("^%-%-%[%[(%d+)%]%]"))
      if not (source_pos) then
        return 
      end
      return self:error_for_pos(source_pos, err_msg)
    end,
    error_for_pos = function(self, source_pos, err_msg)
      local source_line_no = pos_to_line(self.str, source_pos)
      local source_line = get_line(self.str, source_line_no)
      return tostring(err_msg) .. " [" .. tostring(source_line_no) .. "]: " .. tostring(source_line)
    end,
    load = function(self, code, name, env)
      if name == nil then
        name = "etlua"
      end
      local code_fn
      do
        local code_ref = code
        code_fn = function()
          do
            local ret = code_ref
            code_ref = nil
            return ret
          end
        end
      end
      local fn, err = load(code_fn, name, "t", env)
      if not (fn) then
        do
          local err_msg = self:parse_error(err, code)
          if err_msg then
            return nil, err_msg
          end
        end
        return nil, err
      end
      return fn
    end,
    run = function(self, fn, env, buffer, i, ...)
      if not (buffer) then
        buffer = { }
        i = 0
      end
      return fn(tostring, html_escape, buffer, i, ...)
    end,
    compile_to_lua = function(self, str, ...)
      local success, err = self:parse(str)
      if not (success) then
        return nil, err
      end
      return self:chunks_to_lua(...)
    end,
    chunks_to_lua = function(self, compiler_cls)
      if compiler_cls == nil then
        compiler_cls = Compiler
      end
      return compiler_cls():compile_chunks(self.chunks)
    end
  }
  _base_0.__index = _base_0
  _class_0 = setmetatable({
    __init = function() end,
    __base = _base_0,
    __name = "Parser"
  }, {
    __index = _base_0,
    __call = function(cls, ...)
      local _self_0 = setmetatable({}, _base_0)
      cls.__init(_self_0, ...)
      return _self_0
    end
  })
  _base_0.__class = _class_0
  Parser = _class_0
end
local compile
do
  local _base_0 = Parser()
  local _fn_0 = _base_0.compile
  compile = function(...)
    return _fn_0(_base_0, ...)
  end
end
local render
render = function(str, ...)
  local fn, err = compile(str)
  if fn then
    return fn(...)
  else
    return nil, err
  end
end
return {
  compile = compile,
  render = render,
  Parser = Parser,
  Compiler = Compiler,
  _version = VERSION
}