lua/json/decode/composite.lua

   1 --[[
   2         Licensed according to the included 'LICENSE' document
   3         Author: Thomas Harning Jr <harningt@gmail.com>
   4 ]]
   5 local pairs = pairs
   6 local type = type
   7
   8 local lpeg = require("lpeg")
   9
  10 local util = require("json.decode.util")
  11 local jsonutil = require("json.util")
  12
  13 local rawset = rawset
  14
  15 local assert = assert
  16 local tostring = tostring
  17
  18 local error = error
  19 local getmetatable = getmetatable
  20
  21 local _ENV = nil
  22
  23 local defaultOptions = {
  24         array = {
  25                 allowEmptyElement = false,
  26                 ignoreLength = false,
  27                 trailingComma = true
  28         },
  29         object = {
  30                 allowEmptyElement = false,
  31                 trailingComma = true,
  32                 number = true,
  33                 identifier = true,
  34                 setObjectKey = rawset
  35         },
  36         calls = {
  37                 allowEmptyElement = false,
  38                 defs = nil,
  39                 -- By default, do not allow undefined calls to be de-serialized as call objects
  40                 allowUndefined = false,
  41                 trailingComma = true
  42         }
  43 }
  44
  45 local modeOptions = {
  46         default = nil,
  47         strict = {
  48                 array = {
  49                         trailingComma = false
  50                 },
  51                 object = {
  52                         trailingComma = false,
  53                         number = false,
  54                         identifier = false
  55                 }
  56         }
  57 }
  58
  59 local function BEGIN_ARRAY(state)
  60         state:push()
  61         state:new_array()
  62 end
  63 local function END_ARRAY(state)
  64         state:end_array()
  65         state:pop()
  66 end
  67
  68 local function BEGIN_OBJECT(state)
  69         state:push()
  70         state:new_object()
  71 end
  72 local function END_OBJECT(state)
  73         state:end_object()
  74         state:pop()
  75 end
  76
  77 local function END_CALL(state)
  78         state:end_call()
  79         state:pop()
  80 end
  81
  82 local function SET_KEY(state)
  83         state:set_key()
  84 end
  85
  86 local function NEXT_VALUE(state)
  87         state:put_value()
  88 end
  89
  90 local function mergeOptions(options, mode)
  91         jsonutil.doOptionMerge(options, true, 'array', defaultOptions, mode and modeOptions[mode])
  92         jsonutil.doOptionMerge(options, true, 'object', defaultOptions, mode and modeOptions[mode])
  93         jsonutil.doOptionMerge(options, true, 'calls', defaultOptions, mode and modeOptions[mode])
  94 end
  95
  96
  97 local isPattern
  98 if lpeg.type then
  99         function isPattern(value)
 100                 return lpeg.type(value) == 'pattern'
 101         end
 102 else
 103         local metaAdd = getmetatable(lpeg.P("")).__add
 104         function isPattern(value)
 105                 return getmetatable(value).__add == metaAdd
 106         end
 107 end
 108
 109
 110 local function generateSingleCallLexer(name, func)
 111         if type(name) ~= 'string' and not isPattern(name) then
 112                 error("Invalid functionCalls name: " .. tostring(name) .. " not a string or LPEG pattern")
 113         end
 114         -- Allow boolean or function to match up w/ encoding permissions
 115         if type(func) ~= 'boolean' and type(func) ~= 'function' then
 116                 error("Invalid functionCalls item: " .. name .. " not a function")
 117         end
 118         local function buildCallCapture(name)
 119                 return function(state)
 120                         if func == false then
 121                                 error("Function call on '" .. name .. "' not permitted")
 122                         end
 123                         state:push()
 124                         state:new_call(name, func)
 125                 end
 126         end
 127         local nameCallCapture
 128         if type(name) == 'string' then
 129                 nameCallCapture = lpeg.P(name .. "(") * lpeg.Cc(name) / buildCallCapture
 130         else
 131                 -- Name matcher expected to produce a capture
 132                 nameCallCapture = name * "(" / buildCallCapture
 133         end
 134         -- Call func over nameCallCapture and value to permit function receiving name
 135         return nameCallCapture
 136 end
 137
 138 local function generateNamedCallLexers(options)
 139         if not options.calls or not options.calls.defs then
 140                 return
 141         end
 142         local callCapture
 143         for name, func in pairs(options.calls.defs) do
 144                 local newCapture = generateSingleCallLexer(name, func)
 145                 if not callCapture then
 146                         callCapture = newCapture
 147                 else
 148                         callCapture = callCapture + newCapture
 149                 end
 150         end
 151         return callCapture
 152 end
 153
 154 local function generateCallLexer(options)
 155         local lexer
 156         local namedCapture = generateNamedCallLexers(options)
 157         if options.calls and options.calls.allowUndefined then
 158                 lexer = generateSingleCallLexer(lpeg.C(util.identifier), true)
 159         end
 160         if namedCapture then
 161                 lexer = lexer and lexer + namedCapture or namedCapture
 162         end
 163         if lexer then
 164                 lexer = lexer + lpeg.P(")") * lpeg.Cc(END_CALL)
 165         end
 166         return lexer
 167 end
 168
 169 local function generateLexer(options)
 170         local ignored = options.ignored
 171         local array_options, object_options = options.array, options.object
 172         local lexer =
 173                 lpeg.P("[") * lpeg.Cc(BEGIN_ARRAY)
 174                 + lpeg.P("]") * lpeg.Cc(END_ARRAY)
 175                 + lpeg.P("{") * lpeg.Cc(BEGIN_OBJECT)
 176                 + lpeg.P("}") * lpeg.Cc(END_OBJECT)
 177                 + lpeg.P(":") * lpeg.Cc(SET_KEY)
 178                 + lpeg.P(",") * lpeg.Cc(NEXT_VALUE)
 179         if object_options.identifier then
 180                 -- Add identifier match w/ validation check that it is in key
 181                 lexer = lexer + lpeg.C(util.identifier) * ignored * lpeg.P(":") * lpeg.Cc(SET_KEY)
 182         end
 183         local callLexers = generateCallLexer(options)
 184         if callLexers then
 185                 lexer = lexer + callLexers
 186         end
 187         return lexer
 188 end
 189
 190 local composite = {
 191         mergeOptions = mergeOptions,
 192         generateLexer = generateLexer
 193 }
 194
 195 return composite