serpent.lua

local n, v = "serpent", "0.30"
local c, d = "Paul Kulchenko", "Lua serializer and pretty printer"
local snum = {
  [tostring(1 / 0)] = "1/0 --[[math.huge]]",
  [tostring(-1 / 0)] = "-1/0 --[[-math.huge]]",
  [tostring(0 / 0)] = "0/0"
}
local badtype = {
  thread = true,
  userdata = true,
  cdata = true
}
local getmetatable = debug and debug.getmetatable or _ENV.getmetatable

local function pairs(t)
  return next, t
end

local keyword, globals, G = {}, {}, _G or _ENV
for _, k in ipairs({
  "and",
  "break",
  "do",
  "else",
  "elseif",
  "end",
  "false",
  "for",
  "function",
  "goto",
  "if",
  "in",
  "local",
  "nil",
  "not",
  "or",
  "repeat",
  "return",
  "then",
  "true",
  "until",
  "while"
}) do
  keyword[k] = true
end
for k, v in pairs(G) do
  globals[v] = k
end
for _, g in ipairs({
  "coroutine",
  "debug",
  "io",
  "math",
  "string",
  "table",
  "os"
}) do
  for k, v in pairs("table" == type(G[g]) and G[g] or {}) do
    globals[v] = g .. "." .. k
  end
end

local function s(t, opts)
  local name, indent, fatal, maxnum = opts.name, opts.indent, opts.fatal, opts.maxnum
  local sparse, custom, huge = opts.sparse, opts.custom, not opts.nohuge
  local space, maxl = opts.compact and "" or " ", opts.maxlevel or math.huge
  local maxlen, metatostring = tonumber(opts.maxlength), opts.metatostring
  local iname, comm = "_" .. (name or ""), not opts.comment or tonumber(opts.comment) or math.huge
  local numformat = opts.numformat or "%.17g"
  local seen, sref, syms, symn = {}, {
    "local " .. iname .. "={}"
  }, {}, 0
  
  local function gensym(val)
    return "_" .. tostring(tostring(val)):gsub("[^%w]", ""):gsub("(%d%w+)", function(s)
      if not syms[s] then
        symn = symn + 1
        syms[s] = symn
      end
      return tostring(syms[s])
    end)
  end
  
  local function safestr(s)
    return type(s) == "number" and tostring(huge and snum[tostring(s)] or numformat:format(s)) or type(s) ~= "string" and tostring(s) or ("%q"):format(s):gsub("\n", "n"):gsub("\026", "\\026")
  end
  
  local function comment(s, l)
    return comm and (l or 0) < comm and " --[[" .. select(2, pcall(tostring, s)) .. "]]" or ""
  end
  
  local function globerr(s, l)
    return globals[s] and globals[s] .. comment(s, l) or not fatal and safestr(select(2, pcall(tostring, s))) or error("Can't serialize " .. tostring(s))
  end
  
  local function safename(path, name)
    local n = nil == name and "" or name
    local plain = type(n) == "string" and n:match("^[%l%u_][%w_]*$") and not keyword[n]
    local safe = plain and n or "[" .. safestr(n) .. "]"
    return (path or "") .. (plain and path and "." or "") .. safe, safe
  end
  
  local alphanumsort = type(opts.sortkeys) == "function" and opts.sortkeys or function(k, o, n)
    local maxn, to = tonumber(n) or 12, {number = "a", string = "b"}
    
    local function padnum(d)
      return ("%0" .. tostring(maxn) .. "d"):format(tonumber(d))
    end
    
    table.sort(k, function(a, b)
      return (nil ~= k[a] and 0 or to[type(a)] or "z") .. tostring(a):gsub("%d+", padnum) < (nil ~= k[b] and 0 or to[type(b)] or "z") .. tostring(b):gsub("%d+", padnum)
    end)
  end
  
  local function val2str(t, name, indent, insref, path, plainindex, level)
    local ttype, level, mt = type(t), level or 0, getmetatable(t)
    local spath, sname = safename(path, name)
    local tag = plainindex and (type(name) == "number" and "" or name .. space .. "=" .. space) or nil ~= name and sname .. space .. "=" .. space or ""
    if seen[t] then
      sref[#sref + 1] = spath .. space .. "=" .. space .. seen[t]
      return tag .. "nil" .. comment("ref", level)
    end
    if type(mt) == "table" then
      local to, tr = pcall(function()
        return mt.__tostring(t)
      end)
      local so, sr = pcall(function()
        return mt.__serialize(t)
      end)
      if opts.metatostring ~= false and to or so then
        seen[t] = insref or spath
        t = so and sr or tr
        ttype = type(t)
      end
    end
    if "table" == ttype then
      if level >= maxl then
        return tag .. "{}" .. comment("maxlvl", level)
      end
      seen[t] = insref or spath
      if nil == next(t) then
        return tag .. "{}" .. comment(t, level)
      end
      if maxlen and maxlen < 0 then
        return tag .. "{}" .. comment("maxlen", level)
      end
      local maxn, o, out = math.min(#t, maxnum or #t), {}, {}
      for key = 1, maxn do
        o[key] = key
      end
      if not maxnum or #o < maxnum then
        local n = #o
        for key in pairs(t) do
          if o[key] ~= key then
            n = n + 1
            o[n] = key
          end
        end
      end
      if maxnum and #o > maxnum then
        o[maxnum + 1] = nil
      end
      if opts.sortkeys and maxn < #o then
        alphanumsort(o, t, opts.sortkeys)
      end
      local sparse = sparse and maxn < #o
      for n, key in ipairs(o) do
        local value, ktype, plainindex = t[key], type(key), n <= maxn and not sparse
        if not ((not opts.valignore or not opts.valignore[value]) and (not opts.keyallow or opts.keyallow[key])) or opts.keyignore and opts.keyignore[key] or opts.valtypeignore and opts.valtypeignore[type(value)] or sparse and nil == value then
        elseif "table" == ktype or "function" == ktype or badtype[ktype] then
          if not seen[key] and not globals[key] then
            sref[#sref + 1] = "placeholder"
            local sname = safename(iname, gensym(key))
            sref[#sref] = val2str(key, sname, indent, sname, iname, true)
          end
          sref[#sref + 1] = "placeholder"
          local path = seen[t] .. "[" .. tostring(seen[key] or globals[key] or gensym(key)) .. "]"
          sref[#sref] = path .. space .. "=" .. space .. tostring(seen[value] or val2str(value, nil, indent, path))
        else
          out[#out + 1] = val2str(value, key, indent, insref, seen[t], plainindex, level + 1)
          if maxlen then
            maxlen = maxlen - #out[#out]
            if maxlen < 0 then
              break
            end
          end
        end
      end
      local prefix = string.rep(indent or "", level)
      local head = indent and "{\n" .. prefix .. indent or "{"
      local body = table.concat(out, "," .. (indent and "\n" .. prefix .. indent or space))
      local tail = indent and "\n" .. prefix .. "}" or "}"
      return (custom and custom(tag, head, body, tail, level) or tag .. head .. body .. tail) .. comment(t, level)
    elseif badtype[ttype] then
      seen[t] = insref or spath
      return tag .. globerr(t, level)
    elseif "function" == ttype then
      seen[t] = insref or spath
      if opts.nocode then
        return tag .. "function() --[[..skipped..]] end" .. comment(t, level)
      end
      local ok, res = pcall(string.dump, t)
      local func = ok and "((loadstring or load)(" .. safestr(res) .. ",'@serialized'))" .. comment(t, level)
      return tag .. (func or globerr(t, level))
    else
      return tag .. safestr(t)
    end
  end
  
  local sepr = indent and "\n" or ";" .. space
  local body = val2str(t, name, indent)
  local tail = #sref > 1 and table.concat(sref, sepr) .. sepr or ""
  local warn = opts.comment and #sref > 1 and space .. "--[[incomplete output with shared/self-references skipped]]" or ""
  return not name and body .. warn or "do local " .. body .. sepr .. tail .. "return " .. name .. sepr .. "end"
end

local function deserialize(data, opts)
  local env = opts and opts.safe == false and G or setmetatable({}, {
    __index = function(t, k)
      return t
    end,
    __call = function(t, ...)
      error("cannot call functions")
    end
  })
  local f, res = (loadstring or load)("return " .. data, nil, nil, env)
  if not f then
    f, res = (loadstring or load)(data, nil, nil, env)
  end
  if not f then
    return f, res
  end
  if setfenv then
    setfenv(f, env)
  end
  return pcall(f)
end

local function merge(a, b)
  if b then
    for k, v in pairs(b) do
      a[k] = v
    end
  end
  return a
end

return {
  _NAME = n,
  _COPYRIGHT = c,
  _DESCRIPTION = d,
  _VERSION = v,
  serialize = s,
  load = deserialize,
  dump = function(a, opts)
    return s(a, merge({
      name = "_",
      compact = true,
      sparse = true
    }, opts))
  end,
  line = function(a, opts)
    return s(a, merge({sortkeys = true, comment = true}, opts))
  end,
  block = function(a, opts)
    return s(a, merge({
      indent = "  ",
      sortkeys = true,
      comment = true
    }, opts))
  end
}