XML encoder implementation

examples/http/flow.hcl

@@ -1,31 +1,29 @@
 endpoint "FetchLatestProject" "http" {
-	endpoint = "/"
-	method = "GET"
-	codec = "json"
+  endpoint = "/"
+  method   = "GET"
+  codec    = "json"
 }
 
 flow "FetchLatestProject" {
-	input "com.semaphore.Query" {
-		header = ["Authorization", "Timestamp"]
-	}
+  input "com.semaphore.Query" {
+    header = ["Authorization", "Timestamp"]
+  }
 
-	resource "query" {
-		request "com.semaphore.Todo" "Get" {
-		}
-	}
+  resource "query" {
+    request "com.semaphore.Todo" "Get" {}
+  }
 
-	resource "user" {
-		request "com.semaphore.Users" "Get" {
-		}
-	}
+  resource "user" {
+    request "com.semaphore.Users" "Get" {}
+  }
 
-	output "com.semaphore.Item" {
-		header {
-			Username = "{{ user:username }}"
-		}
+  output "com.semaphore.Item" {
+    header {
+      Username = "{{ user:username }}"
+    }
 
-		id = "{{ query:id }}"
-		title = "{{ query:title }}"
-		completed = "{{ query:completed }}"
-	}
+    id        = "{{ query:id }}"
+    title     = "{{ query:title }}"
+    completed = "{{ query:completed }}"
+  }
 }

pkg/codec/json/array.go

@@ -0,0 +1,113 @@
+package json
+
+import (
+	"github.com/francoispqt/gojay"
+	"github.com/jexia/semaphore/pkg/references"
+	"github.com/jexia/semaphore/pkg/specs"
+	"github.com/jexia/semaphore/pkg/specs/types"
+)
+
+// NewArray constructs a new JSON array encoder/decoder
+func NewArray(resource string, object *specs.Property, ref *references.Reference, refs []references.Store) *Array {
+	keys := 0
+
+	if object.Nested != nil {
+		keys = len(object.Nested)
+	}
+
+	return &Array{
+		resource: resource,
+		specs:    object,
+		items:    refs,
+		ref:      ref,
+		keys:     keys,
+	}
+}
+
+// Array represents a JSON array
+type Array struct {
+	resource string
+	specs    *specs.Property
+	items    []references.Store
+	ref      *references.Reference
+	keys     int
+}
+
+// MarshalJSONArray encodes the array into the given gojay encoder
+func (array *Array) MarshalJSONArray(enc *gojay.Encoder) {
+	for _, store := range array.items {
+		if array.specs.Type == types.Message {
+			object := NewObject(array.resource, array.specs.Nested, store)
+			enc.AddObject(object)
+			continue
+		}
+
+		val := array.specs.Default
+
+		if array.specs.Reference != nil {
+			ref := store.Load("", "")
+			if ref != nil {
+				if ref.Enum != nil && array.specs.Enum != nil {
+					val = array.specs.Enum.Positions[*ref.Enum].Key
+				}
+
+				if val == nil {
+					val = ref.Value
+				}
+			}
+		}
+
+		if val == nil {
+			continue
+		}
+
+		AddType(enc, array.specs.Type, val)
+	}
+}
+
+// UnmarshalJSONArray unmarshals the given specs into the configured reference store
+func (array *Array) UnmarshalJSONArray(dec *gojay.Decoder) error {
+	store := references.NewReferenceStore(array.keys)
+
+	if array.specs.Type == types.Message {
+		object := NewObject(array.resource, array.specs.Nested, store)
+		err := dec.AddObject(object)
+		if err != nil {
+			return err
+		}
+
+		array.ref.Append(store)
+		return nil
+	}
+
+	if array.specs.Type == types.Enum && array.specs.Enum != nil {
+		var key string
+		err := dec.AddString(&key)
+		if err != nil {
+			return err
+		}
+
+		enum := array.specs.Enum.Keys[key]
+		if enum != nil {
+			store.StoreEnum("", "", enum.Position)
+			array.ref.Append(store)
+		}
+
+		return nil
+	}
+
+	val, err := DecodeType(dec, array.specs.Type)
+	if err != nil {
+		return err
+	}
+
+	store.StoreValue("", "", val)
+	array.ref.Append(store)
+
+	return nil
+}
+
+// IsNil returns whether the given array is null or not
+func (array *Array) IsNil() bool {
+	return false
+}

pkg/codec/json/object.go

@@ -138,108 +138,3 @@ func (object *Object) NKeys() int {
 func (object *Object) IsNil() bool {
 	return false
 }
-
-// NewArray constructs a new JSON array encoder/decoder
-func NewArray(resource string, object *specs.Property, ref *references.Reference, refs []references.Store) *Array {
-	keys := 0
-
-	if object.Nested != nil {
-		keys = len(object.Nested)
-	}
-
-	return &Array{
-		resource: resource,
-		specs:    object,
-		items:    refs,
-		ref:      ref,
-		keys:     keys,
-	}
-}
-
-// Array represents a JSON array
-type Array struct {
-	resource string
-	specs    *specs.Property
-	items    []references.Store
-	ref      *references.Reference
-	keys     int
-}
-
-// MarshalJSONArray encodes the array into the given gojay encoder
-func (array *Array) MarshalJSONArray(enc *gojay.Encoder) {
-	for _, store := range array.items {
-		if array.specs.Type == types.Message {
-			object := NewObject(array.resource, array.specs.Nested, store)
-			enc.AddObject(object)
-			continue
-		}
-
-		val := array.specs.Default
-
-		if array.specs.Reference != nil {
-			ref := store.Load("", "")
-			if ref != nil {
-				if ref.Enum != nil && array.specs.Enum != nil {
-					val = array.specs.Enum.Positions[*ref.Enum].Key
-				}
-
-				if val == nil {
-					val = ref.Value
-				}
-			}
-		}
-
-		if val == nil {
-			continue
-		}
-
-		AddType(enc, array.specs.Type, val)
-	}
-}
-
-// UnmarshalJSONArray unmarshals the given specs into the configured reference store
-func (array *Array) UnmarshalJSONArray(dec *gojay.Decoder) error {
-	store := references.NewReferenceStore(array.keys)
-
-	if array.specs.Type == types.Message {
-		object := NewObject(array.resource, array.specs.Nested, store)
-		err := dec.AddObject(object)
-		if err != nil {
-			return err
-		}
-
-		array.ref.Append(store)
-		return nil
-	}
-
-	if array.specs.Type == types.Enum && array.specs.Enum != nil {
-		var key string
-		err := dec.AddString(&key)
-		if err != nil {
-			return err
-		}
-
-		enum := array.specs.Enum.Keys[key]
-		if enum != nil {
-			store.StoreEnum("", "", enum.Position)
-			array.ref.Append(store)
-		}
-
-		return nil
-	}
-
-	val, err := DecodeType(dec, array.specs.Type)
-	if err != nil {
-		return err
-	}
-
-	store.StoreValue("", "", val)
-	array.ref.Append(store)
-
-	return nil
-}
-
-// IsNil returns whether the given array is null or not
-func (array *Array) IsNil() bool {
-	return false
-}

pkg/codec/www-form-urlencoded/errors.go

@@ -18,9 +18,3 @@ type errUnknownLabel string
 func (e errUnknownLabel) Error() string {
 	return fmt.Sprintf("unknown label %q", string(e))
 }
-
-type errUnknownType string
-
-func (e errUnknownType) Error() string {
-	return fmt.Sprintf("unknown data type %q", string(e))
-}

pkg/codec/www-form-urlencoded/errors_test.go

@@ -23,14 +23,3 @@ func TestErrUnknownLabel(t *testing.T) {
 		t.Errorf("error %q was expected to be %q", actual, expected)
 	}
 }
-
-func TestErrUnknownType(t *testing.T) {
-	var (
-		err      = errUnknownType("foo")
-		expected = `unknown data type "foo"`
-	)
-
-	if actual := err.Error(); actual != expected {
-		t.Errorf("error %q was expected to be %q", actual, expected)
-	}
-}

pkg/codec/www-form-urlencoded/form.go

@@ -216,7 +216,7 @@ func decodeElement(resource string, pos int, path []string, values []string, sch
 					store.StoreEnum("", "", enum.Position)
 				}
 			default:
-				value, err := DecodeType(raw, prop.Type)
+				value, err := types.DecodeFromString(raw, prop.Type)
 				if err != nil {
 					return err
 				}
@@ -238,7 +238,7 @@ func decodeElement(resource string, pos int, path []string, values []string, sch
 				ref.Enum = &enum.Position
 			}
 		default:
-			value, err := DecodeType(values[0], prop.Type)
+			value, err := types.DecodeFromString(values[0], prop.Type)
 			if err != nil {
 				return err
 			}

pkg/codec/www-form-urlencoded/form_test.go

@@ -368,7 +368,7 @@ func TestMarshal(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			refs := references.NewReferenceStore(0)
+			refs := references.NewReferenceStore(len(test.input))
 			refs.StoreValues(template.InputResource, "", test.input)
 
 			r, err := manager.Marshal(refs)

pkg/codec/www-form-urlencoded/types.go

@@ -49,51 +49,6 @@ func AddTypeKey(encoder url.Values, key string, typed types.Type, value interfac
 	encoder.Add(key, encoded)
 }
 
-// DecodeType decodes the given property from the given decoder
-func DecodeType(raw string, typed types.Type) (interface{}, error) {
-	switch typed {
-	case types.Double:
-		return strconv.ParseFloat(raw, 64)
-	case types.Float:
-		value, err := strconv.ParseFloat(raw, 64)
-		return float64(value), err
-	case types.Int64:
-		return strconv.ParseInt(raw, 10, 64)
-	case types.Uint64:
-		return strconv.ParseUint(raw, 10, 64)
-	case types.Fixed64:
-		return strconv.ParseUint(raw, 10, 64)
-	case types.Int32:
-		value, err := strconv.ParseInt(raw, 10, 32)
-		return int32(value), err
-	case types.Uint32:
-		value, err := strconv.ParseUint(raw, 10, 32)
-		return uint32(value), err
-	case types.Fixed32:
-		value, err := strconv.ParseUint(raw, 10, 32)
-		return uint32(value), err
-	case types.String:
-		return raw, nil
-	case types.Bool:
-		return strconv.ParseBool(raw)
-	case types.Bytes:
-		return base64.StdEncoding.DecodeString(raw)
-	case types.Sfixed32:
-		value, err := strconv.ParseInt(raw, 10, 32)
-		return int32(value), err
-	case types.Sfixed64:
-		value, err := strconv.ParseInt(raw, 10, 64)
-		return value, err
-	case types.Sint32:
-		value, err := strconv.ParseInt(raw, 10, 32)
-		return int32(value), err
-	case types.Sint64:
-		return strconv.ParseInt(raw, 10, 64)
-	default:
-		return nil, errUnknownType(typed)
-	}
-}
-
 // StringEmpty returns the given value as a string or a empty string if the value is nil
 func StringEmpty(val interface{}) string {
 	if val == nil {