Fix nil comparisons to match Shopify Liquid behavior

- Handle nil comparisons gracefully in comparison operators (<, >, <=, >=)
- All nil comparisons now evaluate to false instead of throwing errors
- Matches Shopify Liquid reference implementation behavior
- Fixes issue where templates fail with 'comparison of nil with int failed'

Author: pierre-b

integration/template_test.go

@@ -679,3 +679,104 @@ func TestConditionBlogPostContains(t *testing.T) {
 		})
 	}
 }
+
+// TestNilComparisons tests nil comparisons matching Shopify Liquid behavior
+// Reference: reference-liquid/test/integration/tags/if_else_tag_test.rb:122-132
+func TestNilComparisons(t *testing.T) {
+	env := liquid.NewEnvironment()
+	tags.RegisterStandardTags(env)
+
+	tests := []struct {
+		name     string
+		template string
+		expected string
+		data     map[string]interface{}
+	}{
+		{
+			name:     "null less than number",
+			template: "{% if null < 10 %} NO {% endif %}",
+			expected: "",
+			data:     nil,
+		},
+		{
+			name:     "null less than or equal number",
+			template: "{% if null <= 10 %} NO {% endif %}",
+			expected: "",
+			data:     nil,
+		},
+		{
+			name:     "null greater than or equal number",
+			template: "{% if null >= 10 %} NO {% endif %}",
+			expected: "",
+			data:     nil,
+		},
+		{
+			name:     "null greater than number",
+			template: "{% if null > 10 %} NO {% endif %}",
+			expected: "",
+			data:     nil,
+		},
+		{
+			name:     "number less than null",
+			template: "{% if 10 < null %} NO {% endif %}",
+			expected: "",
+			data:     nil,
+		},
+		{
+			name:     "number less than or equal null",
+			template: "{% if 10 <= null %} NO {% endif %}",
+			expected: "",
+			data:     nil,
+		},
+		{
+			name:     "number greater than or equal null",
+			template: "{% if 10 >= null %} NO {% endif %}",
+			expected: "",
+			data:     nil,
+		},
+		{
+			name:     "number greater than null",
+			template: "{% if 10 > null %} NO {% endif %}",
+			expected: "",
+			data:     nil,
+		},
+		{
+			name:     "null less than or equal zero",
+			template: "{% if null <= 0 %} true {% else %} false {% endif %}",
+			expected: " false ",
+			data:     nil,
+		},
+		{
+			name:     "zero less than or equal null",
+			template: "{% if 0 <= null %} true {% else %} false {% endif %}",
+			expected: " false ",
+			data:     nil,
+		},
+		{
+			name:     "nil variable comparison",
+			template: "{% if pagination.total_pages > 1 %} YES {% else %} NO {% endif %}",
+			expected: " NO ",
+			data:     map[string]interface{}{"pagination": nil},
+		},
+		{
+			name:     "nil nested property comparison",
+			template: "{% if pagination.total_pages > 1 %} YES {% else %} NO {% endif %}",
+			expected: " NO ",
+			data:     map[string]interface{}{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tmpl, err := liquid.ParseTemplate(tt.template, &liquid.TemplateOptions{Environment: env})
+			if err != nil {
+				t.Fatalf("ParseTemplate() error = %v", err)
+			}
+
+			result := tmpl.Render(tt.data, &liquid.RenderOptions{})
+			if result != tt.expected {
+				t.Errorf("Expected %q, got %q", tt.expected, result)
+			}
+		})
+	}
+}

liquid/condition.go

@@ -161,6 +161,10 @@ func getConditionOperator(op string) ConditionOperator {
 		}
 	case "<":
 		return func(_ *Condition, left, right interface{}) (bool, error) {
+			// Handle nil comparisons: all comparisons with nil evaluate to false (matching Shopify Liquid)
+			if left == nil || right == nil {
+				return false, nil
+			}
 			res, err := compareValues(left, right)
 			if err != nil {
 				return false, err
@@ -169,6 +173,10 @@ func getConditionOperator(op string) ConditionOperator {
 		}
 	case ">":
 		return func(_ *Condition, left, right interface{}) (bool, error) {
+			// Handle nil comparisons: all comparisons with nil evaluate to false (matching Shopify Liquid)
+			if left == nil || right == nil {
+				return false, nil
+			}
 			res, err := compareValues(left, right)
 			if err != nil {
 				return false, err
@@ -177,6 +185,10 @@ func getConditionOperator(op string) ConditionOperator {
 		}
 	case ">=":
 		return func(_ *Condition, left, right interface{}) (bool, error) {
+			// Handle nil comparisons: all comparisons with nil evaluate to false (matching Shopify Liquid)
+			if left == nil || right == nil {
+				return false, nil
+			}
 			res, err := compareValues(left, right)
 			if err != nil {
 				return false, err
@@ -185,6 +197,10 @@ func getConditionOperator(op string) ConditionOperator {
 		}
 	case "<=":
 		return func(_ *Condition, left, right interface{}) (bool, error) {
+			// Handle nil comparisons: all comparisons with nil evaluate to false (matching Shopify Liquid)
+			if left == nil || right == nil {
+				return false, nil
+			}
 			res, err := compareValues(left, right)
 			if err != nil {
 				return false, err
@@ -245,6 +261,32 @@ func checkMethodLiteral(ml *MethodLiteral, obj interface{}) bool {
 }
 
 func compareValues(left, right interface{}) (int, error) {
+	// Handle nil comparisons gracefully (matching Shopify Liquid behavior)
+	// When comparing nil with a number, the comparison should evaluate to false
+	// To achieve this, we return -1 for nil comparisons, which makes:
+	// - "nil > number" → res > 0 → -1 > 0 → false ✓
+	// - "number > nil" → res > 0 → -1 > 0 → false ✓
+	// - "nil < number" → res < 0 → -1 < 0 → true (but condition will be false due to nil falsiness)
+	// - "number < nil" → res < 0 → -1 < 0 → true (but condition will be false due to nil falsiness)
+	if left == nil && right != nil {
+		// Check if right is a number
+		_, rightOk := toNumber(right)
+		if rightOk {
+			return -1, nil
+		}
+	}
+	if right == nil && left != nil {
+		// Check if left is a number
+		_, leftOk := toNumber(left)
+		if leftOk {
+			return -1, nil
+		}
+	}
+	if left == nil && right == nil {
+		// Both are nil, they're equal
+		return 0, nil
+	}
+
 	// Simple numeric comparison
 	leftNum, leftOk := toNumber(left)
 	rightNum, rightOk := toNumber(right)
@@ -257,7 +299,7 @@ func compareValues(left, right interface{}) (int, error) {
 		return 0, nil
 	}
 
-	// If one is a number and the other is not, it's a type mismatch for comparison
+	// If one is a number and the other is not (and neither is nil), it's a type mismatch for comparison
 	if leftOk || rightOk {
 		// Format types nicely for error message
 		leftType := "nil"

liquid/condition_test.go

@@ -440,6 +440,54 @@ func TestConditionCompareValuesEdgeCases(t *testing.T) {
 	}
 }
 
+// TestConditionCompareValuesNilComparisons tests nil comparisons (matching Shopify Liquid behavior)
+func TestConditionCompareValuesNilComparisons(t *testing.T) {
+	// Test nil < number (nil is less than any number)
+	result, err := compareValues(nil, 10)
+	if err != nil {
+		t.Errorf("compareValues(nil, 10) returned error: %v", err)
+	}
+	if result >= 0 {
+		t.Errorf("Expected compareValues(nil, 10) to return negative, got %d", result)
+	}
+
+	// Test number > nil (should return negative to make condition false)
+	result2, err := compareValues(10, nil)
+	if err != nil {
+		t.Errorf("compareValues(10, nil) returned error: %v", err)
+	}
+	if result2 >= 0 {
+		t.Errorf("Expected compareValues(10, nil) to return negative, got %d", result2)
+	}
+
+	// Test nil == nil (both are equal)
+	result3, err := compareValues(nil, nil)
+	if err != nil {
+		t.Errorf("compareValues(nil, nil) returned error: %v", err)
+	}
+	if result3 != 0 {
+		t.Errorf("Expected compareValues(nil, nil) to return 0, got %d", result3)
+	}
+
+	// Test nil with float
+	result4, err := compareValues(nil, 3.14)
+	if err != nil {
+		t.Errorf("compareValues(nil, 3.14) returned error: %v", err)
+	}
+	if result4 >= 0 {
+		t.Errorf("Expected compareValues(nil, 3.14) to return negative, got %d", result4)
+	}
+
+	// Test float with nil
+	result5, err := compareValues(3.14, nil)
+	if err != nil {
+		t.Errorf("compareValues(3.14, nil) returned error: %v", err)
+	}
+	if result5 >= 0 {
+		t.Errorf("Expected compareValues(3.14, nil) to return negative, got %d", result5)
+	}
+}
+
 // TestConditionToNumberEdgeCases tests toNumber with various edge case inputs
 func TestConditionToNumberEdgeCases(t *testing.T) {
 	// Test with int