removed tables and fixed arrays data structure (#10)

Author: johri21

convert.go

@@ -28,7 +28,7 @@ func ValueOf(v any) Value {
 		return v
 	case Table:
 		return v
-	case Tables:
+	case Array:
 		return v
 	case int:
 		return Number(v)
@@ -88,10 +88,8 @@ func ValueOf(v any) Value {
 		return Strings(v)
 	case map[string]any:
 		return mapAsTable(v)
-	case []map[string]any:
-		return mapsAsTables(v)
 	case []any:
-		return asArray(v)
+		return sliceAsArray(v)
 	case nil:
 		return Nil{}
 	default:
@@ -109,7 +107,7 @@ func ValueOf(v any) Value {
 	}
 }
 
-// ValueOf converts a value to a LUA-friendly one.
+// resultOf converts a value to a LUA-friendly one.
 func resultOf(v lua.LValue) Value {
 	switch v := v.(type) {
 	case lua.LNumber:
@@ -119,20 +117,25 @@ func resultOf(v lua.LValue) Value {
 	case lua.LBool:
 		return Bool(v)
 	case *lua.LTable:
+
+		// slice cases
 		if top := v.RawGetInt(1); top != nil {
 			switch top.Type() {
-			case lua.LTNil:
-				return asTable(v)
 			case lua.LTNumber:
 				return asNumbers(v)
 			case lua.LTString:
 				return asStrings(v)
 			case lua.LTBool:
 				return asBools(v)
 			case lua.LTTable:
-				return asTables(v)
+				return asArrays(v)
 			}
 		}
+		// map case
+		tbl := asTable(v)
+		if len(tbl) > 0 {
+			return tbl
+		}
 		return Nil{}
 	case *lua.LUserData:
 		return ValueOf(v.Value)
@@ -163,21 +166,25 @@ func asBools(t *lua.LTable) (out Bools) {
 }
 
 func asTable(t *lua.LTable) Table {
-	out := make(Table, t.Len())
+	out := make(Table)
 	t.ForEach(func(k, v lua.LValue) {
-		out[k.String()] = resultOf(v)
+		if k.Type() == lua.LTString {
+			out[k.String()] = resultOf(v)
+		}
 	})
 	return out
 }
 
-func asTables(t *lua.LTable) (out Tables) {
-	t.ForEach(func(_, v lua.LValue) {
-		out = append(out, asTable(v.(*lua.LTable)))
+func asArrays(t *lua.LTable) Array {
+	out, index := make(Array, t.Len()), 0
+	t.ForEach(func(_ lua.LValue, v lua.LValue) {
+		out[index] = resultOf(v)
+		index += 1
 	})
-	return
+	return out
 }
 
-func asArray(input []any) Array {
+func sliceAsArray(input []any) Array {
 	arr := make(Array, 0, len(input))
 	for _, v := range input {
 		arr = append(arr, ValueOf(v))
@@ -193,14 +200,6 @@ func mapAsTable(input map[string]any) Table {
 	return t
 }
 
-func mapsAsTables(input []map[string]any) Tables {
-	t := make(Tables, 0, len(input))
-	for _, v := range input {
-		t = append(t, mapAsTable(v))
-	}
-	return t
-}
-
 // --------------------------------------------------------------------
 
 // lvalueOf converts the script input into a valid lua value

convert_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	lua "github.com/yuin/gopher-lua"
 )
 
 func TestValueOf(t *testing.T) {
@@ -60,3 +61,57 @@ func TestValueOf(t *testing.T) {
 		assert.NotEmpty(t, tc.output.String())
 	}
 }
+
+func TestResultOfArray(t *testing.T) {
+	mp := []map[string]any{
+		{"hello": []float64{1, 2, 3}},
+		{"next": true},
+		{"hello": "world"},
+	}
+	l := lua.NewState()
+	val := lvalueOf(l, mp)
+	res := resultOf(val)
+	array, ok := res.(Array)
+	assert.True(t, ok)
+	assert.Len(t, array, 3)
+
+	resMp := array.Native().([]any)
+	for i, val := range resMp {
+		assert.Equal(t, mp[i], val.(map[string]any))
+	}
+}
+
+func TestResultComplexMap(t *testing.T) {
+	mp := []map[string]any{
+		{"map": []map[string]any{
+			{"e": "f", "g": "h"}},
+		},
+	}
+	l := lua.NewState()
+	val := lvalueOf(l, mp)
+	res := resultOf(val)
+	array, ok := res.(Array)
+	assert.True(t, ok)
+	resMp := array.Native().([]any)
+	assert.Len(t, resMp, len(mp))
+}
+
+func TestResultOfMap(t *testing.T) {
+	mp := map[string]any{
+		"string":  "aj",
+		"numbers": []float64{1, 2, 3},
+		"bool":    true,
+	}
+	l := lua.NewState()
+	val := lvalueOf(l, mp)
+	res := resultOf(val)
+	table, ok := res.(Table)
+	assert.True(t, ok)
+	assert.Len(t, table, 3)
+	resMp, ok := table.Native().(map[string]any)
+	assert.True(t, ok)
+
+	for _, key := range []string{"string", "numbers", "bool"} {
+		assert.Equal(t, mp[key], resMp[key])
+	}
+}

module.go

@@ -103,7 +103,6 @@ func (g *fngen) generate() lua.LGFunction {
 				state.RaiseError(err.Interface().(error).Error())
 				return 0
 			}
-
 			state.Push(lvalueOf(state, out[0].Interface()))
 			return 1
 		}
@@ -190,7 +189,7 @@ func isValid(rt reflect.Type, at int) bool {
 	case typeStrings:
 	case typeBools:
 	case typeTable:
-	case typeTables:
+	case typeArray:
 	default:
 		return false
 	}

module_test.go

@@ -28,7 +28,6 @@ func testModule() Module {
 	must(m.Register("sleep", sleep))
 	must(m.Register("joinMap", joinMap))
 	must(m.Register("enrich", enrich))
-	must(m.Register("batch", batch))
 	must(m.Register("error", errorfunc))
 	must(m.Register("error1", errorfunc1))
 	return m
@@ -80,10 +79,6 @@ func enrich(name String, request Table) (Table, error) {
 	return request, nil
 }
 
-func batch(batch Tables) (Tables, error) {
-	return batch, nil
-}
-
 func Test_Join(t *testing.T) {
 	s, err := newScript("fixtures/join.lua")
 	assert.NoError(t, err)
@@ -180,25 +175,6 @@ func TestEnrich(t *testing.T) {
 	}, out.(Table).Native())
 }
 
-func TestBatch(t *testing.T) {
-	s, err := newScript("fixtures/batch.lua")
-	assert.NoError(t, err)
-
-	input := []map[string]any{
-		{"A": "apples"}, {"B": "oranges"},
-	}
-
-	out, err := s.Run(context.Background(), input)
-
-	assert.NoError(t, err)
-	assert.Equal(t, TypeTables, out.Type())
-	assert.EqualValues(t, input, out.(Tables).Native())
-	assert.Equal(t, Tables{
-		{"A": String("apples")},
-		{"B": String("oranges")},
-	}, out)
-}
-
 func TestErrorMessage(t *testing.T) {
 	s, err := newScript("fixtures/error.lua")
 	assert.NoError(t, err)
@@ -238,23 +214,6 @@ func TestEnrichComplexTable(t *testing.T) {
 	}, v)
 }
 
-func TestEnrichComplexBatch(t *testing.T) {
-	s, err := newScript("fixtures/batch.lua")
-	assert.NoError(t, err)
-
-	v, err := s.Run(context.Background(), []map[string][]float64{{
-		"A": {1, 2, 3},
-		"B": {1, 2, 3},
-	}})
-
-	assert.NoError(t, err)
-	assert.NotNil(t, v)
-	assert.Equal(t, Tables{{
-		"A": Numbers{1, 2, 3},
-		"B": Numbers{1, 2, 3},
-	}}, v)
-}
-
 func TestUserdata(t *testing.T) {
 	s, err := FromString("sandbox", `
 	function main(request)

value.go

@@ -24,7 +24,7 @@ var (
 	typeStrings = reflect.TypeOf(Strings(nil))
 	typeBools   = reflect.TypeOf(Bools(nil))
 	typeTable   = reflect.TypeOf(Table(nil))
-	typeTables  = reflect.TypeOf(Tables(nil))
+	typeArray   = reflect.TypeOf(Array(nil))
 )
 
 var typeMap = map[reflect.Type]Type{
@@ -35,7 +35,7 @@ var typeMap = map[reflect.Type]Type{
 	typeNumbers: TypeNumbers,
 	typeBools:   TypeBools,
 	typeTable:   TypeTable,
-	typeTables:  TypeTables,
+	typeArray:   TypeArray,
 }
 
 // Type represents a type of the value
@@ -51,7 +51,6 @@ const (
 	TypeNumbers
 	TypeStrings
 	TypeTable
-	TypeTables
 	TypeArray
 )
 
@@ -314,41 +313,6 @@ func (v *Table) UnmarshalJSON(b []byte) error {
 
 // --------------------------------------------------------------------
 
-// Tables represents the array of tables
-type Tables []Table
-
-// Type returns the type of the value
-func (v Tables) Type() Type {
-	return TypeTables
-}
-
-// String returns the string representation of the value
-func (v Tables) String() string {
-	return fmt.Sprintf("%v", "(array of tables)")
-}
-
-// Native returns value casted to native type
-func (v Tables) Native() any {
-	var out []map[string]any
-	for _, elem := range v {
-		if tbl, ok := elem.Native().(map[string]any); ok {
-			out = append(out, tbl)
-		}
-	}
-	return out
-}
-
-// lvalue converts the value to a LUA value
-func (v Tables) lvalue(state *lua.LState) lua.LValue {
-	tbl := new(lua.LTable)
-	for _, item := range v {
-		tbl.Append(lvalueOf(state, item))
-	}
-	return tbl
-}
-
-// --------------------------------------------------------------------
-
 // Array represents the array of values
 type Array []Value
 
@@ -364,11 +328,9 @@ func (v Array) String() string {
 
 // Native returns value casted to native type
 func (v Array) Native() any {
-	var out []map[string]any
-	for _, elem := range v {
-		if tbl, ok := elem.Native().(map[string]any); ok {
-			out = append(out, tbl)
-		}
+	out := make([]any, len(v))
+	for i, elem := range v {
+		out[i] = elem.Native()
 	}
 	return out
 }