Merge pull request #45 from scr-oath/json-empty-object

JSON: Support empty tables being objects; not arrays.

Author: scr-oath

json/api.go

@@ -33,3 +33,10 @@ func Encode(L *lua.LState) int {
 	L.Push(lua.LString(string(data)))
 	return 1
 }
+
+//TableIsObject lua json.tableIsObject marks a table as an object (to distinguish between [] and {})
+func TableIsObject(L *lua.LState) int {
+	table := L.CheckTable(1)
+	L.SetMetatable(table, L.GetTypeMetatable(jsonTableIsObject))
+	return 0
+}

json/decoder.go

@@ -63,6 +63,11 @@ func registerDecoder(L *lua.LState) {
 	}))
 }
 
+func registerJsonDecodedObject(L *lua.LState) {
+	mt := L.NewTypeMetatable(jsonTableIsObject)
+	mt.RawSetString(jsonTableIsObject, lua.LTrue)
+}
+
 func newJSONDecoder(L *lua.LState) int {
 	reader := io.CheckIOReader(L, 1)
 	L.Pop(L.GetTop())

json/example_test.go

@@ -18,7 +18,10 @@ func ExampleDecode() {
     local jsonString = [[{"a":{"b":1}}]]
     local result, err = json.decode(jsonString)
     if err then error(err) end
-    print(inspect(result, {newline="", indent=""}))
+	local remove_all_metatables = function(item, path)
+	  if path[#path] ~= inspect.METATABLE then return item end
+	end
+    print(inspect(result, {process = remove_all_metatables, newline="", indent=""}))
 `
 	if err := state.DoString(source); err != nil {
 		log.Fatal(err.Error())

json/loader.go

@@ -16,6 +16,7 @@ func Preload(L *lua.LState) {
 func Loader(L *lua.LState) int {
 	registerJSONEncoder(L)
 	registerDecoder(L)
+	registerJsonDecodedObject(L)
 
 	t := L.NewTable()
 	L.SetFuncs(t, api)
@@ -24,8 +25,9 @@ func Loader(L *lua.LState) int {
 }
 
 var api = map[string]lua.LGFunction{
-	"decode":      Decode,
-	"encode":      Encode,
-	"new_encoder": newJSONEncoder,
-	"new_decoder": newJSONDecoder,
+	"tableIsObject": TableIsObject,
+	"decode":        Decode,
+	"encode":        Encode,
+	"new_encoder":   newJSONEncoder,
+	"new_decoder":   newJSONDecoder,
 }

json/test/test_api.lua

@@ -9,16 +9,26 @@ function TestJson(t)
 
     local result, err = json.decode(jsonStringWithNull)
     t:Run("decode", function(t)
-        if err then error(err) end
-        if result["a"]["b"] ~= 1 then error("must be decode") end
-        if result["a"]["c"] ~= nil then error("c is not nil") end
+        if err then
+            error(err)
+        end
+        if result["a"]["b"] ~= 1 then
+            error("must be decode")
+        end
+        if result["a"]["c"] ~= nil then
+            error("c is not nil")
+        end
         print("done: json.decode()")
     end)
 
     local result, err = json.encode(result)
     t:Run("encode omits null values", function(t)
-        if err then error(err) end
-        if result ~= jsonString then error("must be encode "..inspect(result)) end
+        if err then
+            error(err)
+        end
+        if result ~= jsonString then
+            error("must be encode " .. inspect(result))
+        end
         print("done: json.encode()")
     end)
 end
@@ -29,7 +39,7 @@ function TestEncoder(t)
     writer, err = io.open(temp_file, 'w')
     assert(not err, err)
     encoder = json.new_encoder(writer)
-    err = encoder:encode({foo="bar", bar="baz"})
+    err = encoder:encode({ foo = "bar", bar = "baz" })
     assert(not err, err)
     writer:close()
 
@@ -44,7 +54,7 @@ end
 function TestEncoderWithStringsBuffer(t)
     builder = strings.new_builder()
     encoder = json.new_encoder(builder)
-    err = encoder:encode({abc="def", num=123, arr={1,2,3}})
+    err = encoder:encode({ abc = "def", num = 123, arr = { 1, 2, 3 } })
     s = strings.trim_suffix(builder:string(), "\n")
     expected = [[{"abc":"def","arr":[1,2,3],"num":123}]]
     assert(s == expected, string.format([['%s' ~= '%s']], expected, s))
@@ -54,7 +64,7 @@ function TestEncoderWithPrettyPrinting(t)
     builder = strings.new_builder()
     encoder = json.new_encoder(builder)
     encoder:set_indent('', "  ")
-    err = encoder:encode({abc="def", num=123, arr={1,2,3}})
+    err = encoder:encode({ abc = "def", num = 123, arr = { 1, 2, 3 } })
     s = strings.trim_suffix(builder:string(), "\n")
     expected = [[{
   "abc": "def",
@@ -118,13 +128,58 @@ end
 function TestEncoder_writing_twice(t)
     writer = strings.new_builder()
     encoder = json.new_encoder(writer)
-    err = encoder:encode({abc="def"})
+    err = encoder:encode({ abc = "def" })
     assert(not err, err)
-    err = encoder:encode({num=123})
+    err = encoder:encode({ num = 123 })
     assert(not err, err)
     s = writer:string()
     expected = [[{"abc":"def"}
 {"num":123}
 ]]
     assert(s == expected, string.format([['%s' ~= '%s']], s, expected))
 end
+
+function TestEncodeDecodeEmpty(t)
+    tests = {
+        {
+            name = [["{} should re-encode to {}"]],
+            input = '{}'
+        },
+        {
+            name = [["[] should re-encode to []"]],
+            input = '[]'
+        },
+        {
+            name = [["object with both {} and [] should re-encode to properly"]],
+            input = [[{"emptyArr":[],"emptyObj":{},"s":"foo bar baz"}]]
+        },
+    }
+    for _, tt in ipairs(tests) do
+        t:Run(tt.name, function(t)
+            t:Logf("input: %s", tt.input)
+            local decoded = json.decode(tt.input)
+            t:Logf("decoded: %s", inspect(decoded))
+            local encoded, err = json.encode(decoded)
+            t:Logf("encoded: %s, err = %s", encoded, tostring(err))
+            assert(not err, err)
+            assert(encoded == tt.input, string.format("expected %s; got %s", tt.input, encoded))
+        end)
+    end
+end
+
+function TestTableIsObject(t)
+    t:Run("empty table is []", function(t)
+        local table = {}
+        local encoded, err = json.encode(table)
+        assert(not err, err)
+        assert(encoded == "[]", string.format("expected []; got %s", encoded))
+    end)
+
+    t:Run("empty table marked as object is {}", function(t)
+        local table = {}
+        json.tableIsObject(table)
+        local encoded, err = json.encode(table)
+        assert(not err, err)
+        assert(encoded == "{}", string.format("expected {}; got %s", encoded))
+    end)
+end

json/value.go

@@ -7,6 +7,8 @@ import (
 	lua "github.com/yuin/gopher-lua"
 )
 
+const jsonTableIsObject = "__jsonTableIsObject"
+
 var (
 	errNested      = errors.New("cannot encode recursively nested tables to JSON")
 	errSparseArray = errors.New("cannot encode sparse array")
@@ -24,6 +26,15 @@ type jsonValue struct {
 	visited map[*lua.LTable]bool
 }
 
+func marshalEmptyTable(table *lua.LTable) []byte {
+	if mt, ok := table.Metatable.(*lua.LTable); ok {
+		if lua.LVAsBool(mt.RawGetString(jsonTableIsObject)) {
+			return []byte("{}")
+		}
+	}
+	return []byte("[]")
+}
+
 func (j jsonValue) MarshalJSON() (data []byte, err error) {
 	switch converted := j.LValue.(type) {
 	case lua.LBool:
@@ -44,7 +55,7 @@ func (j jsonValue) MarshalJSON() (data []byte, err error) {
 
 		switch key.Type() {
 		case lua.LTNil: // empty table
-			data = []byte(`[]`)
+			data = marshalEmptyTable(converted)
 		case lua.LTNumber:
 			arr := make([]jsonValue, 0, converted.Len())
 			expectedKey := lua.LNumber(1)
@@ -108,6 +119,7 @@ func decode(L *lua.LState, value interface{}) lua.LValue {
 		return arr
 	case map[string]interface{}:
 		tbl := L.CreateTable(0, len(converted))
+		L.SetMetatable(tbl, L.GetTypeMetatable(jsonTableIsObject))
 		for key, item := range converted {
 			tbl.RawSetH(lua.LString(key), decode(L, item))
 		}