Merge pull request #146 from michaelhvisser/feat/add-shopify-standard-filters

feat: add standard Shopify Liquid filters

Author: osteele

filters/standard_filters.go

@@ -192,6 +192,8 @@ func AddStandardFilters(fd FilterDictionary) { //nolint: gocyclo
 		return a[len(a)-1]
 	})
 	fd.AddFilter("uniq", uniqFilter)
+	fd.AddFilter("where", whereFilter)
+	fd.AddFilter("sum", sumFilter)
 
 	// date filters
 	fd.AddFilter("date", func(t time.Time, format func(string) string) (string, error) {
@@ -279,11 +281,47 @@ func AddStandardFilters(fd FilterDictionary) { //nolint: gocyclo
 
 		return math.Floor(n*exp+0.5) / exp
 	})
+	fd.AddFilter("at_least", func(a, b any) any {
+		if isIntegerType(a) && isIntegerType(b) {
+			ai, bi := toInt64(a), toInt64(b)
+			if ai < bi {
+				return bi
+			}
+			return ai
+		}
+		af, bf := toFloat64(a), toFloat64(b)
+		if af < bf {
+			return bf
+		}
+		return af
+	})
+	fd.AddFilter("at_most", func(a, b any) any {
+		if isIntegerType(a) && isIntegerType(b) {
+			ai, bi := toInt64(a), toInt64(b)
+			if ai > bi {
+				return bi
+			}
+			return ai
+		}
+		af, bf := toFloat64(a), toFloat64(b)
+		if af > bf {
+			return bf
+		}
+		return af
+	})
 
 	// sequence filters
 	fd.AddFilter("size", values.Length)
 
 	// string filters
+	fd.AddFilter("pluralize", func(count any, singular, plural string) string {
+		if toFloat64(count) == 1.0 {
+			return singular
+		}
+		return plural
+	})
+	fd.AddFilter("handleize", handleizeFilter)
+	fd.AddFilter("handle", handleizeFilter)
 	fd.AddFilter("append", func(s, suffix string) string {
 		return s + suffix
 	})
@@ -313,10 +351,24 @@ func AddStandardFilters(fd FilterDictionary) { //nolint: gocyclo
 	fd.AddFilter("remove_first", func(s, old string) string {
 		return strings.Replace(s, old, "", 1)
 	})
+	fd.AddFilter("remove_last", func(s, old string) string {
+		i := strings.LastIndex(s, old)
+		if i < 0 {
+			return s
+		}
+		return s[:i] + s[i+len(old):]
+	})
 	fd.AddFilter("replace", strings.ReplaceAll)
 	fd.AddFilter("replace_first", func(s, old, n string) string {
 		return strings.Replace(s, old, n, 1)
 	})
+	fd.AddFilter("replace_last", func(s, old, n string) string {
+		i := strings.LastIndex(s, old)
+		if i < 0 {
+			return s
+		}
+		return s[:i] + n + s[i+len(old):]
+	})
 	fd.AddFilter("sort_natural", sortNaturalFilter)
 	fd.AddFilter("slice", func(v interface{}, start int, length func(int) int) interface{} {
 		// Are we in the []byte case? Transform []byte to string
@@ -493,6 +545,66 @@ func uniqFilter(a []any) (result []any) {
 	return
 }
 
+var handleizeRe = regexp.MustCompile(`[^a-z0-9]+`)
+
+var omittedWhereTarget = &struct{}{}
+
+func handleizeFilter(s string) string {
+	s = strings.ToLower(s)
+	s = handleizeRe.ReplaceAllString(s, "-")
+	s = strings.Trim(s, "-")
+	return s
+}
+
+func whereFilter(a []any, key string, targetValue func(any) any) (result []any) {
+	keyValue := values.ValueOf(key)
+	target := targetValue(omittedWhereTarget)
+	for _, obj := range a {
+		value := values.ValueOf(obj)
+		prop := value.PropertyValue(keyValue).Interface()
+		if target == omittedWhereTarget {
+			// One-arg form: truthy check
+			if prop != nil && prop != false {
+				result = append(result, obj)
+			}
+		} else {
+			// Two-arg form: equality check using Liquid-compatible
+			// comparison (handles nil, mixed int/float, etc.)
+			if values.Equal(prop, target) {
+				result = append(result, obj)
+			}
+		}
+	}
+	return
+}
+
+func sumFilter(a []any, key func(string) string) any {
+	prop := key("")
+	allInts := true
+	var intTotal int64
+	var floatTotal float64
+	for _, item := range a {
+		if prop != "" {
+			v := values.ValueOf(item)
+			item = v.PropertyValue(values.ValueOf(prop)).Interface()
+		}
+		if allInts && isIntegerType(item) {
+			intTotal += toInt64(item)
+		} else {
+			if allInts {
+				// Switch to float, carry over the int total so far
+				floatTotal = float64(intTotal)
+				allInts = false
+			}
+			floatTotal += toFloat64(item)
+		}
+	}
+	if allInts {
+		return intTotal
+	}
+	return floatTotal
+}
+
 func eqItems(a, b any) bool {
 	if reflect.TypeOf(a).Comparable() && reflect.TypeOf(b).Comparable() {
 		return a == b

filters/standard_filters_test.go

@@ -59,6 +59,17 @@ var filterTests = []struct {
 	{`dup_ints | uniq | join`, "1 2 3"},
 	{`dup_strings | uniq | join`, "one two three"},
 	{`dup_maps | uniq | map: "name" | join`, "m1 m2 m3"},
+	// where
+	{`products | where: "available" | map: "title" | join: ", "`, "Shirt, Pants"},
+	{`products | where: "type", "Shirt" | map: "title" | join: ", "`, "Shirt"},
+	{`products | where: "price", 10.0 | map: "title" | join: ", "`, "Shirt"},
+	{`products | where: "price", 10 | map: "title" | join: ", "`, "Shirt"},
+	{`products | where: "price", nil | map: "title" | join: ", "`, "Hat"},
+	// sum
+	{`"1,2,3" | split: "," | sum`, 6.0},
+	{`prices | sum`, int64(30)},
+	{`products | sum: "price"`, 30.0},
+
 	{`mixed_case_array | sort_natural | join`, "a B c"},
 	{`mixed_case_hash_values | sort_natural: 'key' | map: 'key' | join`, "a B c"},
 
@@ -97,6 +108,22 @@ var filterTests = []struct {
 	{`"Straße" | size`, 6},
 
 	// string filters
+	// pluralize
+	{`1 | pluralize: "item", "items"`, "item"},
+	{`2 | pluralize: "item", "items"`, "items"},
+	{`0 | pluralize: "item", "items"`, "items"},
+	{`1.0 | pluralize: "item", "items"`, "item"},
+	{`1.5 | pluralize: "item", "items"`, "items"},
+	{`"1" | pluralize: "item", "items"`, "item"},
+	{`"2" | pluralize: "item", "items"`, "items"},
+
+	// handleize / handle
+	{`"100% M & Ms!!!" | handleize`, "100-m-ms"},
+	{`"Hello World" | handleize`, "hello-world"},
+	{`"" | handleize`, ""},
+	{`"---already---" | handleize`, "already"},
+	{`"Hello World" | handle`, "hello-world"},
+
 	{`"Take my protein pills and put my helmet on" | replace: "my", "your"`, "Take your protein pills and put your helmet on"},
 	{`"Take my protein pills and put my helmet on" | replace_first: "my", "your"`, "Take your protein pills and put my helmet on"},
 	{`"/my/fancy/url" | append: ".html"`, "/my/fancy/url.html"},
@@ -112,6 +139,10 @@ var filterTests = []struct {
 	{`"apples, oranges, and bananas" | prepend: "Some fruit: "`, "Some fruit: apples, oranges, and bananas"},
 	{`"I strained to see the train through the rain" | remove: "rain"`, "I sted to see the t through the "},
 	{`"I strained to see the train through the rain" | remove_first: "rain"`, "I sted to see the train through the rain"},
+	{`"Hello Hello Hello" | remove_last: "Hello"`, "Hello Hello "},
+	{`"Hello" | remove_last: "xyz"`, "Hello"},
+	{`"Hello Hello Hello" | replace_last: "Hello", "Goodbye"`, "Hello Hello Goodbye"},
+	{`"Hello" | replace_last: "xyz", "abc"`, "Hello"},
 
 	{`"Liquid" | slice: 0`, "L"},
 	{`"Liquid
@@ -236,6 +267,12 @@ Liquid" | slice: 2, 4`, "quid"},
 	{`str_int | plus: 1`, 11.0},
 	{`str_float | plus: 1.0`, 4.5},
 
+	// at_least / at_most
+	{`4 | at_least: 5`, int64(5)},
+	{`6 | at_least: 5`, int64(6)},
+	{`4 | at_most: 5`, int64(4)},
+	{`6 | at_most: 5`, int64(5)},
+
 	{`3 | modulo: 2`, 1.0},
 	{`24 | modulo: 7`, 3.0},
 	// {`183.357 | modulo: 12 | `, 3.357}, // TODO test suit use inexact
@@ -290,6 +327,12 @@ var filterTestBindings = map[string]any{
 		{"weight": 3},
 		{"weight": nil},
 	},
+	"products": []map[string]any{
+		{"title": "Shirt", "type": "Shirt", "price": 10.0, "available": true},
+		{"title": "Pants", "type": "Pants", "price": 20.0, "available": true},
+		{"title": "Hat", "type": "Hat", "price": nil, "available": false},
+	},
+	"prices":               []any{10, 20},
 	"string_with_newlines": "\nHello\nthere\n",
 	"dup_ints":             []int{1, 2, 1, 3},
 	"dup_strings":          []string{"one", "two", "one", "three"},

values/call.go

@@ -99,6 +99,9 @@ func isDefaultFunctionType(typ reflect.Type) bool {
 
 func makeConstantFunction(typ reflect.Type, arg any) reflect.Value {
 	return reflect.MakeFunc(typ, func(args []reflect.Value) []reflect.Value {
+		if arg == nil {
+			return []reflect.Value{reflect.Zero(typ.Out(0))}
+		}
 		return []reflect.Value{reflect.ValueOf(MustConvert(arg, typ.Out(0)))}
 	})
 }

values/call_test.go

@@ -53,6 +53,13 @@ func TestCall_optional(t *testing.T) {
 	value, err = Call(reflect.ValueOf(fn), []any{5, 10})
 	require.NoError(t, err)
 	require.Equal(t, "5,10.", value)
+
+	nilDefault := func(value func(any) any) any {
+		return value("default")
+	}
+	value, err = Call(reflect.ValueOf(nilDefault), []any{nil})
+	require.NoError(t, err)
+	require.Nil(t, value)
 }
 
 func TestCall_variadic(t *testing.T) {