0.0.8 release

Author: pjdufour

.travis.yml

@@ -39,6 +39,6 @@ script:
   - cd ../cmd/dfl
   - go fmt
   - go build
-  - cd ../../cmd/dfljs
+  - cd ../../cmd/dfl.js
   - go fmt
   - go build

cmd/dfl/main.go

@@ -28,7 +28,9 @@ package main
 import (
 	"flag"
 	"fmt"
+	"log"
 	"os"
+	"reflect"
 	"strings"
 	"time"
 )
@@ -54,6 +56,7 @@ func main() {
 	var verbose bool
 	var version bool
 	var pretty bool
+	var dry_run bool
 	var help bool
 
 	flag.StringVar(&filter_text, "f", "", "The DFL expression to evaulate")
@@ -62,6 +65,7 @@ func main() {
 	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(&dry_run, "dry_run", false, "Do a dry run (parse and compile expression but do not evaluate)")
 	flag.BoolVar(&help, "help", false, "Print help")
 
 	flag.Parse()
@@ -96,31 +100,37 @@ func main() {
 		}
 	}
 
+	funcs := dfl.NewFuntionMapWithDefaults()
+
 	for _, a := range flag.Args() {
 		if !strings.Contains(a, "=") {
-			fmt.Println("Context attribute \"" + a + "\" does not contain \"=\".")
-			os.Exit(1)
+			log.Fatal(errors.New("Context attribute \"" + a + "\" does not contain \"=\"."))
 		}
 		pair := strings.SplitN(a, "=", 2)
 		value, err := dfl.Parse(strings.TrimSpace(pair[1]))
 		if err != nil {
-			fmt.Println(errors.Wrap(err, "Could not parse context variable"))
-			os.Exit(1)
+			log.Fatal(errors.Wrap(err, "Could not parse context variable"))
 		}
 		value = value.Compile()
 		switch value.(type) {
+		case dfl.Array:
+			_, arr, err := value.(dfl.Array).Evaluate(map[string]interface{}{}, map[string]interface{}{}, funcs, GO_DFL_DEFAULT_QUOTES[1:])
+			if err != nil {
+				log.Fatal(errors.Wrap(err, "error evaluating context expression for "+strings.TrimSpace(pair[0])))
+			}
+			ctx[strings.TrimSpace(pair[0])] = arr
 		case dfl.Literal:
 			ctx[strings.TrimSpace(pair[0])] = value.(dfl.Literal).Value
+		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)
 	if err != nil {
-		fmt.Println("Error parsing filter expression.")
-		fmt.Println(err)
-		os.Exit(1)
+		log.Fatal(errors.Wrap(err, "error parsing filter expression"))
 	}
 
 	if pretty {
@@ -164,34 +174,36 @@ func main() {
 		fmt.Println(GO_DFL_DEFAULT_QUOTES[0] + root.Dfl(GO_DFL_DEFAULT_QUOTES[1:], false, 0) + GO_DFL_DEFAULT_QUOTES[0])
 	}
 
-	result, err := root.Evaluate(ctx, dfl.NewFuntionMapWithDefaults(), GO_DFL_DEFAULT_QUOTES[1:])
+	if dry_run {
+		os.Exit(0)
+	}
+
+	_, result, err := root.Evaluate(map[string]interface{}{}, ctx, funcs, GO_DFL_DEFAULT_QUOTES[1:])
 	if err != nil {
-		fmt.Println("Error evaluating expression.")
-		fmt.Println(err)
-		os.Exit(1)
+		log.Fatal(errors.Wrap(err, "error evaluating expression"))
 	}
 
 	switch result.(type) {
 	case bool:
 		result_bool := result.(bool)
 		if verbose {
 			fmt.Println("******************* Result *******************")
-			if result_bool {
-				fmt.Println("true")
-			} else {
-				fmt.Println("false")
-			}
-
+			fmt.Println(dfl.TryFormatLiteral(result, GO_DFL_DEFAULT_QUOTES[1:], false, 0))
 			elapsed := time.Since(start)
 			fmt.Println("Done in " + elapsed.String())
 		}
-
 		if result_bool {
 			os.Exit(0)
 		} else {
 			os.Exit(1)
 		}
 	default:
-		os.Exit(1)
+		if verbose {
+			fmt.Println("******************* Result *******************")
+			fmt.Println("Type:", reflect.TypeOf(result))
+			fmt.Println("Value:", dfl.TryFormatLiteral(result, GO_DFL_DEFAULT_QUOTES[1:], false, 0))
+			elapsed := time.Since(start)
+			fmt.Println("Done in " + elapsed.String())
+		}
 	}
 }

dfl/Add.go

@@ -47,17 +47,17 @@ func (a Add) Compile() Node {
 }
 
 // Evaluate returns the value of this node given Context ctx, and an error if any.
-func (a Add) Evaluate(ctx interface{}, funcs FunctionMap, quotes []string) (interface{}, error) {
+func (a Add) Evaluate(vars map[string]interface{}, ctx interface{}, funcs FunctionMap, quotes []string) (map[string]interface{}, interface{}, error) {
 
-	lv, rv, err := a.EvaluateLeftAndRight(ctx, funcs, quotes)
+	vars, lv, rv, err := a.EvaluateLeftAndRight(vars, ctx, funcs, quotes)
 	if err != nil {
-		return 0, err
+		return vars, 0, err
 	}
 
 	v, err := AddValues(lv, rv)
 	if err != nil {
-		return 0, err
+		return vars, 0, err
 	}
 
-	return v, err
+	return vars, v, err
 }

dfl/Add_test.go

@@ -34,7 +34,7 @@ func TestAdd(t *testing.T) {
 			continue
 		}
 		node = node.Compile()
-		got, err := node.Evaluate(testCase.Context, NewFuntionMapWithDefaults(), DefaultQuotes)
+		_, got, err := node.Evaluate(map[string]interface{}{}, testCase.Context, NewFuntionMapWithDefaults(), DefaultQuotes)
 		if err != nil {
 			t.Errorf(errors.Wrap(err, "Error evaluating expression \""+testCase.Expression+"\"").Error())
 		} else if got != testCase.Result {

dfl/After.go

@@ -42,12 +42,12 @@ func (a After) Compile() Node {
 	return After{&TemporalBinaryOperator{&BinaryOperator{Left: left, Right: right}}}
 }
 
-func (a After) Evaluate(ctx interface{}, funcs FunctionMap, quotes []string) (interface{}, error) {
+func (a After) Evaluate(vars map[string]interface{}, ctx interface{}, funcs FunctionMap, quotes []string) (map[string]interface{}, interface{}, error) {
 
-	v, err := a.EvaluateAndCompare(ctx, funcs, quotes)
+	vars, v, err := a.EvaluateAndCompare(vars, ctx, funcs, quotes)
 	if err != nil {
-		return false, err
+		return vars, false, err
 	}
 
-	return v > 0, nil
+	return vars, v > 0, nil
 }

dfl/After_test.go

@@ -38,7 +38,7 @@ func TestAfter(t *testing.T) {
 			continue
 		}
 		node = node.Compile()
-		got, err := node.Evaluate(testCase.Context, NewFuntionMapWithDefaults(), DefaultQuotes)
+		_, got, err := node.Evaluate(map[string]interface{}{}, testCase.Context, NewFuntionMapWithDefaults(), DefaultQuotes)
 		if err != nil {
 			t.Errorf(errors.Wrap(err, "Error evaluating expression \""+testCase.Expression+"\"").Error())
 		} else if got != testCase.Result {

dfl/And.go

@@ -50,24 +50,24 @@ func (a And) Compile() Node {
 	return And{&BinaryOperator{Left: left, Right: right}}
 }
 
-func (a And) Evaluate(ctx interface{}, funcs FunctionMap, quotes []string) (interface{}, error) {
-	lv, err := a.Left.Evaluate(ctx, funcs, quotes)
+func (a And) Evaluate(vars map[string]interface{}, ctx interface{}, funcs FunctionMap, quotes []string) (map[string]interface{}, interface{}, error) {
+	vars, lv, err := a.Left.Evaluate(vars, ctx, funcs, quotes)
 	if err != nil {
-		return false, err
+		return vars, false, err
 	}
 	switch lv.(type) {
 	case bool:
 		if !lv.(bool) {
-			return false, nil
+			return vars, false, nil
 		}
-		rv, err := a.Right.Evaluate(ctx, funcs, quotes)
+		vars, rv, err := a.Right.Evaluate(vars, ctx, funcs, quotes)
 		if err != nil {
-			return false, err
+			return vars, false, err
 		}
 		switch rv.(type) {
 		case bool:
-			return rv.(bool), nil
+			return vars, rv.(bool), nil
 		}
 	}
-	return false, errors.New("Error evaluating expression " + a.Dfl(quotes, false, 0))
+	return vars, false, errors.New("Error evaluating expression " + a.Dfl(quotes, false, 0))
 }

dfl/And_test.go

@@ -34,7 +34,7 @@ func TestAnd(t *testing.T) {
 			continue
 		}
 		node = node.Compile()
-		got, err := node.Evaluate(testCase.Context, NewFuntionMapWithDefaults(), DefaultQuotes)
+		_, got, err := node.Evaluate(map[string]interface{}{}, testCase.Context, NewFuntionMapWithDefaults(), DefaultQuotes)
 		if err != nil {
 			t.Errorf(errors.Wrap(err, "Error evaluating expression \""+testCase.Expression+"\"").Error())
 		} else if got != testCase.Result {

dfl/Array.go

@@ -52,16 +52,16 @@ func (a Array) Compile() Node {
 	return Literal{Value: TryConvertArray(values)}
 }
 
-func (a Array) Evaluate(ctx interface{}, funcs FunctionMap, quotes []string) (interface{}, error) {
-	values := make([]interface{}, len(a.Nodes))
-	for i, n := range a.Nodes {
-		v, err := n.Evaluate(ctx, funcs, quotes)
+func (a Array) Evaluate(vars map[string]interface{}, ctx interface{}, funcs FunctionMap, quotes []string) (map[string]interface{}, interface{}, error) {
+	values := make([]interface{}, 0, len(a.Nodes))
+	for _, n := range a.Nodes {
+		vars, v, err := n.Evaluate(vars, ctx, funcs, quotes)
 		if err != nil {
-			return values, err
+			return vars, values, err
 		}
-		values[i] = v
+		values = append(values, v)
 	}
-	return TryConvertArray(values), nil
+	return vars, TryConvertArray(values), nil
 }
 
 func (a Array) Attributes() []string {

dfl/AttachLeft.go

@@ -14,6 +14,8 @@ import (
 // AttachLeft attaches the left Node as the left child node to the parent root Node.
 func AttachLeft(root Node, left Node) error {
 	switch root.(type) {
+	case *Declare:
+		root.(*Declare).Left = left
 	case *Pipe:
 		root.(*Pipe).Left = left
 	case *And:
@@ -46,6 +48,8 @@ func AttachLeft(root Node, left Node) error {
 		root.(*Add).Left = left
 	case *Subtract:
 		root.(*Subtract).Left = left
+	case *Divide:
+		root.(*Divide).Left = left
 	case *Before:
 		root.(*Before).Left = left
 	case *After: