Make filters context aware

core/condition_test.go

@@ -197,7 +197,7 @@ func floatValue(f float64) Value {
 }
 
 func dynamicValue(s string) Value {
-	return NewDynamicValue([]string{s})
+	return NewDynamicValue(nil, []string{s})
 }
 
 func emptyValue() Value {

core/dynamicvalue.go

@@ -1,6 +1,7 @@
 package core
 
 import (
+	"context"
 	"reflect"
 	"strings"
 )
@@ -10,10 +11,10 @@ type DynamicValue struct {
 	index  Value
 }
 
-func NewDynamicValue(fields []string) *DynamicValue {
+func NewDynamicValue(ctx context.Context, fields []string) *DynamicValue {
 	value := &DynamicValue{fields, nil}
 	last := len(fields) - 1
-	if index, field, ok := unindexDynamicField(fields[last]); ok {
+	if index, field, ok := unindexDynamicField(ctx, fields[last]); ok {
 		fields[last] = field
 		value.index = index
 	}
@@ -62,7 +63,7 @@ func (v *DynamicValue) Underlying() interface{} {
 	return nil
 }
 
-func unindexDynamicField(field string) (Value, string, bool) {
+func unindexDynamicField(ctx context.Context, field string) (Value, string, bool) {
 	end := len(field) - 1
 	if field[end] != ']' {
 		return nil, field, false
@@ -77,7 +78,7 @@ func unindexDynamicField(field string) (Value, string, bool) {
 	if start == 0 {
 		return nil, field, false
 	}
-	value, err := NewParser([]byte(field[start+1:end] + " ")).ReadValue()
+	value, err := NewParser(ctx, []byte(field[start+1:end]+" ")).ReadValue()
 	if err != nil {
 		return nil, field, false
 	}

core/filter.go

@@ -1,10 +1,12 @@
 package core
 
+import "context"
+
 // An interface function
 type Filter func(input interface{}, data map[string]interface{}) interface{}
 
 // A filter factory creates a filter based on the supplied parameters
-type FilterFactory func(parameters []Value) Filter
+type FilterFactory func(ctx context.Context, parameters []Value) Filter
 
 // A map of filter names to filter factories
 var FilterLookup = make(map[string]FilterFactory)

core/parser.go

@@ -1,6 +1,7 @@
 package core
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"strconv"
@@ -21,15 +22,17 @@ const (
 )
 
 type Parser struct {
+	ctx      context.Context
 	Position int
 	Data     []byte
 	Len      int
 	End      int
 	Line     int
 }
 
-func NewParser(data []byte) *Parser {
+func NewParser(ctx context.Context, data []byte) *Parser {
 	parser := &Parser{
+		ctx:      ctx,
 		Position: 0,
 		Data:     data,
 		Len:      len(data),
@@ -257,7 +260,7 @@ func (p *Parser) ReadDynamicValues() (Value, error) {
 			break
 		}
 	}
-	return NewDynamicValue(TrimStrings(values)), nil
+	return NewDynamicValue(p.ctx, TrimStrings(values)), nil
 }
 
 func (p *Parser) ReadName() string {
@@ -315,7 +318,7 @@ func (p *Parser) ReadFilters() ([]Filter, error) {
 				return nil, err
 			}
 		}
-		filters = append(filters, factory(parameters))
+		filters = append(filters, factory(p.ctx, parameters))
 		if p.SkipSpaces() == '|' {
 			p.Forward()
 			continue

core/parser_test.go

@@ -1,6 +1,7 @@
 package core
 
 import (
+	"context"
 	"testing"
 
 	"github.com/karlseguin/gspec"
@@ -310,7 +311,7 @@ func TestParserReadsMultiplePartials(t *testing.T) {
 }
 
 func newParser(s string) *Parser {
-	return NewParser([]byte(s))
+	return NewParser(context.Background(), []byte(s))
 }
 
 func assertParsedConditionGroup(t *testing.T, group Verifiable, data ...interface{}) {

filters/append.go

@@ -1,11 +1,13 @@
 package filters
 
 import (
+	"context"
+
 	"github.com/acstech/liquid/core"
 )
 
 // Creates an append filter
-func AppendFactory(parameters []core.Value) core.Filter {
+func AppendFactory(ctx context.Context, parameters []core.Value) core.Filter {
 	if len(parameters) == 0 {
 		return Noop
 	}

filters/append_test.go

@@ -9,19 +9,19 @@ import (
 
 func TestAppendToAString(t *testing.T) {
 	spec := gspec.New(t)
-	filter := AppendFactory([]core.Value{stringValue("?!")})
+	filter := AppendFactory(nil, []core.Value{stringValue("?!")})
 	spec.Expect(filter("dbz", nil).(string)).ToEqual("dbz?!")
 }
 
 func TestAppendToBytes(t *testing.T) {
 	spec := gspec.New(t)
-	filter := AppendFactory([]core.Value{stringValue("boring")})
+	filter := AppendFactory(nil, []core.Value{stringValue("boring")})
 	spec.Expect(filter([]byte("so"), nil).(string)).ToEqual("soboring")
 }
 
 func TestAppendADynamicValue(t *testing.T) {
 	spec := gspec.New(t)
-	filter := AppendFactory([]core.Value{dynamicValue("local.currency")})
+	filter := AppendFactory(nil, []core.Value{dynamicValue("local.currency")})
 	data := map[string]interface{}{
 		"local": map[string]string{
 			"currency": "$",

filters/capitalize.go

@@ -2,12 +2,13 @@ package filters
 
 import (
 	"bytes"
+	"context"
 
 	"github.com/acstech/liquid/core"
 )
 
 // Creates a capitalize filter
-func CapitalizeFactory(parameters []core.Value) core.Filter {
+func CapitalizeFactory(ctx context.Context, parameters []core.Value) core.Filter {
 	return Capitalize
 }
 

filters/capitalize_test.go

@@ -8,18 +8,18 @@ import (
 
 func TestCapitalizesAString(t *testing.T) {
 	spec := gspec.New(t)
-	filter := CapitalizeFactory(nil)
+	filter := CapitalizeFactory(nil, nil)
 	spec.Expect(string(filter("tiger got to hunt, bird got to fly", nil).([]byte))).ToEqual("Tiger Got To Hunt, Bird Got To Fly")
 }
 
 func TestCapitalizesBytes(t *testing.T) {
 	spec := gspec.New(t)
-	filter := CapitalizeFactory(nil)
+	filter := CapitalizeFactory(nil, nil)
 	spec.Expect(string(filter([]byte("Science is magic that works "), nil).([]byte))).ToEqual("Science Is Magic That Works ")
 }
 
 func TestCapitalizePassThroughOnInvalidType(t *testing.T) {
 	spec := gspec.New(t)
-	filter := CapitalizeFactory(nil)
+	filter := CapitalizeFactory(nil, nil)
 	spec.Expect(filter(123, nil).(int)).ToEqual(123)
 }

filters/date.go

@@ -1,6 +1,7 @@
 package filters
 
 import (
+	"context"
 	"time"
 
 	"github.com/acstech/go-strftime"
@@ -12,7 +13,7 @@ var (
 )
 
 // Creates an date filter
-func DateFactory(parameters []core.Value) core.Filter {
+func DateFactory(ctx context.Context, parameters []core.Value) core.Filter {
 	if len(parameters) == 0 {
 		return Noop
 	}

filters/date_test.go

@@ -17,18 +17,18 @@ func init() {
 
 func TestDateNowWithBasicFormat(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DateFactory([]core.Value{stringValue("%Y %m %d")})
+	filter := DateFactory(nil, []core.Value{stringValue("%Y %m %d")})
 	spec.Expect(filter("now", nil).(string)).ToEqual("2006 01 02")
 }
 
 func TestDateTodayWithBasicFormat(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DateFactory([]core.Value{stringValue("%H:%M:%S%%")})
+	filter := DateFactory(nil, []core.Value{stringValue("%H:%M:%S%%")})
 	spec.Expect(filter("today", nil).(string)).ToEqual("15:04:05%")
 }
 
 func TestDateWithSillyFormat(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DateFactory([]core.Value{stringValue("%w  %U  %j")})
+	filter := DateFactory(nil, []core.Value{stringValue("%w  %U  %j")})
 	spec.Expect(filter("2014-01-10 21:31:28 +0800", nil).(string)).ToEqual("5  02  10")
 }

filters/debug.go

@@ -1,12 +1,13 @@
 package filters
 
 import (
+	"context"
 	"strings"
 
 	"github.com/acstech/liquid/core"
 )
 
-func DebugFactory(parameter []core.Value) core.Filter {
+func DebugFactory(ctx context.Context, parameter []core.Value) core.Filter {
 	debug := &DebugFilter{parameter}
 	return debug.Debug
 }

filters/default.go

@@ -1,6 +1,7 @@
 package filters
 
 import (
+	"context"
 	"reflect"
 
 	"github.com/acstech/liquid/core"
@@ -9,7 +10,7 @@ import (
 var defaultDefaultFilter = (&DefaultFilter{EmptyValue}).Default
 
 // Creates a default filter
-func DefaultFactory(parameters []core.Value) core.Filter {
+func DefaultFactory(ctx context.Context, parameters []core.Value) core.Filter {
 	if len(parameters) == 0 {
 		return defaultDefaultFilter
 	}

filters/default_test.go

@@ -9,18 +9,18 @@ import (
 
 func TestDefaultWithBuiltinValue(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DefaultFactory(nil)
+	filter := DefaultFactory(nil, nil)
 	spec.Expect(filter(nil, nil).(string)).ToEqual("")
 }
 
 func TestDefaultWithValueOnString(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DefaultFactory([]core.Value{stringValue("d")})
+	filter := DefaultFactory(nil, []core.Value{stringValue("d")})
 	spec.Expect(filter("", nil).(string)).ToEqual("d")
 }
 
 func TestDefaultWithValueOnArray(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DefaultFactory([]core.Value{stringValue("n/a")})
+	filter := DefaultFactory(nil, []core.Value{stringValue("n/a")})
 	spec.Expect(filter([]int{}, nil).(string)).ToEqual("n/a")
 }

filters/divideby.go

@@ -1,10 +1,12 @@
 package filters
 
 import (
+	"context"
+
 	"github.com/acstech/liquid/core"
 )
 
-func DivideByFactory(parameters []core.Value) core.Filter {
+func DivideByFactory(ctx context.Context, parameters []core.Value) core.Filter {
 	if len(parameters) == 0 {
 		return Noop
 	}

filters/divideby_test.go

@@ -9,72 +9,72 @@ import (
 
 func TestDivideByAnIntToAnInt(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DivideByFactory([]core.Value{intValue(5)})
+	filter := DivideByFactory(nil, []core.Value{intValue(5)})
 	spec.Expect(filter(43, nil).(float64)).ToEqual(8.6)
 }
 
 func TestDivideByAnIntToAFloat(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DivideByFactory([]core.Value{intValue(2)})
+	filter := DivideByFactory(nil, []core.Value{intValue(2)})
 	spec.Expect(filter(43.3, nil).(float64)).ToEqual(21.65)
 }
 
 func TestDivideByAnIntToAStringAsAnInt(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DivideByFactory([]core.Value{intValue(7)})
+	filter := DivideByFactory(nil, []core.Value{intValue(7)})
 	spec.Expect(filter("33", nil).(float64)).ToEqual(4.714285714285714)
 }
 
 func TestDivideByAnIntToBytesAsAnInt(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DivideByFactory([]core.Value{intValue(7)})
+	filter := DivideByFactory(nil, []core.Value{intValue(7)})
 	spec.Expect(filter([]byte("34"), nil).(float64)).ToEqual(4.857142857142857)
 }
 
 func TestDivideByAnIntToAStringAsAString(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DivideByFactory([]core.Value{intValue(7)})
+	filter := DivideByFactory(nil, []core.Value{intValue(7)})
 	spec.Expect(filter("abc", nil).(string)).ToEqual("abc")
 }
 
 func TestDivideByAnIntToBytesAsAString(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DivideByFactory([]core.Value{intValue(8)})
+	filter := DivideByFactory(nil, []core.Value{intValue(8)})
 	spec.Expect(filter([]byte("abb"), nil).(string)).ToEqual("abb")
 }
 
 func TestDivideByAFloatToAnInt(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DivideByFactory([]core.Value{floatValue(1.10)})
+	filter := DivideByFactory(nil, []core.Value{floatValue(1.10)})
 	spec.Expect(filter(43, nil).(float64)).ToEqual(39.090909090909086)
 }
 
 func TestDivideByAFloatToAFloat(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DivideByFactory([]core.Value{floatValue(5.3)})
+	filter := DivideByFactory(nil, []core.Value{floatValue(5.3)})
 	spec.Expect(filter(43.3, nil).(float64)).ToEqual(8.169811320754716)
 }
 
 func TestDivideByAFloatToAStringAsAnInt(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DivideByFactory([]core.Value{floatValue(7.11)})
+	filter := DivideByFactory(nil, []core.Value{floatValue(7.11)})
 	spec.Expect(filter("33", nil).(float64)).ToEqual(4.641350210970464)
 }
 
 func TestDivideByADynamicIntValue(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DivideByFactory([]core.Value{dynamicValue("count")})
+	filter := DivideByFactory(nil, []core.Value{dynamicValue("count")})
 	spec.Expect(filter("33", params("count", 112)).(float64)).ToEqual(0.29464285714285715)
 }
 
 func TestDivideByADynamicFloatValue(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DivideByFactory([]core.Value{dynamicValue("count")})
+	filter := DivideByFactory(nil, []core.Value{dynamicValue("count")})
 	spec.Expect(filter("12", params("count", 44.2)).(float64)).ToEqual(0.27149321266968324)
 }
 
 func TestDivideByDynamicNoop(t *testing.T) {
 	spec := gspec.New(t)
-	filter := DivideByFactory([]core.Value{dynamicValue("count")})
+	filter := DivideByFactory(nil, []core.Value{dynamicValue("count")})
 	spec.Expect(filter("12", params("count", "22")).(string)).ToEqual("12")
 }