rspamd/contrib/lua-lupa/lupa.lua

-- Copyright 2015-2020 Mitchell. See LICENSE.
-- Sponsored by the Library of the University of Antwerp.
-- Contributions from Ana Balan.
-- Lupa templating engine.

--[[ This comment is for LuaDoc.
---
-- Lupa is a Jinja2 template engine implementation written in Lua and supports
-- Lua syntax within tags and variables.
module('lupa')]]
local M = {}

local lpeg = require('lpeg')
lpeg.locale(lpeg)
local space, newline = lpeg.space, lpeg.P('\r')^-1 * '\n'
local P, S, V = lpeg.P, lpeg.S, lpeg.V
local C, Cc, Cg, Cp, Ct = lpeg.C, lpeg.Cc, lpeg.Cg, lpeg.Cp, lpeg.Ct

---
-- Lupa's expression filters.
-- @class table
-- @name filters
M.filters = {}

---
-- Lupa's value tests.
-- @class table
-- @name tests
M.tests = {}

---
-- Lupa's template loaders.
-- @class table
-- @name loaders
M.loaders = {}

-- Lua version compatibility.
if _VERSION == 'Lua 5.1' then
  function load(ld, source, mode, env)
    local f, err = loadstring(ld)
    if f and env then return setfenv(f, env) end
    return f, err
  end
  table.unpack = unpack
end

local newline_sequence, keep_trailing_newline, autoescape = '\n', false, false
local loader

-- Creates and returns a token pattern with token name *name* and pattern
-- *patt*.
-- The returned pattern captures three values: the token's position and name,
-- and either a string value or table of capture values.
-- Tokens are used to construct an Abstract Syntax Tree (AST) for a template.
-- @param name The name of the token.
-- @param patt The pattern to match. It must contain only one capture: either a
--   string or table of captures.
-- @see evaluate
local function token(name, patt) return Cp() * Cc(name) * patt end

-- Returns an LPeg pattern that immediately raises an error with message
-- *errmsg* for invalid syntax when parsing a template.
-- @param errmsg The error message to raise an error with.
local function lpeg_error(errmsg)
  return P(function(input, index)
    input = input:sub(1, index)
    local _, line_num = input:gsub('\n', '')
    local col_num = #input:match('[^\n]*$')
    error(string.format('Parse Error in file "%s" on line %d, column %d: %s',
                        M._FILENAME, line_num + 1, col_num, errmsg), 0)
  end)
end

---
-- Configures the basic delimiters and options for templates.
-- This function then regenerates the grammar for parsing templates.
-- Note: this function cannot be used iteratively to configure Lupa options.
-- Any options not provided are reset to their default values.
-- @param ts The tag start delimiter. The default value is '{%'.
-- @param te The tag end delimiter. The default value is '%}'.
-- @param vs The variable start delimiter. The default value is '{{'.
-- @param ve The variable end delimiter. The default value is '}}'.
-- @param cs The comment start delimiter. The default value is '{#'.
-- @param ce The comment end delimiter. The default value is '#}'.
-- @param options Optional set of options for templates:
--
--   * `trim_blocks`: Trim the first newline after blocks.
--   * `lstrip_blocks`: Strip line-leading whitespace in front of tags.
--   * `newline_sequence`: The end-of-line character to use.
--   * `keep_trailing_newline`: Whether or not to keep a newline at the end of
--     a template.
--   * `autoescape`: Whether or not to autoescape HTML entities. May be a
--     function that accepts the template's filename as an argument and returns
--     a boolean.
--   * `loader`: Function that receives a template name to load and returns the
--     path to that template.
-- @name configure
function M.configure(ts, te, vs, ve, cs, ce, options)
  if type(ts) == 'table' then options, ts = ts, nil end
  if not ts then ts = '{%' end
  if not te then te = '%}' end
  if not vs then vs = '{{' end
  if not ve then ve = '}}' end
  if not cs then cs = '{#' end
  if not ce then ce = '#}' end

  -- Tokens for whitespace control.
  local lstrip = token('lstrip', C('-')) + '+' -- '+' is handled by grammar
  local rstrip = token('rstrip', -(P(te) + ve + ce) * C('-'))

  -- Configure delimiters, including whitespace control.
  local tag_start = P(ts) * lstrip^-1 * space^0
  local tag_end = space^0 * rstrip^-1 * P(te)
  local variable_start = P(vs) * lstrip^-1 * space^0
  local variable_end = space^0 * rstrip^-1 * P(ve)
  local comment_start = P(cs) * lstrip^-1 * space^0
  local comment_end = space^0 * rstrip^-1 * P(ce)
  if options and options.trim_blocks then
    -- Consider whitespace, including a newline, immediately following a tag as
    -- part of that tag so it is not captured as plain text. Basically, strip
    -- the trailing newline from tags.
    tag_end = tag_end * S(' \t')^0 * newline^-1
    comment_end = comment_end * S(' \t')^0 * newline^-1
  end

  -- Error messages.
  local variable_end_error = lpeg_error('"'..ve..'" expected')
  local comment_end_error = lpeg_error('"'..ce..'" expected')
  local tag_end_error = lpeg_error('"'..te..'" expected')
  local endraw_error = lpeg_error('additional tag or "'..ts..' endraw '..te..
                                  '" expected')
  local expr_error = lpeg_error('expression expected')
  local endblock_error = lpeg_error('additional tag or "'..ts..' endblock '..
                                    te..'" expected')
  local endfor_error = lpeg_error('additional tag or "'..ts..' endfor '..te..
                                  '" expected')
  local endif_error = lpeg_error('additional tag or "'..ts..' endif '..te..
                                 '" expected')
  local endmacro_error = lpeg_error('additional tag or "'..ts..' endmacro '..
                                    te..'" expected')
  local endcall_error = lpeg_error('additional tag or "'..ts..' endcall '..te..
                                   '" expected')
  local endfilter_error = lpeg_error('additional tag or "'..ts..' endfilter '..
                                     te..'" expected')
  local tag_error = lpeg_error('unknown or unexpected tag')
  local main_error = lpeg_error('unexpected character; text or tag expected')

  -- Grammar.
  M.grammar = Ct(P{
    -- Utility patterns used by tokens.
    entity_start = tag_start + variable_start + comment_start,
    any_text = (1 - V('entity_start'))^1,
    -- Allow '{{' by default in expression text since it is valid in Lua.
    expr_text = (1 - tag_end - tag_start - comment_start)^1,
    -- When `options.lstrip_blocks` is enabled, ignore leading whitespace
    -- immediately followed by a tag (as long as '+' is not present) so that
    -- whitespace not captured as plain text. Basically, strip leading spaces
    -- from tags.
    line_text = (1 - newline - V('entity_start'))^1,
    lstrip_entity_start = -P(vs) * (P(ts) + cs) * -P('+'),
    lstrip_space = S(' \t')^1 * #V('lstrip_entity_start'),
    text_lines = V('line_text') * (newline * -(S(' \t')^0 * V('lstrip_entity_start')) * V('line_text'))^0 * newline^-1 + newline,

    -- Plain text.
    text = (not options or not options.lstrip_blocks) and
           token('text', C(V('any_text'))) or
           V('lstrip_space') + token('text', C(V('text_lines'))),

    -- Variables: {{ expr }}.
    lua_table = '{' * ((1 - S('{}')) + V('lua_table'))^0 * '}',
    variable = variable_start *
               token('variable', C((V('lua_table') + (1 - variable_end))^0)) *
               (variable_end + variable_end_error),

    -- Filters: handled in variable evaluation.

    -- Tests: handled in control structure expression evaluation.

    -- Comments: {# comment #}.
    comment = comment_start * (1 - comment_end)^0 * (comment_end + comment_end_error),

    -- Whitespace control: handled in tag/variable/comment start/end.

    -- Escaping: {% raw %} body {% endraw %}.
    raw_block = tag_start * 'raw' * (tag_end + tag_end_error) *
                token('text', C((1 - (tag_start * 'endraw' * tag_end))^0)) *
                (tag_start * 'endraw' * tag_end + endraw_error),

    -- Note: line statements are not supported since this grammer cannot parse
    -- Lua itself.

    -- Template inheritence.
    -- {% block ... %} body {% endblock %}
    block_block = tag_start * 'block' * space^1 * token('block', Ct((Cg(V('expr_text'), 'expression') + expr_error) * (tag_end + tag_end_error) *
                  V('body')^-1)) *
                  (tag_start * 'endblock' * tag_end + endblock_error),
    -- {% extends ... %}
    extends_tag = tag_start * 'extends' * space^1 * token('extends', C(V('expr_text')) + expr_error) * (tag_end + tag_end_error),
    -- Super blocks are handled in variables.
    -- Note: named block end tags are not supported since keeping track of that
    -- state information is difficult.
    -- Note: block nesting and scope is not applicable since blocks always have
    -- access to scoped variables in this implementation.

    -- Control Structures.
    -- {% for expr %} body {% else %} body {% endfor %}
    for_block = tag_start * 'for' * space^1 * token('for', Ct((Cg(V('expr_text'), 'expression') + expr_error) * (tag_end + tag_end_error) *
                V('body')^-1 *
                Cg(Ct(tag_start * 'else' * tag_end *
                      V('body')^-1), 'else')^-1)) *
                (tag_start * 'endfor' * tag_end + endfor_error),
    -- {% if expr %} body {% elseif expr %} body {% else %} body {% endif %}
    if_block = tag_start * 'if' * space^1 * token('if', Ct((Cg(V('expr_text'), 'expression') + expr_error) * (tag_end + tag_end_error) *
               V('body')^-1 *
               Cg(Ct(Ct(tag_start * 'elseif' * space^1 * (Cg(V('expr_text'), 'expression') + expr_error) * (tag_end + tag_end_error) *
                       V('body')^-1)^1), 'elseif')^-1 *
               Cg(Ct(tag_start * 'else' * tag_end *
                       V('body')^-1), 'else')^-1)) *
               (tag_start * 'endif' * tag_end + endif_error),
    -- {% macro expr %} body {% endmacro %}
    macro_block = tag_start * 'macro' * space^1 * token('macro', Ct((Cg(V('expr_text'), 'expression') + expr_error) * (tag_end + tag_end_error) *
                  V('body')^-1)) *
                  (tag_start * 'endmacro' * tag_end + endmacro_error),
    -- {% call expr %} body {% endcall %}
    call_block = tag_start * 'call' * (space^1 + #P('(')) * token('call', Ct((Cg(V('expr_text'), 'expression') + expr_error) * (tag_end + tag_end_error) *
                  V('body')^-1)) *
                  (tag_start * 'endcall' * tag_end + endcall_error),
    -- {% filter expr %} body {% endfilter %}
    filter_block = tag_start * 'filter' * space^1 * token('filter', Ct((Cg(V('expr_text'), 'expression') + expr_error) * (tag_end + tag_end_error) *
                   V('body')^-1)) *
                   (tag_start * 'endfilter' * tag_end + endfilter_error),
    -- {% set ... %}
    set_tag = tag_start * 'set' * space^1 * token('set', C(V('expr_text')) + expr_error) * (tag_end + tag_end_error),
    -- {% include ... %}
    include_tag = tag_start * 'include' * space^1 * token('include', C(V('expr_text')) + expr_error) * (tag_end + tag_end_error),
    -- {% import ... %}
    import_tag = tag_start * 'import' * space^1 * token('import', C(V('expr_text')) + expr_error) * (tag_end + tag_end_error),

    -- Note: i18n is not supported since it is out of scope for this
    -- implementation.

    -- Expression statement: {% do ... %}.
    do_tag = tag_start * 'do' * space^1 * token('do', C(V('expr_text')) + expr_error) * (tag_end + tag_end_error),

    -- Note: loop controls are not supported since that would require jumping
    -- between "scopes" (e.g. from within an "if" block to outside that "if"
    -- block's parent "for" block when coming across a {% break %} tag).

    -- Note: with statement is not supported since it is out of scope for this
    -- implementation.

    -- Note: autoescape is not supported since it is out of scope for this
    -- implementation.

    -- Any valid blocks of text or tags.
    body = (V('text') + V('variable') + V('comment') + V('raw_block') +
            V('block_block') + V('extends_tag') + V('for_block') +
            V('if_block') + V('macro_block') + V('call_block') +
            V('filter_block') + V('set_tag') + V('include_tag') +
            V('import_tag') + V('do_tag'))^0,

    -- Main pattern.
    V('body') * (-1 + tag_start * tag_error + main_error),
  })

  -- Other options.
  if options and options.newline_sequence then
    assert(options.newline_sequence:find('^\r?\n$'),
           'options.newline_sequence must be "\r\n" or "\n"')
    newline_sequence = options.newline_sequence
  else
    newline_sequence = '\n'
  end
  if options and options.keep_trailing_newline then
    keep_trailing_newline = options.keep_trailing_newline
  else
    keep_trailing_newline = false
  end
  if options and options.autoescape then
    autoescape = options.autoescape
  else
    autoescape = false
  end
  if options and options.loader then
    assert(type(options.loader) == 'function',
           'options.loader must be a function that returns a filename')
    loader = options.loader
  else
    loader = M.loaders.filesystem()
  end
end

-- Wraps Lua's `assert()` in template environment *env* such that, when called
-- in conjunction with another Lua function that produces an error message (e.g.
-- `load()` and `pcall()`), that error message's context (source and line
-- number) is replaced by the template's context.
-- This results in Lua's error messages pointing to a template position rather
-- than this library's source code.
-- @param env The environment for the currently running template. It must have
--   a `_SOURCE` field with the template's source text and a `_POSITION` field
--   with the current position of expansion.
-- @param ... Arguments to Lua's `assert()`.
local function env_assert(env, ...)
  if not select(1, ...) then
    local input = env._LUPASOURCE:sub(1, env._LUPAPOSITION)
    local _, line_num = input:gsub('\n', '')
    local col_num = #input:match('[^\n]*$')
    local errmsg = select(2, ...)
    errmsg = errmsg:match(':%d+: (.*)$') or errmsg -- reformat if necessary
    error(string.format('Runtime Error in file "%s" on line %d, column %d: %s',
                        env._LUPAFILENAME, line_num + 1, col_num, errmsg), 0)
  end
  return ...
end

-- Returns a generator that returns the position and filter in a list of
-- filters, taking into account '|'s that may be within filter arguments.
-- @usage for pos, filter in each_filter('foo|join("|")|bar') do ... end
local function each_filter(s)
  local init = 1
  return function(s)
    local pos, filter, e = s:match('^%s*()([^|(]+%b()[^|]*)|?()', init)
    if not pos then pos, filter, e = s:match('()([^|]+)|?()', init) end
    init = e
    return pos, filter
  end, s
end

-- Evaluates template variable *expression* subject to template environment
-- *env*, applying any filters given in *expression*.
-- @param expression The string expression to evaluate.
-- @param env The environment to evaluate the expression in.
local function eval(expression, env)
  local expr, pos, filters = expression:match('^([^|]*)|?()(.-)$')
  -- Evaluate base expression.
  local f = env_assert(env, load('return '..expr, nil, nil, env))
  local result = select(2, env_assert(env, pcall(f)))
  -- Apply any filters.
  local results, multiple_results = nil, false
  local p = env._LUPAPOSITION + pos - 1 -- mark position at first filter
  for pos, filter in each_filter(filters) do
    env._LUPAPOSITION = p + pos - 1 -- update position for error messages
    local name, params = filter:match('^%s*([%w_]+)%(?(.-)%)?%s*$')
    f = M.filters[name]
    env_assert(env, f, 'unknown filter "'..name..'"')
    local args = env_assert(env, load('return {'..params..'}', nil, nil, env),
                            'invalid filter parameter(s) for "'..name..'"')()
    if not multiple_results then
      results = {select(2,
                        env_assert(env, pcall(f, result, table.unpack(args))))}
    else
      for i = 1, #results do table.insert(args, i, results[i]) end
      results = {select(2, env_assert(env, pcall(f, table.unpack(args))))}
    end
    result, multiple_results = results[1], #results > 1
  end
  if multiple_results then return table.unpack(results) end
  return result
end

local iterate

-- Iterates over *ast*, a collection of tokens from a portion of a template's
-- Abstract Syntax Tree (AST), evaluating any expressions in template
-- environment *env*, and returns a concatenation of the results.
-- @param ast A template's AST or portion of its AST (e.g. portion inside a
--   'for' control structure).
-- @param env Environment to evaluate any expressions in.
local function evaluate(ast, env)
  local chunks = {}
  local extends -- text of a parent template
  local rstrip -- flag for stripping leading whitespace of next token
  for i = 1, #ast, 3 do
    local pos, token, block = ast[i], ast[i + 1], ast[i + 2]
    env._LUPAPOSITION = pos
    if token == 'text' then
      chunks[#chunks + 1] = block
    elseif token == 'variable' then
      local value = eval(block, env)
      if autoescape then
        local escape = autoescape
        if type(autoescape) == 'function' then
          escape = autoescape(env._LUPAFILENAME) -- TODO: test
        end
        if escape and type(value) == 'string' then
          value = M.filters.escape(value)
        end
      end
      chunks[#chunks + 1] = value ~= nil and tostring(value) or ''
    elseif token == 'extends' then
      env_assert(env, not extends,
                 'cannot have multiple "extends" in the same scope')
      local file = eval(block, env) -- covers strings and variables
      extends = file
      env._LUPAEXTENDED = true -- used by parent templates
    elseif token == 'block' then
      local name = block.expression:match('^[%w_]+$')
      env_assert(env, name, 'invalid block name')
      -- Store the block for potential use by the parent template if this
      -- template is a child template, or for use by `self`.
      if not env._LUPABLOCKS then env._LUPABLOCKS = {} end
      if not env._LUPABLOCKS[name] then env._LUPABLOCKS[name] = {} end
      table.insert(env._LUPABLOCKS[name], 1, block)
      -- Handle the block properly.
      if not extends then
        if not env._LUPAEXTENDED then
          -- Evaluate the block normally.
          chunks[#chunks + 1] = evaluate(block, env)
        else
          -- A child template is overriding this parent's named block. Evaluate
          -- the child's block and use it instead of the parent's.
          local blocks = env._LUPABLOCKS[name]
          local super_env = setmetatable({super = function()
            -- Loop through the chain of defined blocks, evaluating from top to
            -- bottom, and return the bottom block. In each sub-block, the
            -- 'super' variable needs to point to the next-highest block's
            -- evaluated result.
            local super = evaluate(block, env) -- start with parent block
            local sub_env = setmetatable({super = function() return super end},
                                         {__index = env})
            for i = 1, #blocks - 1 do super = evaluate(blocks[i], sub_env) end
            return super
          end}, {__index = env})
          chunks[#chunks + 1] = evaluate(blocks[#blocks], super_env)
        end
      end
    elseif token == 'for' then
      local expr = block.expression
      local p = env._LUPAPOSITION -- mark position at beginning of expression
      -- Extract variable list and generator.
      local patt = '^([%w_,%s]+)%s+in%s+()(.+)%s+if%s+(.+)$'
      local var_list, pos, generator, if_expr = expr:match(patt)
      if not var_list then
        var_list, pos, generator = expr:match('^([%w_,%s]+)%s+in%s+()(.+)$')
      end
      env_assert(env, var_list and generator, 'invalid for expression')
      -- Store variable names in a list for loop assignment.
      local variables = {}
      for variable, pos in var_list:gmatch('([^,%s]+)()') do
        env._LUPAPOSITION = p + pos - 1 -- update position for error messages
        env_assert(env, variable:find('^[%a_]') and variable ~= 'loop',
                   'invalid variable name')
        variables[#variables + 1] = variable
      end
      -- Evaluate the generator and perform the iteration.
      env._LUPAPOSITION = p + pos - 1 -- update position to generator
      if not generator:find('|') then
        generator = env_assert(env, load('return '..generator, nil, nil, env))
      else
        local generator_expr = generator
        generator = function() return eval(generator_expr, env) end
      end
      local new_env = setmetatable({}, {__index = env})
      chunks[#chunks + 1] = iterate(generator, variables, if_expr, block,
                                    new_env, 1, ast[i + 4] == 'lstrip')
    elseif token == 'if' then
      if eval(block.expression, env) then
        chunks[#chunks + 1] = evaluate(block, env)
      else
        local evaluate_else = true
        local elseifs = block['elseif']
        if elseifs then
          for j = 1, #elseifs do
            if eval(elseifs[j].expression, env) then
              chunks[#chunks + 1] = evaluate(elseifs[j], env)
              evaluate_else = false
              break
            end
          end
        end
        if evaluate_else and block['else'] then
          chunks[#chunks + 1] = evaluate(block['else'], env)
        end
      end
    elseif token == 'macro' then
      -- Parse the macro's name and parameter list.
      local signature = block.expression
      local name, param_list = signature:match('^([%w_]+)(%b())')
      env_assert(env, name and param_list, 'invalid macro expression')
      param_list = param_list:sub(2, -2)
      local p = env._LUPAPOSITION + #name + 1 -- mark pos at beginning of args
      local params, defaults = {}, {}
      for param, pos, default in param_list:gmatch('([%w_]+)=?()([^,]*)') do
        params[#params + 1] = param
        if default ~= '' then
          env._LUPAPOSITION = p + pos - 1 -- update position for error messages
          local f = env_assert(env, load('return '..default))
          defaults[param] = select(2, env_assert(env, pcall(f)))
        end
      end
      -- Create the function associated with the macro such that when the
      -- function is called (from within {{ ... }}), the macro's body is
      -- evaluated subject to an environment where parameter names are variables
      -- whose values are the ones passed to the macro itself.
      env[name] = function(...)
        local new_env = setmetatable({}, {__index = function(_, k)
          if k == 'caller' and type(env[k]) ~= 'function' then return nil end
          return env[k]
        end})
        local args = {...}
        -- Assign the given parameter values.
        for i = 1, #args do
          if i > #params then break end
          new_env[params[i]] = args[i]
        end
        -- Clear all other unspecified parameter values or set them to their
        -- defined defaults.
        for i = #args + 1, #params do
          new_env[params[i]] = defaults[params[i]]
        end
        -- Store extra parameters in "varargs" variable.
        new_env.varargs = {}
        for i = #params + 1, #args do
          new_env.varargs[#new_env.varargs + 1] = args[i]
        end
        local chunk = evaluate(block, new_env)
        if ast[i + 4] == 'lstrip' then chunk = chunk:gsub('%s*$', '') end
        return chunk
      end
    elseif token == 'call' then
      -- Parse the call block's parameter list (if any) and determine the macro
      -- to call.
      local param_list = block.expression:match('^(%b())')
      local params = {}
      if param_list then
        for param in param_list:gmatch('[%w_]+') do
          params[#params + 1] = param
        end
      end
      local macro = block.expression:match('^%b()(.+)$') or block.expression
      -- Evaluate the given macro, subject to a "caller" function that returns
      -- the contents of this call block. Any arguments passed to the caller
      -- function are used as values of this parameters parsed earlier.
      local old_caller = M.env.caller -- save
      M.env.caller = function(...)
        local new_env = setmetatable({}, {__index = env})
        local args = {...}
        -- Assign the given parameter values (if any).
        for i = 1, #args do new_env[params[i]] = args[i] end
        local chunk = evaluate(block, new_env)
        if ast[i + 4] == 'lstrip' then chunk = chunk:gsub('%s*$', '') end
        return chunk
      end
      chunks[#chunks + 1] = eval(macro, env)
      M.env.caller = old_caller -- restore
    elseif token == 'filter' then
      local text = evaluate(block, env)
      local p = env._LUPAPOSITION -- mark position at beginning of expression
      for pos, filter in each_filter(block.expression) do
        env._LUPAPOSITION = p + pos - 1 -- update position for error messages
        local name, params = filter:match('^%s*([%w_]+)%(?(.-)%)?%s*$')
        local f = M.filters[name]
        env_assert(env, f, 'unknown filter "'..name..'"')
        local args = env_assert(env, load('return {'..params..'}'),
                                'invalid filter parameter(s) for "'..name..
                                '"')()
        text = select(2, env_assert(env, pcall(f, text, table.unpack(args))))
      end
      chunks[#chunks + 1] = text
    elseif token == 'set' then
      local var, expr = block:match('^([%a_][%w_]*)%s*=%s*(.+)$')
      env_assert(env, var and expr, 'invalid variable name or expression')
      env[var] = eval(expr, env)
    elseif token == 'do' then
      env_assert(env, pcall(env_assert(env, load(block, nil, nil, env))))
    elseif token == 'include' then
      -- Parse the include block for flags.
      local without_context = block:find('without%s+context%s*')
      local ignore_missing = block:find('ignore%s+missing%s*')
      block = block:gsub('witho?u?t?%s+context%s*', '')
                   :gsub('ignore%s+missing%s*', '')
      -- Evaluate the include expression in order to determine the file to
      -- include. If the result is a table, use the first file that exists.
      local file = eval(block, env) -- covers strings and variables
      if type(file) == 'table' then
        local files = file
        for i = 1, #files do
          file = loader(files[i], env)
          if file then break end
        end
        if type(file) == 'table' then file = nil end
      elseif type(file) == 'string' then
        file = loader(file, env)
      else
        error('"include" requires a string or table of files')
      end
      -- If the file exists, include it. Otherwise throw an error unless the
      -- "ignore missing" flag was given.
      env_assert(env, file or ignore_missing, 'no file(s) found to include')
      if file then
        chunks[#chunks + 1] = M.expand_file(file, not without_context and env or
                                                  M.env)
      end
    elseif token == 'import' then
      local file, global = block:match('^%s*(.+)%s+as%s+([%a][%w_]*)%s*')
      local new_env = setmetatable({}, {
        __index = block:find('with%s+context%s*$') and env or M.env
      })
      M.expand_file(eval(file or block, env), new_env)
      -- Copy any defined macros and variables over into the proper namespace.
      if global then env[global] = {} end
      local namespace = global and env[global] or env
      for k, v in pairs(new_env) do if not env[k] then namespace[k] = v end end
    elseif token == 'lstrip' and chunks[#chunks] then
      chunks[#chunks] = chunks[#chunks]:gsub('%s*$', '')
    elseif token == 'rstrip' then
      rstrip = true -- can only strip after determining the next chunk
    end
    if rstrip and token ~= 'rstrip' then
      chunks[#chunks] = chunks[#chunks]:gsub('^%s*', '')
      rstrip = false
    end
  end
  return not extends and table.concat(chunks) or M.expand_file(extends, env)
end

local pairs_gen, ipairs_gen = pairs({}), ipairs({})

-- Iterates over the generator *generator* subject to string "if" expression
-- *if_expr*, assigns that generator's returned values to the variable names
-- listed in *variables* within template environment *env*, evaluates any
-- expressions in *block* (a portion of a template's AST), and returns a
-- concatenation of the results.
-- @param generator Either a function that returns a generator function, or a
--   table to iterate over. In the latter case, `ipairs()` is used as the
--   generator function.
-- @param variables List of variable names to assign values returned by
--   *generator* to.
-- @param if_expr A conditional expression that when `false`, skips the current
--   loop item.
-- @param block The portion inside the 'for' structure of a template's AST to
--   iterate with.
-- @param env The environment iteration variables are defined in and where
--   expressions are evaluated in.
-- @param depth The current recursion depth. Recursion is performed by calling
--   `loop(t)` with a table to iterate over.
-- @param lstrip Whether or not the "endfor" block strips whitespace on the
--   left. When `true`, all blocks produced by iteration are left-stripped.
iterate = function(generator, variables, if_expr, block, env, depth, lstrip)
  local chunks = {}
  local orig_variables = {} -- used to store original loop variables' values
  for i = 1, #variables do orig_variables[variables[i]] = env[variables[i]] end
  local i, n = 1 -- used for loop variables
  local _, s, v -- state variables
  if type(generator) == 'function' then
    _, generator, s, v = env_assert(env, pcall(generator))
    -- In practice, a generator's state variable is normally unused and hidden.
    -- This is not the case for 'pairs()' and 'ipairs', though.
    if variables[1] ~= '_index' and generator ~= pairs_gen and
       generator ~= ipairs_gen then
      table.insert(variables, 1, '_index')
    end
  end
  if type(generator) == 'table' then
    n = #generator
    generator, s, v = ipairs(generator)
    -- "for x in y" translates to "for _, x in ipairs(y)"; hide _ state variable
    if variables[1] ~= '_index' then table.insert(variables, 1, '_index') end
  end
  if generator then
    local first_results -- for preventing infinite loop from invalid generator
    while true do
      local results = {generator(s, v)}
      if results[1] == nil then break end
      -- If the results from the generator look like results returned by a
      -- generator itself (function, state, initial variable), verify last two
      -- results are different. If they are the same, then the original
      -- generator is invalid and will loop infinitely.
      if first_results == nil then
        first_results = #results == 3 and type(results[1]) == 'function' and
                        results
      elseif first_results then
        env_assert(env, results[3] ~= first_results[3] or
                        results[2] ~= first_results[2],
                   'invalid generator (infinite loop)')
      end
      -- Assign context variables and evaluate the body of the loop.
      -- As long as the result (ignoring the _index variable) is not a single
      -- table and there is only one loop variable defined (again, ignoring
      -- _index variable), assignment occurs as normal in Lua. Otherwise,
      -- unpacking on the table is done (like assignment to ...).
      if not (type(results[2]) == 'table' and #results == 2 and
              #variables > 2) then
        for j = 1, #variables do env[variables[j]] = results[j] end
      else
        for j = 2, #variables do env[variables[j]] = results[2][j - 1] end
      end
      if not if_expr or eval(if_expr, env) then
        env.loop = setmetatable({
          index = i, index0 = i - 1,
          revindex = n and n - (i - 1), revindex0 = n and n - i,
          first = i == 1, last = i == n, length = n,
          cycle = function(...)
            return select((i - 1) % select('#', ...) + 1, ...)
          end,
          depth = depth, depth0 = depth - 1
        }, {__call = function(_, t)
          return iterate(t, variables, if_expr, block, env, depth + 1, lstrip)
        end})
        chunks[#chunks + 1] = evaluate(block, env)
        if lstrip then chunks[#chunks] = chunks[#chunks]:gsub('%s*$', '') end
        i = i + 1
      end
      -- Prepare for next iteration.
      v = results[1]
    end
  end
  if i == 1 and block['else'] then
    chunks[#chunks + 1] = evaluate(block['else'], env)
  end
  for i = 1, #variables do env[variables[i]] = orig_variables[variables[i]] end
  return table.concat(chunks)
end

-- Expands string template *template* from source *source*, subject to template
-- environment *env*, and returns the result.
-- @param template String template to expand.
-- @param env Environment for the given template.
-- @param source Filename or identifier the template comes from for error
--   messages and debugging.
local function expand(template, env, source)
  template = template:gsub('\r?\n', newline_sequence) -- normalize
  if not keep_trailing_newline then template = template:gsub('\r?\n$', '') end
  -- Set up environment.
  if not env then env = {} end
  if not getmetatable(env) then env = setmetatable(env, {__index = M.env}) end
  env.self = setmetatable({}, {__index = function(_, k)
    env_assert(env, env._LUPABLOCKS and env._LUPABLOCKS[k],
               'undefined block "'..k..'"')
    return function() return evaluate(env._LUPABLOCKS[k][1], env) end
  end})
  -- Set context variables and expand the template.
  env._LUPASOURCE, env._LUPAFILENAME = template, source
  M._FILENAME = source -- for lpeg errors only
  local ast = assert(lpeg.match(M.grammar, template), "internal error")
  local result = evaluate(ast, env)
  return result
end

---
-- Expands the string template *template*, subject to template environment
-- *env*, and returns the result.
-- @param template String template to expand.
-- @param env Optional environment for the given template.
-- @name expand
function M.expand(template, env) return expand(template, env, '<string>') end

---
-- Expands the template within file *filename*, subject to template environment
-- *env*, and returns the result.
-- @param filename Filename containing the template to expand.
-- @param env Optional environment for the template to expand.
-- @name expand_file
function M.expand_file(filename, env)
  filename = loader(filename, env) or filename
  local f = (not env or not env._LUPASOURCE) and assert(io.open(filename)) or
            env_assert(env, io.open(filename))
  local template = f:read('*a')
  f:close()
  return expand(template, env, filename)
end

---
-- Returns a loader for templates that uses the filesystem starting at directory
-- *directory*.
-- When looking up the template for a given filename, the loader considers the
-- following: if no template is being expanded, the loader assumes the given
-- filename is relative to *directory* and returns the full path; otherwise the
-- loader assumes the given filename is relative to the current template's
-- directory and returns the full path.
-- The returned path may be passed to `io.open()`.
-- @param directory Optional the template root directory. The default value is
--   ".", which is the current working directory.
-- @name loaders.filesystem
-- @see configure
function M.loaders.filesystem(directory)
  return function(filename, env)
    if not filename then return nil end
    local current_dir = env and env._LUPAFILENAME and
                        env._LUPAFILENAME:match('^(.+)[/\\]')
    if not filename:find('^/') and not filename:find('^%a:[/\\]') then
      filename = (current_dir or directory or '.')..'/'..filename
    end
    local f = io.open(filename)
    if not f then return nil end
    f:close()
    return filename
  end
end

-- Globally defined functions.

---
-- Returns a sequence of integers from *start* to *stop*, inclusive, in
-- increments of *step*.
-- The complete sequence is generated at once -- no generator is returned.
-- @param start Optional number to start at. The default value is `1`.
-- @param stop Number to stop at.
-- @param step Optional increment between sequence elements. The default value
--   is `1`.
-- @name _G.range
function range(start, stop, step)
  if not stop and not step then stop, start = start, 1 end
  if not step then step = 1 end
  local t = {}
  for i = start, stop, step do t[#t + 1] = i end
  return t
end

---
-- Returns an object that cycles through the given values by calls to its
-- `next()` function.
-- A `current` field contains the cycler's current value and a `reset()`
-- function resets the cycler to its beginning.
-- @param ... Values to cycle through.
-- @usage c = cycler(1, 2, 3)
-- @usage c:next(), c:next() --> 1, 2
-- @usage c:reset() --> c.current == 1
-- @name _G.cycler
function cycler(...)
  local c = {...}
  c.n, c.i, c.current = #c, 1, c[1]
  function c:next()
    local current = self.current
    self.i = self.i + 1
    if self.i > self.n then self.i = 1 end
    self.current = self[self.i]
    return current
  end
  function c:reset() self.i, self.current = 1, self[1] end
  return c
end

-- Create the default sandbox environment for templates.
local safe = {
  -- Lua globals.
  '_VERSION', 'ipairs', 'math', 'pairs', 'select', 'tonumber', 'tostring',
  'type', 'bit32', 'os.date', 'os.time', 'string', 'table', 'utf8',
  -- Lupa globals.
  'range', 'cycler'
}
local sandbox_env = setmetatable({}, {__index = M.tests})
for i = 1, #safe do
  local v = safe[i]
  if not v:find('%.') then
    sandbox_env[v] = _G[v]
  else
    local mod, func = v:match('^([^.]+)%.(.+)$')
    if not sandbox_env[mod] then sandbox_env[mod] = {} end
    sandbox_env[mod][func] = _G[mod][func]
  end
end
sandbox_env._G = sandbox_env

---
-- Resets Lupa's default delimiters, options, and environments to their
-- original default values.
-- @name reset
function M.reset()
  M.configure('{%', '%}', '{{', '}}', '{#', '#}')
  M.env = setmetatable({}, {__index = sandbox_env})
end
M.reset()

---
-- The default template environment.
-- @class table
-- @name env
local env

-- Lupa filters.

---
-- Returns the absolute value of number *n*.
-- @param n The number to compute the absolute value of.
-- @name filters.abs
M.filters.abs = math.abs

-- Returns a table that, when indexed with an integer, indexes table *t* with
-- that integer along with string *attribute*.
-- This is used by filters that operate on particular attributes of table
-- elements.
-- @param t The table to index.
-- @param attribute The additional attribute to index with.
local function attr_accessor(t, attribute)
  return setmetatable({}, {__index = function(_, i)
    local value = t[i]
    attribute = tonumber(attribute) or attribute
    if type(attribute) == 'number' then return value[attribute] end
    for k in attribute:gmatch('[^.]+') do value = value[k] end
    return value
  end})
end

---
-- Returns a generator that produces all of the items in table *t* in batches
-- of size *size*, filling any empty spaces with value *fill*.
-- Combine this with the "list" filter to produce a list.
-- @param t The table to split into batches.
-- @param size The batch size.
-- @param fill The value to use when filling in any empty space in the last
--   batch.
-- @usage expand('{% for i in {1, 2, 3}|batch(2, 0) %}{{ i|string }}
--   {% endfor %}') --> {1, 2} {3, 0}
-- @see filters.list
-- @name filters.batch
function M.filters.batch(t, size, fill)
  assert(t, 'input to filter "batch" was nil instead of a table')
  local n = #t
  return function(t, i)
    if i > n then return nil end
    local batch = {}
    for j = i, i + size - 1 do batch[j - i + 1] = t[j] end
    if i + size > n and fill then
      for j = n + 1, i + size - 1 do batch[#batch + 1] = fill end
    end
    return i + size, batch
  end, t, 1
end

---
-- Capitalizes string *s*.
-- The first character will be uppercased, the others lowercased.
-- @param s The string to capitalize.
-- @usage expand('{{ "foo bar"|capitalize }}') --> Foo bar
-- @name filters.capitalize
function M.filters.capitalize(s)
  assert(s, 'input to filter "capitalize" was nil instead of a string')
  local first, rest = s:match('^(.)(.*)$')
  return first and first:upper()..rest:lower() or s
end

---
-- Centers string *s* within a string of length *width*.
-- @param s The string to center.
-- @param width The length of the centered string.
-- @usage expand('{{ "foo"|center(9) }}') --> "   foo   "
-- @name filters.center
function M.filters.center(s, width)
  assert(s, 'input to filter "center" was nil instead of a string')
  local padding = (width or 80) - #s
  local left, right = math.ceil(padding / 2), math.floor(padding / 2)
  return ("%s%s%s"):format((' '):rep(left), s, (' '):rep(right))
end

---
-- Returns value *value* or value *default*, depending on whether or not *value*
-- is "true" and whether or not boolean *false_defaults* is `true`.
-- @param value The value return if "true" or if `false` and *false_defaults*
--   is `true`.
-- @param default The value to return if *value* is `nil` or `false` (the latter
--   applies only if *false_defaults* is `true`).
-- @param false_defaults Optional flag indicating whether or not to return
--   *default* if *value* is `false`. The default value is `false`.
-- @usage expand('{{ false|default("no") }}') --> false
-- @usage expand('{{ false|default("no", true) }') --> no
-- @name filters.default
function M.filters.default(value, default, false_defaults)
  if value == nil or false_defaults and not value then return default end
  return value
end

---
-- Returns a table constructed from table *t* such that each element is a list
-- that contains a single key-value pair and all elements are sorted according
-- to string *by* (which is either "key" or "value") and boolean
-- *case_sensitive*.
-- @param value The table to sort.
-- @param case_sensitive Optional flag indicating whether or not to consider
--   case when sorting string values. The default value is `false`.
-- @param by Optional string that specifies which of the key-value to sort by,
--   either "key" or "value". The default value is `"key"`.
-- @usage expand('{{ {b = 1, a = 2}|dictsort|string }}') --> {{"a", 2},
--   {"b", 1}}
-- @name filters.dictsort
function M.filters.dictsort(t, case_sensitive, by)
  assert(t, 'input to filter "dictsort" was nil instead of a table')
  assert(not by or by == 'key' or by == 'value',
         'filter "dictsort" can only sort tables by "key" or "value"')
  local i = (not by or by == 'key') and 1 or 2
  local items = {}
  for k, v in pairs(t) do items[#items + 1] = {k, v} end
  table.sort(items, function(a, b)
    a, b = a[i], b[i]
    if not case_sensitive then
      if type(a) == 'string' then a = a:lower() end
      if type(b) == 'string' then b = b:lower() end
    end
    return a < b
  end)
  return items
end

---
-- Returns an HTML-safe copy of string *s*.
-- @param s String to ensure is HTML-safe.
-- @usage expand([[{{ '<">&'|e}}]]) --> &lt;&#34;&gt;&amp;
-- @name filters.escape
function M.filters.escape(s)
  assert(s, 'input to filter "escape" was nil instead of a string')
  return s:gsub('[<>"\'&]', {
    ['<'] = '&lt;', ['>'] = '&gt;', ['"'] = '&#34;', ["'"] = '&#39;',
    ['&'] = '&amp;'
  })
end

---
-- Returns an HTML-safe copy of string *s*.
-- @param s String to ensure is HTML-safe.
-- @usage expand([[{{ '<">&'|escape}}]]) --> &lt;&#34;&gt;&amp;
-- @name filters.e
function M.filters.e(s)
  assert(s, 'input to filter "e" was nil instead of a string')
  return M.filters.escape(s)
end

---
-- Returns a human-readable, decimal (or binary, depending on boolean *binary*)
-- file size for *bytes* number of bytes.
-- @param bytes The number of bytes to return the size for.
-- @param binary Flag indicating whether or not to report binary file size
--    as opposed to decimal file size. The default value is `false`.
-- @usage expand('{{ 1000|filesizeformat }}') --> 1.0 kB
-- @name filters.filesizeformat
function M.filters.filesizeformat(bytes, binary)
  assert(bytes, 'input to filter "filesizeformat" was nil instead of a number')
  local base = binary and 1024 or 1000
  local units = {
    binary and 'KiB' or 'kB', binary and 'MiB' or 'MB',
    binary and 'GiB' or 'GB', binary and 'TiB' or 'TB',
    binary and 'PiB' or 'PB', binary and 'EiB' or 'EB',
    binary and 'ZiB' or 'ZB', binary and 'YiB' or 'YB'
  }
  if bytes < base then
    return string.format('%d Byte%s', bytes, bytes > 1 and 's' or '')
  else
    local limit, unit
    for i = 1, #units do
      limit, unit = base^(i + 1), units[i]
      if bytes < limit then break end
    end
    return string.format('%.1f %s', (base * bytes / limit), unit)
  end
end

---
-- Returns the first element in table *t*.
-- @param t The table to get the first element of.
-- @usage expand('{{ range(10)|first }}') --> 1
-- @name filters.first
function M.filters.first(t)
  assert(t, 'input to filter "first" was nil instead of a table')
  return t[1]
end

---
-- Returns value *value* as a float.
-- This filter only works in Lua 5.3, which has a distinction between floats and
-- integers.
-- @param value The value to interpret as a float.
-- @usage expand('{{ 42|float }}') --> 42.0
-- @name filters.float
function M.filters.float(value)
  assert(value, 'input to filter "float" was nil instead of a number')
  return (tonumber(value) or 0) * 1.0
end

---
-- Returns an HTML-safe copy of value *value*, even if *value* was returned by
-- the "safe" filter.
-- @param value Value to ensure is HTML-safe.
-- @usage expand('{% set x = "<div />"|safe %}{{ x|forceescape }}') -->
--   &lt;div /&gt;
-- @name filters.forceescape
function M.filters.forceescape(value)
  assert(value, 'input to filter "forceescape" was nil instead of a string')
  return M.filters.escape(tostring(value))
end

---
-- Returns the given arguments formatted according to string *s*.
-- See Lua's `string.format()` for more information.
-- @param s The string to format subsequent arguments according to.
-- @param ... Arguments to format.
-- @usage expand('{{ "%s,%s"|format("a", "b") }}') --> a,b
-- @name filters.format
function M.filters.format(s, ...)
  assert(s, 'input to filter "format" was nil instead of a string')
  return string.format(s, ...)
end

---
-- Returns a generator that produces lists of items in table *t* grouped by
-- string attribute *attribute*.
-- @param t The table to group items from.
-- @param attribute The attribute of items in the table to group by. This may
--   be nested (e.g. "foo.bar" groups by t[i].foo.bar for all i).
-- @usage expand('{% for age, group in people|groupby("age") %}...{% endfor %}')
-- @name filters.groupby
function M.filters.groupby(t, attribute)
  assert(t, 'input to filter "groupby" was nil instead of a table')
  local n = #t
  local seen = {} -- keep track of groupers in order to avoid duplicates
  return function(t, i)
    if i > n then return nil end
    local ta = attr_accessor(t, attribute)
    -- Determine the next grouper.
    local grouper = ta[i]
    while seen[grouper] do
      i = i + 1
      if i > n then return nil end
      grouper = ta[i]
    end
    seen[grouper] = true
    -- Create and return the group.
    local group = {}
    for j = i, #t do if ta[j] == grouper then group[#group + 1] = t[j] end end
    return i + 1, grouper, group
  end, t, 1
end

---
-- Returns a copy of string *s* with all lines after the first indented by
-- *width* number of spaces.
-- If boolean *first_line* is `true`, indents the first line as well.
-- @param s The string to indent lines of.
-- @param width The number of spaces to indent lines with.
-- @param first_line Optional flag indicating whether or not to indent the
--   first line of text. The default value is `false`.
-- @usage expand('{{ "foo\nbar"|indent(2) }}') --> "foo\n  bar"
-- @name filters.indent
function M.filters.indent(s, width, first_line)
  assert(s, 'input to filter "indent" was nil instead of a string')
  local indent = (' '):rep(width)
  return (first_line and indent or '')..s:gsub('([\r\n]+)', '%1'..indent)
end

---
-- Returns value *value* as an integer.
-- @param value The value to interpret as an integer.
-- @usage expand('{{ 32.32|int }}') --> 32
-- @name filters.int
function M.filters.int(value)
  assert(value, 'input to filter "int" was nil instead of a number')
  return math.floor(tonumber(value) or 0)
end

---
-- Returns a string that contains all the elements in table *t* (or all the
-- attributes named *attribute* in *t*) separated by string *sep*.
-- @param t The table to join.
-- @param sep The string to separate table elements with.
-- @param attribute Optional attribute of elements to use for joining instead
--   of the elements themselves. This may be nested (e.g. "foo.bar" joins
--   `t[i].foo.bar` for all i).
-- @usage expand('{{ {1, 2, 3}|join("|") }}') --> 1|2|3
-- @name filters.join
function M.filters.join(t, sep, attribute)
  assert(t, 'input to filter "join" was nil instead of a table')
  if not attribute then
    local strings = {}
    for i = 1, #t do strings[#strings + 1] = tostring(t[i]) end
    return table.concat(strings, sep)
  end
  local ta = attr_accessor(t, attribute)
  local attributes = {}
  for i = 1, #t do attributes[#attributes + 1] = ta[i] end
  return table.concat(attributes, sep)
end

---
-- Returns the last element in table *t*.
-- @param t The table to get the last element of.
-- @usage expand('{{ range(10)|last }}') --> 10
-- @name filters.last
function M.filters.last(t)
  assert(t, 'input to filter "last" was nil instead of a table')
  return t[#t]
end

---
-- Returns the length of string or table *value*.
-- @param value The value to get the length of.
-- @usage expand('{{ "hello world"|length }}') --> 11
-- @name filters.length
function M.filters.length(value)
  assert(value, 'input to filter "length" was nil instead of a table or string')
  return #value
end

---
-- Returns the list of items produced by generator *generator*, subject to
-- initial state *s* and initial iterator variable *i*.
-- This filter should only be used after a filter that returns a generator.
-- @param generator Generator function that produces an item.
-- @param s Initial state for the generator.
-- @param i Initial iterator variable for the generator.
-- @usage expand('{{ range(4)|batch(2)|list|string }}') --> {{1, 2}, {3, 4}}
-- @see filters.batch
-- @see filters.groupby
-- @see filters.slice
-- @name filters.list
function M.filters.list(generator, s, i)
  assert(type(generator) == 'function',
         'input to filter "list" must be a generator')
  local list = {}
  for _, v in generator, s, i do list[#list + 1] = v end
  return list
end

---
-- Returns a copy of string *s* with all lowercase characters.
-- @param s The string to lowercase.
-- @usage expand('{{ "FOO"|lower }}') --> foo
-- @name filters.lower
function M.filters.lower(s)
  assert(s, 'input to filter "lower" was nil instead of a string')
  return string.lower(s)
end

---
-- Maps each element of table *t* to a value produced by filter name *filter*
-- and returns the resultant table.
-- @param t The table of elements to map.
-- @param filter The name of the filter to pass table elements through.
-- @param ... Any arguments for the filter.
-- @usage expand('{{ {"1", "2", "3"}|map("int")|sum }}') --> 6
-- @name filters.map
function M.filters.map(t, filter, ...)
  assert(t, 'input to filter "map" was nil instead of a table')
  local f = M.filters[filter]
  assert(f, 'unknown filter "'..filter..'"')
  local map = {}
  for i = 1, #t do map[i] = f(t[i], ...) end
  return map
end

---
-- Maps the value of each element's string *attribute* in table *t* to the
-- value produced by filter name *filter* and returns the resultant table.
-- @param t The table of elements with attributes to map.
-- @param attribute The attribute of elements in the table to filter. This may
--   be nested (e.g. "foo.bar" maps t[i].foo.bar for all i).
-- @param filter The name of the filter to pass table elements through.
-- @param ... Any arguments for the filter.
-- @usage expand('{{ users|mapattr("name")|join("|") }}')
-- @name filters.mapattr
function M.filters.mapattr(t, attribute, filter, ...)
  assert(t, 'input to filter "mapattr" was nil instead of a table')
  local ta = attr_accessor(t, attribute)
  local f = M.filters[filter]
  if filter then
    assert(f, 'unknown filter "'..filter..'" given to filter "mapattr"')
  end
  local map = {}
  for i = 1, #t do map[i] = filter and f(ta[i], ...) or ta[i] end
  return map
end

---
-- Returns a random element from table *t*.
-- @param t The table to get a random element from.
-- @usage expand('{{ range(100)|random }}')
-- @name filters.random
function M.filters.random(t)
  assert(t, 'input to filter "random" was nil instead of a table')
  math.randomseed(os.time())
  return t[math.random(#t)]
end

---
-- Returns a list of elements in table *t* that fail test name *test*.
-- @param t The table of elements to reject from.
-- @param test The name of the test to use on table elements.
-- @param ... Any arguments for the test.
-- @usage expand('{{ range(5)|reject(is_odd)|join("|") }}') --> 2|4
-- @name filters.reject
function M.filters.reject(t, test, ...)
  assert(t, 'input to filter "reject" was nil instead of a table')
  local f = test or function(value) return not not value end
  local items = {}
  for i = 1, #t do if not f(t[i], ...) then items[#items + 1] = t[i] end end
  return items
end

---
-- Returns a list of elements in table *t* whose string attribute *attribute*
-- fails test name *test*.
-- @param t The table of elements to reject from.
-- @param attribute The attribute of items in the table to reject from. This
--   may be nested (e.g. "foo.bar" tests t[i].foo.bar for all i).
-- @param test The name of the test to use on table elements.
-- @param ... Any arguments for the test.
-- @usage expand('{{ users|rejectattr("offline")|mapattr("name")|join(",") }}')
-- @name filters.rejectattr
function M.filters.rejectattr(t, attribute, test, ...)
  assert(t, 'input to filter "rejectattr" was nil instead of a table')
  local ta = attr_accessor(t, attribute)
  local f = test or function(value) return not not value end
  local items = {}
  for i = 1, #t do if not f(ta[i], ...) then items[#items + 1] = t[i] end end
  return items
end

---
-- Returns a copy of string *s* with all (or up to *n*) occurrences of string
-- *old* replaced by string *new*.
-- Identical to Lua's `string.gsub()` and handles Lua patterns.
-- @param s The subject string.
-- @param pattern The string or Lua pattern to replace.
-- @param repl The replacement text (may contain Lua captures).
-- @param n Optional number indicating the maximum number of replacements to
--   make. The default value is `nil`, which is unlimited.
-- @usage expand('{% filter upper|replace("FOO", "foo") %}foobar
--   {% endfilter %}') --> fooBAR
-- @name filters.replace
function M.filters.replace(s, pattern, repl, n)
  assert(s, 'input to filter "replace" was nil instead of a string')
  return string.gsub(s, pattern, repl, n)
end

---
-- Returns a copy of the given string or table *value* in reverse order.
-- @param value The value to reverse.
-- @usage expand('{{ {1, 2, 3}|reverse|string }}') --> {3, 2, 1}
-- @name filters.reverse
function M.filters.reverse(value)
  assert(type(value) == 'table' or type(value) == 'string',
         'input to filter "reverse" was nil instead of a table or string')
  if type(value) == 'string' then return value:reverse() end
  local t = {}
  for i = 1, #value do t[i] = value[#value - i + 1] end
  return t
end

---
-- Returns number *value* rounded to *precision* decimal places based on string
-- *method* (if given).
-- @param value The number to round.
-- @param precision Optional precision to round the number to. The default
--   value is `0`.
-- @param method Optional string rounding method, either `"ceil"` or
--   `"floor"`. The default value is `nil`, which uses the common rounding
--   method (if a number's fractional part is 0.5 or greater, rounds up;
--   otherwise rounds down).
-- @usage expand('{{ 2.1236|round(3, "floor") }}') --> 2.123
-- @name filters.round
function M.filters.round(value, precision, method)
  assert(value, 'input to filter "round" was nil instead of a number')
  assert(not method or method == 'ceil' or method == 'floor',
         'rounding method given to filter "round" must be "ceil" or "floor"')
  precision = precision or 0
  method = method or (select(2, math.modf(value)) >= 0.5 and 'ceil' or 'floor')
  local s = string.format('%.'..(precision >= 0 and precision or 0)..'f',
                          math[method](value * 10^precision) / 10^precision)
  return tonumber(s)
end

---
-- Marks string *s* as HTML-safe, preventing Lupa from modifying it when
-- configured to autoescape HTML entities.
-- This filter must be used at the end of a filter chain unless it is
-- immediately proceeded by the "forceescape" filter.
-- @param s The string to mark as HTML-safe.
-- @usage lupa.configure{autoescape = true}
-- @usage expand('{{ "<div>foo</div>"|safe }}') --> <div>foo</div>
-- @name filters.safe
function M.filters.safe(s)
  assert(s, 'input to filter "safe" was nil instead of a string')
  return setmetatable({}, {__tostring = function() return s end})
end

---
-- Returns a list of the elements in table *t* that pass test name *test*.
-- @param t The table of elements to select from.
-- @param test The name of the test to use on table elements.
-- @param ... Any arguments for the test.
-- @usage expand('{{ range(5)|select(is_odd)|join("|") }}') --> 1|3|5
-- @name filters.select
function M.filters.select(t, test, ...)
  assert(t, 'input to filter "select" was nil instead of a table')
  local f = test or function(value) return not not value end
  local items = {}
  for i = 1, #t do if f(t[i], ...) then items[#items + 1] = t[i] end end
  return items
end

---
-- Returns a list of elements in table *t* whose string attribute *attribute*
-- passes test name *test*.
-- @param t The table of elements to select from.
-- @param attribute The attribute of items in the table to select from. This
--   may be nested (e.g. "foo.bar" tests t[i].foo.bar for all i).
-- @param test The name of the test to use on table elements.
-- @param ... Any arguments for the test.
-- @usage expand('{{ users|selectattr("online")|mapattr("name")|join("|") }}')
-- @name filters.selectattr
function M.filters.selectattr(t, attribute, test, ...)
  assert(t, 'input to filter "selectattr" was nil instead of a table')
  local ta = attr_accessor(t, attribute)
  local f = test or function(value) return not not value end
  local items = {}
  for i = 1, #t do if f(ta[i], ...) then items[#items + 1] = t[i] end end
  return items
end

---
-- Returns a generator that produces all of the items in table *t* in *slices*
-- number of iterations, filling any empty spaces with value *fill*.
-- Combine this with the "list" filter to produce a list.
-- @param t The table to slice.
-- @param slices The number of slices to produce.
-- @param fill The value to use when filling in any empty space in the last
--   slice.
-- @usage expand('{% for i in {1, 2, 3}|slice(2, 0) %}{{ i|string }}
--   {% endfor %}') --> {1, 2} {3, 0}
-- @see filters.list
-- @name filters.slice
function M.filters.slice(t, slices, fill)
  assert(t, 'input to filter "slice" was nil instead of a table')
  local size, slices_with_extra = math.floor(#t / slices), #t % slices
  return function(t, i)
    if i > slices then return nil end
    local slice = {}
    local s = (i - 1) * size + math.min(i, slices_with_extra + 1)
    local e = i * size + math.min(i, slices_with_extra)
    for j = s, e do slice[j - s + 1] = t[j] end
    if slices_with_extra > 0 and i > slices_with_extra and fill then
      slice[#slice + 1] = fill
    end
    return i + 1, slice
  end, t, 1
end

---
-- Returns a copy of table or string *value* in sorted order by value (or by
-- an attribute named *attribute*), depending on booleans *reverse* and
-- *case_sensitive*.
-- @param value The table or string to sort.
-- @param reverse Optional flag indicating whether or not to sort in reverse
--   (descending) order. The default value is `false`, which sorts in ascending
--   order.
-- @param case_sensitive Optional flag indicating whether or not to consider
--   case when sorting string values. The default value is `false`.
-- @param attribute Optional attribute of elements to sort by instead of the
--   elements themselves.
-- @usage expand('{{ {2, 3, 1}|sort|string }}') --> {1, 2, 3}
-- @name filters.sort
function M.filters.sort(value, reverse, case_sensitive, attribute)
  assert(value, 'input to filter "sort" was nil instead of a table or string')
  assert(not attribute or type(attribute) == 'string' or
         type(attribute) == 'number',
         'attribute to filter "sort" must be a string or number')
  local t = {}
  local sort_string = type(value) == 'string'
  if not sort_string then
    for i = 1, #value do t[#t + 1] = value[i] end
  else
    for char in value:gmatch('.') do t[#t + 1] = char end -- chars in string
  end
  table.sort(t, function(a, b)
    if attribute then
      if type(attribute) == 'number' then
        a, b = a[attribute], b[attribute]
      else
        for k in attribute:gmatch('[^.]+') do a, b = a[k], b[k] end
      end
    end
    if not case_sensitive then
      if type(a) == 'string' then a = a:lower() end
      if type(b) == 'string' then b = b:lower() end
    end
    if not reverse then
      return a < b
    else
      return a > b
    end
  end)
  return not sort_string and t or table.concat(t)
end

---
-- Returns the string representation of value *value*, handling lists properly.
-- @param value Value to return the string representation of.
-- @usage expand('{{ {1 * 1, 2 * 2, 3 * 3}|string }}') --> {1, 4, 9}
-- @name filters.string
function M.filters.string(value)
  if type(value) ~= 'table' then return tostring(value) end
  local t = {}
  for i = 1, #value do
    local item = value[i]
    t[i] = type(item) == 'string' and '"'..item..'"' or M.filters.string(item)
  end
  return '{'..table.concat(t, ', ')..'}'
end

---
-- Returns a copy of string *s* with any HTML tags stripped.
-- Also cleans up whitespace.
-- @param s String to strip HTML tags from.
-- @usage expand('{{ "<div>foo</div>"|striptags }}') --> foo
-- @name filters.striptags
function M.filters.striptags(s)
  assert(s, 'input to filter "striptags" was nil instead of a string')
  return s:gsub('%b<>', ''):gsub('%s+', ' '):match('^%s*(.-)%s*$')
end

---
-- Returns the numeric sum of the elements in table *t* or the sum of all
-- attributes named *attribute* in *t*.
-- @param t The table to calculate the sum of.
-- @param attribute Optional attribute of elements to use for summing instead
--   of the elements themselves. This may be nested (e.g. "foo.bar" sums
--   `t[i].foo.bar` for all i).
-- @usage expand('{{ range(6)|sum }}') --> 21
-- @name filters.sum
function M.filters.sum(t, attribute)
  assert(t, 'input to filter "sum" was nil instead of a table')
  local ta = attribute and attr_accessor(t, attribute) or t
  local sum = 0
  for i = 1, #t do sum = sum + ta[i] end
  return sum
end

---
-- Returns a copy of all words in string *s* in titlecase.
-- @param s The string to titlecase.
-- @usage expand('{{ "foo bar"|title }}') --> Foo Bar
-- @name filters.title
function M.filters.title(s)
  assert(s, 'input to filter "title" was nil instead of a string')
  return s:gsub('[^-%s]+', M.filters.capitalize)
end

---
-- Returns a copy of string *s* truncated to *length* number of characters.
-- Truncated strings end with '...' or string *delimiter*. If boolean
-- *partial_words* is `false`, truncation will only happen at word boundaries.
-- @param s The string to truncate.
-- @param length The length to truncate the string to.
-- @param partial_words Optional flag indicating whether or not to allow
--   truncation within word boundaries. The default value is `false`.
-- @param delimiter Optional delimiter text. The default value is '...'.
-- @usage expand('{{ "foo bar"|truncate(4) }}') --> "foo ..."
-- @name filters.truncate
function M.filters.truncate(s, length, partial_words, delimiter)
  assert(s, 'input to filter "truncate" was nil instead of a string')
  if #s <= length then return s end
  local truncated = s:sub(1, length)
  if s:find('[%w_]', length) and not partial_words then
    truncated = truncated:match('^(.-)[%w_]*$') -- drop partial word
  end
  return truncated..(delimiter or '...')
end

---
-- Returns a copy of string *s* with all uppercase characters.
-- @param s The string to uppercase.
-- @usage expand('{{ "foo"|upper }}') --> FOO
-- @name filters.upper
function M.filters.upper(s)
  assert(s, 'input to filter "upper" was nil instead of a string')
  return string.upper(s)
end

---
-- Returns a string suitably encoded to be used in a URL from value *value*.
-- *value* may be a string, table of key-value query parameters, or table of
-- lists of key-value query parameters (for order).
-- @param value Value to URL-encode.
-- @usage expand('{{ {{'f', 1}, {'z', 2}}|urlencode }}') --> f=1&z=2
-- @name filters.urlencode
function M.filters.urlencode(value)
  assert(value,
         'input to filter "urlencode" was nil instead of a string or table')
  if type(value) ~= 'table' then
    return tostring(value):gsub('[^%w.-]', function(c)
      return string.format('%%%X', string.byte(c))
    end)
  end
  local params = {}
  if #value > 0 then
    for i = 1, #value do
      local k = M.filters.urlencode(value[i][1])
      local v = M.filters.urlencode(value[i][2])
      params[#params + 1] = k..'='..v
    end
  else
    for k, v in pairs(value) do
      params[#params + 1] = M.filters.urlencode(k)..'='..M.filters.urlencode(v)
    end
  end
  return table.concat(params, '&')
end

---
-- Replaces any URLs in string *s* with HTML links, limiting link text to
-- *length* characters.
-- @param s The string to replace URLs with HTML links in.
-- @param length Optional maximum number of characters to include in link text.
--   The default value is `nil`, which imposes no limit.
-- @param nofollow Optional flag indicating whether or not HTML links will get a
--   "nofollow" attribute.
-- @usage expand('{{ "example.com"|urlize }}') -->
--   <a href="http://example.com">example.com</a>
-- @name filters.urlize
function M.filters.urlize(s, length, nofollow)
  assert(s, 'input to filter "urlize" was nil instead of a string')
  -- Trims the given url.
  local function trim_url(url)
    return length and s:sub(1, length)..(#s > length and '...' or '') or url
  end
  local nofollow_attr = nofollow and ' rel="nofollow"' or ''
  local lead, trail = C((S('(<') + '&lt;')^0), C((S('.,)>\n') + '&gt;')^0) * -1
  local middle = C((1 - trail)^0)
  local patt = lpeg.Cs(lead * middle * trail / function(lead, middle, trail)
    local linked
    if middle:find('^www%.') or (not middle:find('@') and
                                 not middle:find('^https?://') and
                                 #middle > 0 and middle:find('^%w') and (
                                   middle:find('%.com$') or
                                   middle:find('%.net$') or
                                   middle:find('%.org$')
                                 )) then
      middle, linked = string.format('<a href="http://%s"%s>%s</a>', middle,
                                     nofollow_attr, trim_url(middle)), true
    end
    if middle:find('^https?://') then
      middle, linked = string.format('<a href="%s"%s>%s</a>', middle,
                                     nofollow_attr, trim_url(middle)), true
    end
    if middle:find('@') and not middle:find('^www%.') and
       not middle:find(':') and middle:find('^%S+@[%w._-]+%.[%w._-]+$') then
      middle, linked = string.format('<a href="mailto:%s">%s</a>', middle,
                                     middle), true
    end
    if linked then return lead..middle..trail end
  end)
  return M.filters.escape(s):gsub('%S+', function(word)
    return lpeg.match(patt, word)
  end)
end

---
-- Returns the number of words in string *s*.
-- A word is a sequence of non-space characters.
-- @param s The string to count words in.
-- @usage expand('{{ "foo bar baz"|wordcount }}') --> 3
-- @name filters.wordcount
function M.filters.wordcount(s)
  assert(s, 'input to filter "wordcount" was nil instead of a string')
  return select(2, s:gsub('%S+', ''))
end

---
-- Interprets table *t* as a list of XML attribute-value pairs, returning them
-- as a properly formatted, space-separated string.
-- @param t The table of XML attribute-value pairs.
-- @usage expand('<data {{ {foo = 42, bar = 23}|xmlattr }} />')
-- @name filters.xmlattr
function M.filters.xmlattr(t)
  assert(t, 'input to filter "xmlattr" was nil instead of a table')
  local attributes = {}
  for k, v in pairs(t) do
    attributes[#attributes + 1] = string.format('%s="%s"', k,
                                                M.filters.escape(tostring(v)))
  end
  return table.concat(attributes, ' ')
end

-- Lupa tests.

---
-- Returns whether or not number *n* is odd.
-- @param n The number to test.
-- @usage expand('{% for x in range(10) if is_odd(x) %}...{% endif %}')
-- @name tests.is_odd
function M.tests.is_odd(n) return n % 2 == 1 end

---
-- Returns whether or not number *n* is even.
-- @param n The number to test.
-- @usage expand('{% for x in range(10) if is_even(x) %}...{% endif %}')
-- @name tests.is_even
function M.tests.is_even(n) return n % 2 == 0 end

---
-- Returns whether or not number *n* is evenly divisible by number *num*.
-- @param n The dividend to test.
-- @param num The divisor to use.
-- @usage expand('{% if is_divisibleby(x, y) %}...{% endif %}')
-- @name tests.is_divisibleby
function M.tests.is_divisibleby(n, num) return n % num == 0 end

---
-- Returns whether or not value *value* is non-nil, and thus defined.
-- @param value The value to test.
-- @usage expand('{% if is_defined(x) %}...{% endif %}')
-- @name tests.is_defined
function M.tests.is_defined(value) return value ~= nil end

---
-- Returns whether or not value *value* is nil, and thus effectively undefined.
-- @param value The value to test.
-- @usage expand('{% if is_undefined(x) %}...{% endif %}')
-- @name tests.is_undefined
function M.tests.is_undefined(value) return value == nil end

---
-- Returns whether or not value *value* is nil.
-- @param value The value to test.
-- @usage expand('{% if is_none(x) %}...{% endif %}')
-- @name tests.is_none
function M.tests.is_none(value) return value == nil end

---
-- Returns whether or not value *value* is nil.
-- @param value The value to test.
-- @usage expand('{% if is_nil(x) %}...{% endif %}')
-- @name tests.is_nil
function M.tests.is_nil(value) return value == nil end

---
-- Returns whether or not string *s* is in all lower-case characters.
-- @param s The string to test.
-- @usage expand('{% if is_lower(s) %}...{% endif %}')
-- @name tests.is_lower
function M.tests.is_lower(s) return s:lower() == s end

---
-- Returns whether or not string *s* is in all upper-case characters.
-- @param s The string to test.
-- @usage expand('{% if is_upper(s) %}...{% endif %}')
-- @name tests.is_upper
function M.tests.is_upper(s) return s:upper() == s end

---
-- Returns whether or not value *value* is a string.
-- @param value The value to test.
-- @usage expand('{% if is_string(x) %}...{% endif %}')
-- @name tests.is_string
function M.tests.is_string(value) return type(value) == 'string' end

---
-- Returns whether or not value *value* is a table.
-- @param value The value to test.
-- @usage expand('{% if is_mapping(x) %}...{% endif %}')
-- @name tests.is_mapping
function M.tests.is_mapping(value) return type(value) == 'table' end

---
-- Returns whether or not value *value* is a table.
-- @param value The value to test.
-- @usage expand('{% if is_table(x) %}...{% endif %}')
-- @name tests.is_table
function M.tests.is_table(value) return type(value) == 'table' end

---
-- Returns whether or not value *value* is a number.
-- @param value The value to test.
-- @usage expand('{% if is_number(x) %}...{% endif %}')
-- @name tests.is_number
function M.tests.is_number(value) return type(value) == 'number' end

---
-- Returns whether or not value *value* is a sequence, namely a table with
-- non-zero length.
-- @param value The value to test.
-- @usage expand('{% if is_sequence(x) %}...{% endif %}')
-- @name tests.is_sequence
function M.tests.is_sequence(value)
  return type(value) == 'table' and #value > 0
end

---
-- Returns whether or not value *value* is a sequence (a table with non-zero
-- length) or a generator.
-- At the moment, all functions are considered generators.
-- @param value The value to test.
-- @usage expand('{% if is_iterable(x) %}...{% endif %}')
-- @name tests.is_iterable
function M.tests.is_iterable(value)
  return M.tests.is_sequence(value) or type(value) == 'function'
end

---
-- Returns whether or not value *value* is a function.
-- @param value The value to test.
-- @usage expand('{% if is_callable(x) %}...{% endif %}')
-- @name tests.is_callable
function M.tests.is_callable(value) return type(value) == 'function' end

---
-- Returns whether or not value *value* is the same as value *other*.
-- @param value The value to test.
-- @param other The value to compare with.
-- @usage expand('{% if is_sameas(x, y) %}...{% endif %}')
-- @name tests.is_sameas
function M.tests.is_sameas(value, other) return value == other end

---
-- Returns whether or not value *value* is HTML-safe.
-- @param value The value to test.
-- @usage expand('{% if is_escaped(x) %}...{% endif %}')
-- @name tests.is_escaped
function M.tests.is_escaped(value)
  return getmetatable(value) and getmetatable(value).__tostring ~= nil
end

return M