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