Added yaml.encode and a few test cases for it (#18)

Author: scr-oath

go.mod

@@ -14,6 +14,7 @@ require (
 	github.com/mitchellh/mapstructure v1.3.2 // indirect
 	github.com/montanaflynn/stats v0.6.3
 	github.com/prometheus/client_golang v1.5.1
+	github.com/stretchr/testify v1.5.1
 	github.com/technoweenie/multipartstreamer v1.0.1
 	github.com/yuin/gluamapper v0.0.0-20150323120927-d836955830e7
 	github.com/yuin/gopher-lua v0.0.0-20200603152657-dc2b0ca8b37e

go.sum

@@ -14,7 +14,6 @@ github.com/cbroglie/mustache v1.0.1 h1:ivMg8MguXq/rrz2eu3tw6g3b16+PQhoTn6EZAhst2
 github.com/cbroglie/mustache v1.0.1/go.mod h1:R/RUa+SobQ14qkP4jtx5Vke5sDytONDQXNLPY/PO69g=
 github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cheggaaa/pb v1.0.29 h1:FckUN5ngEk2LpvuG0fw1GEFx6LtyY2pWI/Z2QgCnEYo=
 github.com/cheggaaa/pb/v3 v3.0.5 h1:lmZOti7CraK9RSjzExsY53+WWfub9Qv13B5m4ptEoPE=
 github.com/cheggaaa/pb/v3 v3.0.5/go.mod h1:X1L61/+36nz9bjIsrDU52qHKOQukUQe2Ge+YvGuquCw=
 github.com/chzyer/logex v1.1.10 h1:Swpa1K6QvQznwJRcfTfQJmTE72DqScAa40E+fbHEXEE=

yaml/README.md

@@ -2,6 +2,7 @@
 
 ## Usage
 
+### decode
 ```lua
 local yaml = require("yaml")
 local inspect = require("inspect")
@@ -18,3 +19,14 @@ print(inspect(result, {newline="", indent=""}))
 -- {a = {b = 1}}
 ```
 
+### encode
+```lua
+    local yaml = require("yaml")
+    local encoded, err = yaml.encode({a = {b = 1}})
+    if err then error(err) end
+    print(encoded)
+	-- Output:
+	-- a:
+	--   b: 1
+	--
+```

yaml/api.go

@@ -2,6 +2,8 @@
 package yaml
 
 import (
+	"fmt"
+
 	lua "github.com/yuin/gopher-lua"
 	yaml "gopkg.in/yaml.v2"
 )
@@ -21,6 +23,80 @@ func Decode(L *lua.LState) int {
 	return 1
 }
 
+// Encode lua yaml.encode(any) returns (string, error)
+func Encode(L *lua.LState) int {
+	arg := L.CheckAny(1)
+	var value interface{}
+	err := L.GPCall(func(L *lua.LState) int {
+		visited := make(map[*lua.LTable]bool)
+		value = toYAML(L, visited, arg)
+		return 0
+	}, lua.LNil)
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(err.Error()))
+		return 2
+	}
+	data, err := yaml.Marshal(value)
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(err.Error()))
+		return 2
+	}
+	L.Push(lua.LString(data))
+	return 1
+}
+
+func tableIsSlice(table *lua.LTable) bool {
+	expectedKey := lua.LNumber(1)
+	for key, _ := table.Next(lua.LNil); key != lua.LNil; key, _ = table.Next(key) {
+		if expectedKey != key {
+			return false
+		}
+		expectedKey++
+	}
+	return true
+}
+
+func toYAML(L *lua.LState, visited map[*lua.LTable]bool, value lua.LValue) interface{} {
+	switch value.Type() {
+	case lua.LTNil:
+		return nil
+	case lua.LTBool:
+		return lua.LVAsBool(value)
+	case lua.LTNumber:
+		num := float64(lua.LVAsNumber(value))
+		intNum := int64(num)
+		if num != float64(intNum) {
+			return num
+		}
+		return intNum
+	case lua.LTString:
+		return lua.LVAsString(value)
+	case lua.LTTable:
+		valueTable := value.(*lua.LTable)
+		if visited[valueTable] {
+			L.RaiseError("nested table %s", valueTable)
+		}
+		visited[valueTable] = true
+		if tableIsSlice(valueTable) {
+			ret := make([]interface{}, 0, valueTable.Len())
+			valueTable.ForEach(func(_ lua.LValue, tValue lua.LValue) {
+				ret = append(ret, toYAML(L, visited, tValue))
+			})
+			return ret
+		}
+		ret := make(map[interface{}]interface{})
+		valueTable.ForEach(func(tKey lua.LValue, tValue lua.LValue) {
+			ret[toYAML(L, visited, tKey)] = toYAML(L, visited, tValue)
+		})
+		return ret
+	default:
+		L.RaiseError(fmt.Sprintf("cannot encode values with %s in them", value.Type()))
+		return nil
+	}
+}
+
 func fromYAML(L *lua.LState, value interface{}) lua.LValue {
 	switch converted := value.(type) {
 	case bool:

yaml/api_test.go

@@ -3,13 +3,38 @@ package yaml
 import (
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
 	lua "github.com/yuin/gopher-lua"
 )
 
 func TestApi(t *testing.T) {
-	state := lua.NewState()
-	Preload(state)
-	if err := state.DoFile("./test/test_api.lua"); err != nil {
-		t.Fatalf("execute test: %s\n", err.Error())
-	}
+	// Setup the VM
+	L := lua.NewState()
+	defer L.Close()
+	Preload(L)
+
+	// Load the test cases from file
+	err := L.DoFile("./test/test_api.lua")
+	require.NoError(t, err)
+	test := L.CheckTable(1)
+	L.Pop(1)
+
+	// For each method on the returned test object, invoke it safely with PCall.
+	testCount := 0
+	test.ForEach(func(key lua.LValue, value lua.LValue) {
+		if value.Type() != lua.LTFunction {
+			return
+		}
+		testCount++
+		t.Run(lua.LVAsString(key), func(t *testing.T) {
+			L.Push(value)
+			L.Push(test)
+			require.NoError(t, L.PCall(1, 0, nil))
+		})
+	})
+
+	// Ensure we ran non-zero tests.
+	assert.NotEqual(t, 0, testCount, "test should not be empty")
 }

yaml/example_test.go

@@ -29,3 +29,22 @@ a:
 	// Output:
 	// {a = {b = 1}}
 }
+
+func ExampleEncode() {
+	state := lua.NewState()
+	Preload(state)
+	inspect.Preload(state)
+	source := `
+    local yaml = require("yaml")
+    local encoded, err = yaml.encode({a = {b = 1}})
+    if err then error(err) end
+    print(encoded)
+`
+	if err := state.DoString(source); err != nil {
+		log.Fatal(err.Error())
+	}
+	// Output:
+	// a:
+	//   b: 1
+	//
+}

yaml/loader.go

@@ -22,4 +22,5 @@ func Loader(L *lua.LState) int {
 
 var api = map[string]lua.LGFunction{
 	"decode": Decode,
+	"encode": Encode,
 }

yaml/test/test_api.lua

@@ -1,10 +1,95 @@
 local yaml = require("yaml")
-local text = [[
+local test = {}
+
+-- test decode
+function test:decode()
+    local text = [[
+a:
+  b: 1
+]]
+    local result, err = yaml.decode(text)
+    assert(not err, tostring(err))
+    assert(result["a"]["b"] == 1, tostring(result["a"]["b"]))
+    print("done: yaml.decode()")
+end
+
+-- test decode with no args throws exception
+function test:decode_no_args()
+    local ok, errMsg = pcall(yaml.decode)
+    assert(not ok)
+    assert(errMsg)
+    assert(errMsg:find("(string expected, got nil)"), tostring(errMsg))
+end
+
+-- test encode of decoded(text) == text
+function test:decoded_text_equals_text()
+    local text = [[
 a:
   b: 1
 ]]
-local result, err = yaml.decode(text)
-if err then error(err) end
-if not(result["a"]["b"] == 1) then error("decode error") end
+    local result = { a = { b = 1 } }
+    local encodedResult, err = yaml.encode(result)
+    assert(not err, tostring(err))
+    assert(encodedResult == text, tostring(encodedResult)
+    )
+end
+
+-- test encode(slice) works
+function test:encode_slice_works()
+    local encodedSlice = yaml.encode({ "foo", "bar", "baz" })
+    assert(encodedSlice == [[
+- foo
+- bar
+- baz
+]], tostring(encodedSlice))
+end
+
+-- test encode(sparse slice) works
+function test:encode_sparse_slice_returns_map()
+    local slice = { [0] = "foo", [1] = "bar", [2] = "baz" }
+    local encodedSlice = yaml.encode(slice)
+    assert(encodedSlice == [[
+0: foo
+1: bar
+2: baz
+]], tostring(encodedSlice))
+end
+
+-- test encode(map) works
+function test:encode_map_returns_map()
+    local map = { foo = "bar", bar = { 1, 2, 3.45 } }
+    local encodedMap = yaml.encode(map)
+    assert(encodedMap == [[
+bar:
+- 1
+- 2
+- 3.45
+foo: bar
+]], tostring(encodedMap))
+end
+
+-- test encode(function) fails
+function test:encode_function_fails()
+    local _, errMsg = yaml.encode(function()
+        return ""
+    end)
+    assert(errMsg)
+    assert(errMsg:find("cannot encode values with function in them"), errMsg)
+
+    -- test encode with no args throws exception
+    local ok, errMsg = pcall(yaml.encode)
+    assert(not ok)
+    assert(errMsg:find("(value expected)"), tostring(errMsg))
+end
+
+-- test cycles
+function test:cycles_return_error()
+    local t1 = {}
+    local t2 = { t1 = t1 }
+    t1[t2] = t2
+    local _, errMsg = yaml.encode(t1)
+    assert(errMsg)
+    assert(errMsg:find("nested table"), tostring(errMsg))
+end
 
-print("done: yaml.decode()")
+return test