feat: add named filter arguments and allow_false for default filter

expressions/builders.go

@@ -19,7 +19,19 @@ func makeContainsExpr(e1, e2 func(Context) values.Value) func(Context) values.Va
 	}
 }
 
-func makeFilter(fn valueFn, name string, args []valueFn) valueFn {
+// filterArgs holds both positional and keyword arguments for a filter.
+type filterArgs struct {
+	positional []valueFn
+	keyword    []keywordArg
+}
+
+// keywordArg represents a named argument (e.g., allow_false: true).
+type keywordArg struct {
+	name string
+	val  valueFn
+}
+
+func makeFilter(fn valueFn, name string, args *filterArgs) valueFn {
 	return func(ctx Context) values.Value {
 		result, err := ctx.ApplyFilter(name, fn, args)
 		if err != nil {

expressions/context.go

@@ -4,7 +4,7 @@ import "github.com/osteele/liquid/values"
 
 // Context is the expression evaluation context. It maps variables names to values.
 type Context interface {
-	ApplyFilter(string, valueFn, []valueFn) (any, error)
+	ApplyFilter(string, valueFn, *filterArgs) (any, error)
 	// Clone returns a copy with a new variable binding map
 	// (so that copy.Set does effect the source context.)
 	Clone() Context

expressions/expressions.y

@@ -23,7 +23,7 @@ func init() {
    cyclefn  func(string) Cycle
    loop     Loop
    loopmods loopModifiers
-   filter_params []valueFn
+   filter_params *filterArgs
 }
 %type<f> expr rel filtered cond
 %type<filter_params> filter_params
@@ -142,9 +142,11 @@ filtered:
 ;
 
 filter_params:
-  expr { $$ = []valueFn{$1} }
+  expr { $$ = &filterArgs{positional: []valueFn{$1}} }
 | filter_params ',' expr
-  { $$ = append($1, $3) }
+  { $1.positional = append($1.positional, $3); $$ = $1 }
+| filter_params ',' KEYWORD expr
+  { $1.keyword = append($1.keyword, keywordArg{$3, $4}); $$ = $1 }
 
 rel:
   filtered

expressions/filters.go

@@ -80,7 +80,7 @@ func isClosureInterfaceType(t reflect.Type) bool {
 	return closureType.ConvertibleTo(t) && !interfaceType.ConvertibleTo(t)
 }
 
-func (ctx *context) ApplyFilter(name string, receiver valueFn, params []valueFn) (any, error) {
+func (ctx *context) ApplyFilter(name string, receiver valueFn, params *filterArgs) (any, error) {
 	filter, ok := ctx.filters[name]
 	if !ok {
 		if !ctx.LaxFilters {
@@ -95,16 +95,26 @@ func (ctx *context) ApplyFilter(name string, receiver valueFn, params []valueFn)
 	args := argsBuf[:1]
 	args[0] = receiver(ctx).Interface()
 
-	for i, param := range params {
-		if i+1 < fr.Type().NumIn() && isClosureInterfaceType(fr.Type().In(i+1)) {
-			expr, err := Parse(param(ctx).Interface().(string))
-			if err != nil {
-				panic(err)
+	if params != nil {
+		for i, param := range params.positional {
+			if i+1 < fr.Type().NumIn() && isClosureInterfaceType(fr.Type().In(i+1)) {
+				expr, err := Parse(param(ctx).Interface().(string))
+				if err != nil {
+					panic(err)
+				}
+
+				args = append(args, closure{expr, ctx})
+			} else {
+				args = append(args, param(ctx).Interface())
 			}
+		}
 
-			args = append(args, closure{expr, ctx})
-		} else {
-			args = append(args, param(ctx).Interface())
+		if len(params.keyword) > 0 {
+			kwargs := make(map[string]any, len(params.keyword))
+			for _, kw := range params.keyword {
+				kwargs[kw.name] = kw.val(ctx).Interface()
+			}
+			args = append(args, kwargs)
 		}
 	}
 

expressions/filters_test.go

@@ -34,7 +34,7 @@ func TestContext_runFilter(t *testing.T) {
 		return "<" + s + ">"
 	})
 	ctx := NewContext(map[string]any{"x": 10}, cfg)
-	out, err := ctx.ApplyFilter("f1", receiver, []valueFn{})
+	out, err := ctx.ApplyFilter("f1", receiver, nil)
 	require.NoError(t, err)
 	require.Equal(t, "<self>", out)
 
@@ -43,15 +43,15 @@ func TestContext_runFilter(t *testing.T) {
 		return fmt.Sprintf("(%s, %s)", a, b)
 	})
 	ctx = NewContext(map[string]any{"x": 10}, cfg)
-	out, err = ctx.ApplyFilter("with_arg", receiver, []valueFn{constant("arg")})
+	out, err = ctx.ApplyFilter("with_arg", receiver, &filterArgs{positional: []valueFn{constant("arg")}})
 	require.NoError(t, err)
 	require.Equal(t, "(self, arg)", out)
 
 	// TODO optional argument
 	// TODO error return
 
 	// extra argument
-	_, err = ctx.ApplyFilter("with_arg", receiver, []valueFn{constant(1), constant(2)})
+	_, err = ctx.ApplyFilter("with_arg", receiver, &filterArgs{positional: []valueFn{constant(1), constant(2)}})
 	require.Error(t, err)
 	require.Contains(t, err.Error(), "wrong number of arguments")
 	require.Contains(t, err.Error(), "given 2")
@@ -70,11 +70,42 @@ func TestContext_runFilter(t *testing.T) {
 		return fmt.Sprintf("(%v, %v)", a, value), nil
 	})
 	ctx = NewContext(map[string]any{"x": 10}, cfg)
-	out, err = ctx.ApplyFilter("closure", receiver, []valueFn{constant("x |add: y")})
+	out, err = ctx.ApplyFilter("closure", receiver, &filterArgs{positional: []valueFn{constant("x |add: y")}})
 	require.NoError(t, err)
 	require.Equal(t, "(self, 11)", out)
 }
 
+func TestContext_runFilter_keywordArgs(t *testing.T) {
+	cfg := NewConfig()
+	constant := func(value any) valueFn {
+		return func(Context) values.Value { return values.ValueOf(value) }
+	}
+	receiver := constant("self")
+
+	cfg.AddFilter("with_kwargs", func(s string, kwargs ...map[string]any) string {
+		if len(kwargs) > 0 {
+			if v, ok := kwargs[0]["option"]; ok {
+				return fmt.Sprintf("(%s, option=%v)", s, v)
+			}
+		}
+		return fmt.Sprintf("(%s)", s)
+	})
+
+	ctx := NewContext(map[string]any{}, cfg)
+
+	// without keyword args
+	out, err := ctx.ApplyFilter("with_kwargs", receiver, nil)
+	require.NoError(t, err)
+	require.Equal(t, "(self)", out)
+
+	// with keyword args
+	out, err = ctx.ApplyFilter("with_kwargs", receiver, &filterArgs{
+		keyword: []keywordArg{{name: "option", val: constant(true)}},
+	})
+	require.NoError(t, err)
+	require.Equal(t, "(self, option=true)", out)
+}
+
 // TestAddSafeFilterNilMap verifies that AddSafeFilter doesn't panic
 // when called on a Config with nil filters map
 func TestAddSafeFilterNilMap(t *testing.T) {