Feature/float converter

converter/add.go

@@ -0,0 +1,67 @@
+package converter
+
+import (
+	"errors"
+	"github.com/mbordner/kazaam/transform"
+	"go/constant"
+	"go/token"
+)
+
+type Add struct {
+	ConverterBase
+}
+
+func (c *Add) Convert(jsonData []byte, value []byte, args []byte) (newValue []byte, err error) {
+
+	var jsonValue, argsValue *transform.JSONValue
+	jsonValue, err = c.NewJSONValue(value)
+	if err != nil {
+		return
+	}
+
+	argsValue, err = c.NewJSONValue(args)
+	if err != nil {
+		return
+	}
+
+	if jsonValue.IsNumber() == false || argsValue.IsString() == false {
+		err = errors.New("invalid value or arguments for add converter")
+		return
+	}
+
+	numStrVal := argsValue.GetStringValue()
+	if numStrVal[0] == '.' {
+		numStrVal = "0" + numStrVal
+	}
+
+	// convert the string to number
+	argsValue, err = c.NewJSONValue([]byte(numStrVal))
+	if err != nil {
+		return
+	}
+
+	if argsValue.IsNumber() == false {
+		err = errors.New("arguments should be a number for add converter")
+		return
+	}
+
+	var left, right constant.Value
+
+	if jsonValue.GetType() == transform.JSONInt {
+		left = constant.MakeInt64(jsonValue.GetIntValue())
+	} else {
+		left = constant.MakeFloat64(jsonValue.GetFloatValue())
+	}
+
+	if argsValue.GetType() == transform.JSONInt {
+		right = constant.MakeInt64(argsValue.GetIntValue())
+	} else {
+		right = constant.MakeFloat64(argsValue.GetFloatValue())
+	}
+
+	result := constant.BinaryOp(left, token.ADD, right)
+
+	newValue = []byte(result.String())
+
+	return
+}

converter/add_test.go

@@ -0,0 +1,37 @@
+package converter
+
+import (
+	"github.com/mbordner/kazaam/registry"
+	"strconv"
+	"testing"
+)
+
+func TestAdd_Convert(t *testing.T) {
+
+	registry.RegisterConverter("add", &Add{})
+	c := registry.GetConverter("add")
+
+	table := []struct {
+		value     string
+		arguments string
+		expected  string
+	}{
+		{`5`, `1`, `6`,},
+		{`5`, `-1`, `4`,},
+	}
+
+	for _, test := range table {
+		v, e := c.Convert(getTestData(), []byte(test.value), []byte(strconv.Quote(test.arguments)))
+
+		if e != nil {
+			t.Error("error running convert function")
+		}
+
+		if string(v) != test.expected {
+			t.Error("unexpected result from convert")
+			t.Log("Expected: {}", test.expected)
+			t.Log("Actual: {}", string(v))
+		}
+	}
+
+}

converter/ceil.go

@@ -0,0 +1,39 @@
+package converter
+
+import (
+	"errors"
+	"github.com/mbordner/kazaam/transform"
+	"go/constant"
+	"math"
+)
+
+type Ceil struct {
+	ConverterBase
+}
+
+func (c *Ceil) Convert(jsonData []byte, value []byte, args []byte) (newValue []byte, err error) {
+
+	newValue = value
+
+	var jsonValue *transform.JSONValue
+	jsonValue, err = c.NewJSONValue(value)
+	if err != nil {
+		return
+	}
+	if jsonValue.IsNumber() == false {
+		err = errors.New("invalid value for ceil converter")
+		return
+	}
+
+	if jsonValue.GetType() == transform.JSONInt {
+		return
+	}
+
+	val := jsonValue.GetFloatValue()
+
+	val = math.Ceil(val)
+
+	newValue = []byte(constant.MakeInt64(int64(val)).String())
+
+	return
+}

converter/ceil_test.go

@@ -0,0 +1,36 @@
+package converter
+
+import (
+	"github.com/mbordner/kazaam/registry"
+	"strconv"
+	"testing"
+)
+
+func TestCeil_Convert(t *testing.T) {
+	registry.RegisterConverter("ceil", &Ceil{})
+	c := registry.GetConverter("ceil")
+
+	table := []struct {
+		value     string
+		arguments string
+		expected  string
+	}{
+		{`5.1`, ``, `6`,},
+		{`5.6`, ``, `6`,},
+		{`0.01`, ``, `1`},
+	}
+
+	for _, test := range table {
+		v, e := c.Convert(getTestData(), []byte(test.value), []byte(strconv.Quote(test.arguments)))
+
+		if e != nil {
+			t.Error("error running convert function")
+		}
+
+		if string(v) != test.expected {
+			t.Error("unexpected result from convert")
+			t.Log("Expected: {}", test.expected)
+			t.Log("Actual: {}", string(v))
+		}
+	}
+}

converter/div.go

@@ -0,0 +1,67 @@
+package converter
+
+import (
+	"errors"
+	"github.com/mbordner/kazaam/transform"
+	"go/constant"
+	"go/token"
+)
+
+type Div struct {
+	ConverterBase
+}
+
+func (c *Div) Convert(jsonData []byte, value []byte, args []byte) (newValue []byte, err error) {
+
+	var jsonValue, argsValue *transform.JSONValue
+	jsonValue, err = c.NewJSONValue(value)
+	if err != nil {
+		return
+	}
+
+	argsValue, err = c.NewJSONValue(args)
+	if err != nil {
+		return
+	}
+
+	if jsonValue.IsNumber() == false || argsValue.IsString() == false {
+		err = errors.New("invalid value or arguments for div converter")
+		return
+	}
+
+	numStrVal := argsValue.GetStringValue()
+	if numStrVal[0] == '.' {
+		numStrVal = "0" + numStrVal
+	}
+
+	// convert the string to number
+	argsValue, err = c.NewJSONValue([]byte(numStrVal))
+	if err != nil {
+		return
+	}
+
+	if argsValue.IsNumber() == false {
+		err = errors.New("arguments should be a number for div converter")
+		return
+	}
+
+	var left, right constant.Value
+
+	if jsonValue.GetType() == transform.JSONInt {
+		left = constant.MakeInt64(jsonValue.GetIntValue())
+	} else {
+		left = constant.MakeFloat64(jsonValue.GetFloatValue())
+	}
+
+	if argsValue.GetType() == transform.JSONInt {
+		right = constant.MakeInt64(argsValue.GetIntValue())
+	} else {
+		right = constant.MakeFloat64(argsValue.GetFloatValue())
+	}
+
+	result := constant.BinaryOp(left, token.QUO, right)
+
+	newValue = []byte(result.String())
+
+	return
+}

converter/div_test.go

@@ -0,0 +1,36 @@
+package converter
+
+import (
+	"github.com/mbordner/kazaam/registry"
+	"strconv"
+	"testing"
+)
+
+func TestDiv_Convert(t *testing.T) {
+	registry.RegisterConverter("div", &Div{})
+	c := registry.GetConverter("div")
+
+	table := []struct {
+		value     string
+		arguments string
+		expected  string
+	}{
+		{`10`, `2`, `5`,},
+		{`5`, `2`, `2.5`,},
+		{`5`, `.5`, `10`},
+	}
+
+	for _, test := range table {
+		v, e := c.Convert(getTestData(), []byte(test.value), []byte(strconv.Quote(test.arguments)))
+
+		if e != nil {
+			t.Error("error running convert function")
+		}
+
+		if string(v) != test.expected {
+			t.Error("unexpected result from convert")
+			t.Log("Expected: {}", test.expected)
+			t.Log("Actual: {}", string(v))
+		}
+	}
+}

converter/eqs.go

@@ -0,0 +1,28 @@
+package converter
+
+import (
+	"bytes"
+	"github.com/mbordner/kazaam/transform"
+)
+
+type Eqs struct {
+	ConverterBase
+}
+
+func (c *Eqs) Convert(jsonData []byte, value []byte, args []byte) (newValue []byte, err error) {
+
+	var argsValue *transform.JSONValue
+	argsValue, err = c.NewJSONValue(args)
+	if err != nil {
+		return
+	}
+
+	argsBytes := []byte(argsValue.GetStringValue())
+
+	if bytes.Equal(value, argsBytes) == true {
+		return []byte("true"), nil
+	}
+
+	return []byte("false"), nil
+
+}

converter/eqs_test.go

@@ -0,0 +1,37 @@
+package converter
+
+import (
+	"strconv"
+	"testing"
+	"github.com/mbordner/kazaam/registry"
+)
+
+func TestEqs_Convert(t *testing.T) {
+
+	registry.RegisterConverter("eqs", &Eqs{})
+	c := registry.GetConverter("eqs")
+
+	table := []struct {
+		value     string
+		arguments string
+		expected  string
+	}{
+		{`"The quick brown fox jumps over the lazy dog"`, `"The quick brown fox jumps over the lazy dog"`, `true`,},
+		{`42`,`42`,`true`,},
+	}
+
+	for _, test := range table {
+		v, e := c.Convert(getTestData(), []byte(test.value), []byte(strconv.Quote(test.arguments)))
+
+		if e != nil {
+			t.Error("error running convert function")
+		}
+
+		if string(v) != test.expected {
+			t.Error("unexpected result from convert")
+			t.Log("Expected: {}", test.expected)
+			t.Log("Actual: {}", string(v))
+		}
+	}
+
+}