new transform, and converters

README.md

@@ -21,7 +21,7 @@ API Documentation is available at http://godoc.org/gopkg.in/qntfy/kazaam.v3.
 
 ## Features
 Kazaam is primarily designed to be used as a library for transforming arbitrary JSON.
-It ships with nine built-in transform types, and fifteen built-in converter types,
+It ships with ten built-in transform types, and fifteen built-in converter types,
 described below, which provide significant flexibility in reshaping JSON data.
 
 Also included when you `go get` Kazaam, is a binary implementation, `kazaam` that can be used for
@@ -45,6 +45,7 @@ need arises.
 
 Kazaam currently supports the following built-in transforms:
 - shift
+- steps
 - concat
 - coalesce
 - extract
@@ -157,6 +158,33 @@ within the arguments are preserved, if the whitespace around the arguments is re
 Arguments are passed to the converter functions as a single string, and will require the converter function to parse out any meaningful parameters.
 
 
+### Steps
+The steps transform performs a series of shift transforms with each step working on the ouptput from the last step. This
+transform is very similar to the shift transform, and takes the same optional parameters.
+
+The following example produces the same results as the `Shift` transform example presented earlier. The only difference
+is that the each of the steps are guaranteed to transform in the specified order.
+
+```json 
+{
+  "operation": "steps",
+  "spec": {
+    "steps": [
+      {
+        "object.id": "doc.uid"
+      },
+      {
+        "gid2": "doc.guid[1]"
+      },
+      {
+        "allGuids": "doc.guidObjects[*].id"
+      }
+    ]
+  }
+}
+```
+
+
 ### Concat
 The concat transform allows the combination of fields and literal strings into a single string value.
 ```json
@@ -519,6 +547,9 @@ Kazaam currently supports the following built-in Conveters:
 `substr <num> [<num>]` | converts a string value to a substring value
 `trim` | converts a string value by removing the leading and trailing whitespace characters
 `upper` | converts a string value to uppercase characters
+`len` | converts a string to an integer value equal to the length of the string
+`splitn <string> <num>` | splits a string by a delimiter string and returns the Nth token (1 based)
+`eqs <any>` | returns `true` or `false` based on whether the value matches the parameter
 
 ### Converter Examples ###
 
@@ -950,6 +981,83 @@ produces:
 }
 ```
 
+#### Len ####
+
+Returns the length of a string value
+
+Argument | Description
+---------|------------
+
+example:
+```json
+{
+  "operation": "shift",
+  "spec": {
+    "output": "tests.test_string | len"
+  }
+}
+```
+
+produces:
+```json
+{
+  "output": 19
+}
+```
+
+#### Splitn ####
+
+Returns the Nth token of a string split by a delimiter string
+
+Argument | Description
+---------|------------
+string   | delimiter string
+number   | one based position of token to return
+
+example:
+```json
+{
+  "operation": "shift",
+  "spec": {
+    "output": "tests.test_string | splitn o 2"
+  }
+}
+```
+
+produces:
+```json
+{
+  "output": "wn f"
+}
+```
+
+#### Eqs ####
+
+Returns `true` or `false` based on whether the value equals the parameter
+
+Argument | Description
+---------|------------
+any      | value to compare
+
+
+example:
+```json
+{
+  "operation": "shift",
+  "spec": {
+    "output": "tests.test_string | eqs \"The quick brown fox\""
+  }
+}
+```
+
+produces:
+```json
+{
+  "output": true
+}
+```
+
+
 
 ## Usage
 

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))
+		}
+	}
+
+}

converter/len.go

@@ -0,0 +1,32 @@
+package converter
+
+import (
+	"fmt"
+	"github.com/mbordner/kazaam/transform"
+	"github.com/pkg/errors"
+)
+
+type Len struct {
+	ConverterBase
+}
+
+func (c *Len) 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.IsString() == false {
+		err = errors.New("value must be string for len converter")
+		return
+	}
+
+	origValue := jsonValue.GetStringValue()
+
+	newValue = []byte(fmt.Sprintf("%d", len(origValue)))
+
+	return
+}

converter/len_test.go

@@ -0,0 +1,37 @@
+package converter
+
+import (
+	"github.com/mbordner/kazaam/registry"
+	"strconv"
+	"testing"
+)
+
+func TestLen_Convert(t *testing.T) {
+
+	registry.RegisterConverter("len", &Len{})
+	c := registry.GetConverter("len")
+
+	table := []struct {
+		value     string
+		arguments string
+		expected  string
+	}{
+		{`"The quick brown fox jumps over the lazy dog"`, ``, `43`,},
+		{`"the lazy dog"`, ``, `12`,},
+	}
+
+	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/splitn.go

@@ -0,0 +1,65 @@
+package converter
+
+import (
+	"errors"
+	"github.com/mbordner/kazaam/transform"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+type Splitn struct {
+	ConverterBase
+}
+
+// |substr start end , end is optional, and will be the last char sliced's index + 1,
+// start is the start index and required
+func (c *Splitn) Convert(jsonData []byte, value []byte, args []byte) (newValue []byte, err error) {
+	newValue = value
+
+	var jsonValue, argsValue *transform.JSONValue
+	jsonValue, err = c.NewJSONValue(value)
+	if err != nil {
+		return
+	}
+
+	argsValue, err = transform.NewJSONValue(args)
+	if err != nil {
+		return
+	}
+
+	if jsonValue.IsString() == false || argsValue.IsString() == false {
+		err = errors.New("invalid value or arguments for splintn converter")
+		return
+	}
+
+	var re *regexp.Regexp
+	re, err = regexp.Compile(`(?Us)^(?:\s*)(.+)(?:\s*)(\d+)*(?:\s*)$`)
+	if err != nil {
+		return
+	}
+
+	argsString := argsValue.GetStringValue()
+	origValue := jsonValue.GetStringValue()
+
+	var n int64
+
+	newValue = []byte("null")
+
+	if matches := re.FindStringSubmatch(argsString); matches != nil {
+		n, err = strconv.ParseInt(matches[2], 10, 64)
+		if err != nil {
+			return
+		}
+
+		vals := strings.SplitN(origValue,matches[1],int(n)+1)
+
+		if len(vals) >= int(n) {
+			newValue = []byte(strconv.Quote(vals[int(n)-1]))
+		}
+
+	}
+
+
+	return
+}

converter/splitn_test.go

@@ -0,0 +1,38 @@
+package converter
+
+import (
+	"github.com/mbordner/kazaam/registry"
+	"strconv"
+	"testing"
+)
+
+func TestSplitn_Convert(t *testing.T) {
+
+	registry.RegisterConverter("splitn", &Splitn{})
+	c := registry.GetConverter("splitn")
+
+	table := []struct {
+		value     string
+		arguments string
+		expected  string
+	}{
+		{`"aazbbzcczdd""`, `z 4`, `"dd"`,},
+		{`"abc|def|ghi|jkl|mno"`, `| 2`, `"def"`,},
+		{"\"abc\\ndef\\nghi\\njkl\\nmno\"", "\n 5", `"mno"`,},
+	}
+
+	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))
+		}
+	}
+
+}