Merge pull request #23 from spatialcurrent/numeric_arrays

Equal/NotEqual support for numeric arrays

Author: pjdufour

.travis.yml

@@ -26,5 +26,5 @@ script:
   - gometalinter --misspell-locale=US --disable-all --enable=misspell --enable=vet ./cmd/dfljs/
   - cd cmd/dfl
   - go fmt
-  - go test
   - go build
+  - go test

README.md

@@ -55,7 +55,6 @@ import (
 </html>
 ```
 
-
 # Examples:
 
 **Environment**
@@ -66,6 +65,22 @@ With the `-env` flag you can use DFL filters against the current environment.
 ./dfl -env -f '@SHELL in [/bin/sh, /bin/bash]' && echo "Shell is set to sh or bash"
 ```
 
+**Arrays**
+
+You can use DFL to filter integer arrays.
+
+```
+./dfl -verbose -f '@a == [1, 2, 3, 4]' 'a=[1, 2, 3, 4]'
+# returns true as exit code 0
+```
+
+You can also use DFl to compare byte arrays.
+
+```
+./dfl -f '@a == [137, 80, 78, 71]' 'a=[0x89, 0x50, 0x4E, 0X47]'
+# returns true as exit code 0
+```
+
 **IP Address Information**
 
 You can use DFL to filter IP addresses.

cmd/dfl/main.go

@@ -101,19 +101,32 @@ func main() {
 	}
 
 	ctx := map[string]interface{}{}
+
 	if load_env {
 		for _, e := range os.Environ() {
-			pair := strings.Split(e, "=")
-			ctx[pair[0]] = dfl.TryConvertString(pair[1])
+			pair := strings.SplitN(e, "=", 2)
+			ctx[strings.TrimSpace(pair[0])] = dfl.TryConvertString(strings.TrimSpace(pair[1]))
 		}
 	}
+
 	for _, a := range flag.Args() {
 		if !strings.Contains(a, "=") {
 			fmt.Println("Context attribute \"" + a + "\" does not contain \"=\".")
 			os.Exit(1)
 		}
 		pair := strings.SplitN(a, "=", 2)
-		ctx[pair[0]] = dfl.TryConvertString(pair[1])
+		value, err := dfl.Parse(strings.TrimSpace(pair[1]))
+		if err != nil {
+			fmt.Println(errors.Wrap(err, "Could not parse context variable"))
+			os.Exit(1)
+		}
+		value = value.Compile()
+		switch value.(type) {
+		case dfl.Literal:
+			ctx[strings.TrimSpace(pair[0])] = value.(dfl.Literal).Value
+		default:
+			ctx[strings.TrimSpace(pair[0])] = dfl.TryConvertString(pair[1])
+		}
 	}
 
 	root, err := dfl.Parse(filter_text)
@@ -123,6 +136,17 @@ func main() {
 		os.Exit(1)
 	}
 
+	if verbose {
+		fmt.Println("******************* Context *******************")
+		out, err := yaml.Marshal(ctx)
+		if err != nil {
+			fmt.Println("Error marshaling context to yaml.")
+			fmt.Println(err)
+			os.Exit(1)
+		}
+		fmt.Println(string(out))
+	}
+
 	if verbose {
 		fmt.Println("******************* Parsed *******************")
 		out, err := yaml.Marshal(root.Map())

dfl/Array.go

@@ -35,7 +35,7 @@ func (a Array) Map() map[string]interface{} {
 }
 
 // Compile returns a compiled version of this node.
-// If all the values of an Set are literals, returns a single Literal with the corresponding Set/slice as its value.
+// If all the values of an Set are literals, returns a single Literal with the corresponding array as its value.
 // Otherwise returns the original node..
 func (a Array) Compile() Node {
 	values := make([]interface{}, len(a.Nodes))
@@ -49,7 +49,7 @@ func (a Array) Compile() Node {
 			return a
 		}
 	}
-	return Literal{Value: values}
+	return Literal{Value: TryConvertArray(values)}
 }
 
 func (a Array) Evaluate(ctx Context, funcs FunctionMap) (interface{}, error) {
@@ -61,7 +61,7 @@ func (a Array) Evaluate(ctx Context, funcs FunctionMap) (interface{}, error) {
 		}
 		values[i] = v
 	}
-	return values, nil
+	return TryConvertArray(values), nil
 }
 
 func (a Array) Attributes() []string {

dfl/CompareNumbers.go

@@ -39,6 +39,14 @@ func CompareNumbers(a interface{}, b interface{}) (int, error) {
 			} else {
 				return 0, nil
 			}
+		case uint8:
+			if a.(int) > int(b.(uint8)) {
+				return 1, nil
+			} else if a.(int) < int(b.(uint8)) {
+				return -1, nil
+			} else {
+				return 0, nil
+			}
 		case float64:
 			if float64(a.(int)) > b.(float64) {
 				return 1, nil
@@ -66,6 +74,14 @@ func CompareNumbers(a interface{}, b interface{}) (int, error) {
 			} else {
 				return 0, nil
 			}
+		case uint8:
+			if a.(int64) > int64(b.(uint8)) {
+				return 1, nil
+			} else if a.(int64) < int64(b.(uint8)) {
+				return -1, nil
+			} else {
+				return 0, nil
+			}
 		case float64:
 			if float64(a.(int64)) > b.(float64) {
 				return 1, nil
@@ -75,6 +91,41 @@ func CompareNumbers(a interface{}, b interface{}) (int, error) {
 				return 0, nil
 			}
 		}
+	case uint8:
+		switch b.(type) {
+		case int:
+			if int(a.(uint8)) > int(b.(int)) {
+				return 1, nil
+			} else if int(a.(uint8)) < int(b.(int)) {
+				return -1, nil
+			} else {
+				return 0, nil
+			}
+		case int64:
+			if int64(a.(uint8)) > b.(int64) {
+				return 1, nil
+			} else if int64(a.(uint8)) < b.(int64) {
+				return -1, nil
+			} else {
+				return 0, nil
+			}
+		case uint8:
+			if a.(uint8) > b.(uint8) {
+				return 1, nil
+			} else if a.(uint8) < b.(uint8) {
+				return -1, nil
+			} else {
+				return 0, nil
+			}
+		case float64:
+			if float64(a.(uint8)) > b.(float64) {
+				return 1, nil
+			} else if float64(a.(uint8)) < b.(float64) {
+				return -1, nil
+			} else {
+				return 0, nil
+			}
+		}
 	case float64:
 		switch b.(type) {
 		case int:
@@ -93,6 +144,14 @@ func CompareNumbers(a interface{}, b interface{}) (int, error) {
 			} else {
 				return 0, nil
 			}
+		case uint8:
+			if a.(float64) > float64(b.(uint8)) {
+				return 1, nil
+			} else if a.(float64) < float64(b.(uint8)) {
+				return -1, nil
+			} else {
+				return 0, nil
+			}
 		case float64:
 			if a.(float64) > b.(float64) {
 				return 1, nil

dfl/CompareStrings.go

@@ -0,0 +1,34 @@
+// =================================================================
+//
+// Copyright (C) 2018 Spatial Current, Inc. - All Rights Reserved
+// Released as open source under the MIT License.  See LICENSE file.
+//
+// =================================================================
+
+package dfl
+
+import (
+	"regexp"
+	"strings"
+)
+
+import (
+	"github.com/pkg/errors"
+)
+
+// CompareStrings compares parameter a and parameter b.
+// The parameters must be of type string.
+// Returns true if a like b.
+func CompareStrings(lvs string, rvs string) (bool, error) {
+
+	if len(rvs) == 0 {
+		return len(lvs) == 0, nil
+	}
+
+	pattern, err := regexp.Compile("^" + strings.Replace(rvs, "%", ".*", -1) + "$")
+	if err != nil {
+		return false, errors.Wrap(err, "Error comparing strings \""+lvs+"\" and \""+rvs+"\"")
+	}
+
+	return pattern.MatchString(lvs), nil
+}

dfl/Counter.go

@@ -0,0 +1,20 @@
+package dfl
+
+type Counter map[string]int
+
+func (c Counter) Len() int {
+	return len(c)
+}
+
+func (c Counter) Has(key string) bool {
+	_, ok := c[key]
+	return ok
+}
+
+func (c Counter) Increment(key string) {
+	if count, ok := c[key]; ok {
+		c[key] = count + 1
+	} else {
+		c[key] = 1
+	}
+}