#6, #7, #8, #9

Author: pjdufour

README.md

@@ -16,24 +16,37 @@ import (
 )
 ```
 
-You can also test DFL filtering using a command line tool:
+You can also use the command line tool.
 
 ```
-Usage: dfl -filter INPUT [-verbose] [-version] [-help] [A=1] [B=2]
+Usage: dfl -f INPUT [-verbose] [-version] [-help] [-env] [A=1] [B=2]
 Options:
-  -filter string
+  -env
+    	Load environment variables
+  -f string
     	The DFL expression to evaulate
   -help
     	Print help
   -verbose
     	Provide verbose output
   -version
     	Prints version to stdout
-
 ```
 
 # Examples:
 
+**Environment**
+
+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"
+```
+
+**OpenStreetMap**
+
+You can also use DFL to filter OpenStreetMap features.
+
 ```
 ./dfl -verbose -filter '@pop > (10 - 2)' craft=brewery name=Stone pop=10
 true

cmd/dfl/main.go

@@ -65,20 +65,22 @@ func main() {
 
 	var filter_text string
 
+	var load_env bool
 	var verbose bool
 	var version bool
 	var help bool
 
-	flag.StringVar(&filter_text, "filter", "", "The DFL expression to evaulate")
+	flag.StringVar(&filter_text, "f", "", "The DFL expression to evaulate")
 
+	flag.BoolVar(&load_env, "env", false, "Load environment variables")
 	flag.BoolVar(&verbose, "verbose", false, "Provide verbose output")
 	flag.BoolVar(&version, "version", false, "Prints version to stdout")
 	flag.BoolVar(&help, "help", false, "Print help")
 
 	flag.Parse()
 
 	if help {
-		fmt.Println("Usage: dfl -filter INPUT [-verbose] [-version] [-help] [A=1] [B=2]")
+		fmt.Println("Usage: dfl -f INPUT [-verbose] [-version] [-help] [-env] [A=1] [B=2]")
 		fmt.Println("Options:")
 		flag.PrintDefaults()
 		os.Exit(0)
@@ -87,7 +89,7 @@ func main() {
 		fmt.Println("Run \"dfl -help\" for more information.")
 		os.Exit(0)
 	} else if len(os.Args) == 2 && os.Args[1] == "help" {
-		fmt.Println("Usage: dfl -filter INPUT [-verbose] [-version] [-help] [A=1] [B=2]")
+		fmt.Println("Usage: dfl -f INPUT [-verbose] [-version] [-help] [-env] [A=1] [B=2]")
 		fmt.Println("Options:")
 		flag.PrintDefaults()
 		os.Exit(0)
@@ -99,13 +101,19 @@ 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])
+		}
+	}
 	for _, a := range flag.Args() {
 		if !strings.Contains(a, "=") {
 			fmt.Println("Context attribute \"" + a + "\" does not contain \"=\".")
 			os.Exit(1)
 		}
-		parts := strings.SplitN(a, "=", 2)
-		ctx[parts[0]] = dfl.TryConvertString(parts[1])
+		pair := strings.SplitN(a, "=", 2)
+		ctx[pair[0]] = dfl.TryConvertString(pair[1])
 	}
 
 	root, err := dfl.Parse(filter_text)

dfl/Array.go

@@ -0,0 +1,79 @@
+// =================================================================
+//
+// Copyright (C) 2018 Spatial Current, Inc. - All Rights Reserved
+// Released as open source under the MIT License.  See LICENSE file.
+//
+// =================================================================
+
+package dfl
+
+import (
+	"reflect"
+)
+
+// Array is a Node representing an array of values, which can be either a Literal or Attribute.
+type Array struct {
+	Nodes []Node
+}
+
+func (a Array) Dfl() string {
+	str := "["
+	for i, x := range a.Nodes {
+		if i > 0 {
+			str += ", "
+		}
+		str += x.Dfl()
+	}
+	str = str + "]"
+	return str
+}
+
+func (a Array) Map() map[string]interface{} {
+	return map[string]interface{}{
+		"nodes": a.Nodes,
+	}
+}
+
+// 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.
+// Otherwise returns the original node..
+func (a Array) Compile() Node {
+	values := make([]interface{}, len(a.Nodes))
+	nodes := reflect.ValueOf(a.Nodes)
+	for i := 0; i < nodes.Len(); i++ {
+		n := nodes.Index(i).Interface()
+		switch n.(type) {
+		case *Literal:
+			values[i] = n.(*Literal).Value
+		default:
+			return a
+		}
+	}
+	return Literal{Value: values}
+}
+
+func (a Array) Evaluate(ctx Context, funcs FunctionMap) (interface{}, error) {
+	values := make([]interface{}, len(a.Nodes))
+	for i, n := range a.Nodes {
+		v, err := n.Evaluate(ctx, funcs)
+		if err != nil {
+			return values, err
+		}
+		values[i] = v
+	}
+	return values, nil
+}
+
+func (a Array) Attributes() []string {
+	set := make(map[string]struct{})
+	for _, n := range a.Nodes {
+		for _, x := range n.Attributes() {
+			set[x] = struct{}{}
+		}
+	}
+	attrs := make([]string, 0, len(set))
+	for x := range set {
+		attrs = append(attrs, x)
+	}
+	return attrs
+}

dfl/EvaluateBool.go

@@ -1,7 +1,7 @@
 package dfl
 
 import (
-  "fmt"
+	"fmt"
 	"reflect"
 )
 
@@ -11,15 +11,15 @@ import (
 
 // EvaluateBool returns the boolean value of a node given a context.  If the result is not a bool, then returns an error.
 func EvaluateBool(n Node, ctx Context, funcs FunctionMap) (bool, error) {
-  result, err := n.Evaluate(ctx, funcs)
-  if err != nil {
-    return false, errors.Wrap(err, "Error evaluating expression")
-  }
+	result, err := n.Evaluate(ctx, funcs)
+	if err != nil {
+		return false, errors.Wrap(err, "Error evaluating expression")
+	}
 
-  switch result.(type) {
-  case bool:
-    return result.(bool), nil
-  }
+	switch result.(type) {
+	case bool:
+		return result.(bool), nil
+	}
 
-  return false, errors.New("Evaluation returned a "+fmt.Sprint(reflect.TypeOf(result))+" instead of bool")
+	return false, errors.New("Evaluation returned a " + fmt.Sprint(reflect.TypeOf(result)) + " instead of bool")
 }

dfl/EvaluateInt.go

@@ -0,0 +1,25 @@
+package dfl
+
+import (
+	"fmt"
+	"reflect"
+)
+
+import (
+	"github.com/pkg/errors"
+)
+
+// EvaluateInt returns the int value of a node given a context.  If the result is not an int, then returns an error.
+func EvaluateInt(n Node, ctx Context, funcs FunctionMap) (int, error) {
+	result, err := n.Evaluate(ctx, funcs)
+	if err != nil {
+		return 0, errors.Wrap(err, "Error evaluating expression")
+	}
+
+	switch result.(type) {
+	case int:
+		return result.(int), nil
+	}
+
+	return 0, errors.New("Evaluation returned a " + fmt.Sprint(reflect.TypeOf(result)) + " instead of int")
+}

dfl/EvaluateString.go

@@ -0,0 +1,25 @@
+package dfl
+
+import (
+	"fmt"
+	"reflect"
+)
+
+import (
+	"github.com/pkg/errors"
+)
+
+// EvaluateString returns the string value of a node given a context.  If the result is not a string, then returns an error.
+func EvaluateString(n Node, ctx Context, funcs FunctionMap) (string, error) {
+	result, err := n.Evaluate(ctx, funcs)
+	if err != nil {
+		return "", errors.Wrap(err, "Error evaluating expression")
+	}
+
+	switch result.(type) {
+	case string:
+		return result.(string), nil
+	}
+
+	return "", errors.New("Evaluation returned a " + fmt.Sprint(reflect.TypeOf(result)) + " instead of string")
+}

dfl/In_test.go

@@ -24,7 +24,9 @@ func TestIn(t *testing.T) {
 		NewTestCase("bar in @b", ctx, true),
 		NewTestCase("@a in @b", ctx, true),
 		NewTestCase("bar in [bar, cafe]", ctx, true),
+		NewTestCase("bar in {bar, cafe}", ctx, true),
 		NewTestCase("fast_food in [bar, cafe]", ctx, false),
+		NewTestCase("fast_food in {bar, cafe}", ctx, false),
 		NewTestCase("fast_food in @b", ctx, false),
 	}
 

dfl/Parse.go

@@ -36,6 +36,7 @@ func Parse(in string) (Node, error) {
 	} else {
 
 		parentheses := 0
+		curlybrackets := 0
 		squarebrackets := 0
 		singlequotes := 0
 		doublequotes := 0
@@ -53,6 +54,10 @@ func Parse(in string) (Node, error) {
 				squarebrackets += 1
 			} else if squarebrackets == 1 && c == ']' {
 				squarebrackets -= 1
+			} else if curlybrackets == 0 && c == '{' {
+				curlybrackets += 1
+			} else if curlybrackets == 1 && c == '}' {
+				curlybrackets -= 1
 			} else if singlequotes == 1 && c == '\'' {
 				singlequotes -= 1
 			} else if singlequotes == 0 && c == '\'' {
@@ -63,10 +68,12 @@ func Parse(in string) (Node, error) {
 				doublequotes += 1
 			}
 
-			if parentheses == 0 && squarebrackets == 0 && singlequotes == 0 && doublequotes == 0 && (len(remainder) == 0 || in[i+1] == ' ') {
+			if parentheses == 0 && squarebrackets == 0 && curlybrackets == 0 && singlequotes == 0 && doublequotes == 0 && (len(remainder) == 0 || in[i+1] == ' ') {
 				if len(s) >= 2 && ((strings.HasPrefix(s, "'") && strings.HasSuffix(s, "'")) || (strings.HasPrefix(s, "\"") && strings.HasSuffix(s, "\""))) {
 					return ParseLiteral(s[1:len(s)-1], remainder)
 				} else if len(s) >= 2 && strings.HasPrefix(s, "[") && strings.HasSuffix(s, "]") {
+					return ParseArray(s[1:len(s)-1], remainder)
+				} else if len(s) >= 2 && strings.HasPrefix(s, "{") && strings.HasSuffix(s, "}") {
 					return ParseSet(s[1:len(s)-1], remainder)
 				} else if len(s) >= 2 && strings.HasPrefix(s, "(") && strings.HasSuffix(s, ")") {
 					return ParseSub(s[1:len(s)-1], remainder)