Add support for logical expressions

test/unit/binary_expression_test.rb

@@ -2,6 +2,25 @@
 
 require 'test_helper'
 
+class ExecutionSpy
+  attr_reader :called
+  attr_accessor :value
+
+  def initialize(value)
+    @called = false
+    @value = value
+  end
+
+  def to_liquid_value
+    @called = true
+    @value
+  end
+
+  def reset
+    @called = false
+  end
+end
+
 class BinaryExpressionTest < Minitest::Test
   include Liquid
 
@@ -13,6 +32,32 @@ class BinaryExpressionTest < Minitest::Test
     assert_eval(true, BinaryExpression.new("abcd", "contains", "a"))
   end
 
+  def test_logical_expression_short_circuiting
+    spy = ExecutionSpy.new(true)
+
+    # false or spy should try spy
+    assert_eval(true, BinaryExpression.new(false, 'or', spy))
+    assert_equal(true, spy.called)
+
+    spy.reset
+
+    # true or spy should not call spy
+    assert_eval(true, BinaryExpression.new(true, 'or', spy))
+    assert_equal(false, spy.called)
+
+    spy.reset
+
+    # true and spy should try spy
+    assert_eval(true, BinaryExpression.new(true, 'and', spy))
+    assert_equal(true, spy.called)
+
+    spy.reset
+
+    # false and spy should not try spy
+    assert_eval(false, BinaryExpression.new(false, 'and', spy))
+    assert_equal(false, spy.called)
+  end
+
   def test_complex_evaluation
     # 1 > 2 == 2 > 3
     assert_eval(true, BinaryExpression.new(

test/unit/parser_unit_test.rb

@@ -77,6 +77,35 @@ class ParserUnitTest < Minitest::Test
     assert_equal(0..5, p.expression)
   end
 
+  def test_logical
+    p = new_parser("a and b")
+    expr = p.expression
+    assert(expr.is_a?(BinaryExpression))
+    assert_equal('and', expr.operator)
+    assert_equal('a', expr.left_node.name)
+    assert_equal('b', expr.right_node.name)
+
+    p = new_parser("a and b or c")
+    expr = p.expression
+    assert(expr.is_a?(BinaryExpression))
+    assert_equal('and', expr.operator)
+    assert_equal('a', expr.left_node.name)
+    assert_equal('or', expr.right_node.operator)
+    assert_equal('b', expr.right_node.left_node.name)
+    assert_equal('c', expr.right_node.right_node.name)
+
+    p = new_parser("a == b and c or d")
+    expr = p.expression
+    assert(expr.is_a?(BinaryExpression))
+    assert_equal('and', expr.operator)
+    assert_equal('==', expr.left_node.operator)
+    assert_equal('a', expr.left_node.left_node.name)
+    assert_equal('b', expr.left_node.right_node.name)
+    assert_equal('or', expr.right_node.operator)
+    assert_equal('c', expr.right_node.left_node.name)
+    assert_equal('d', expr.right_node.right_node.name)
+  end
+
   def test_equality
     p = new_parser("a == b")
     expr = p.expression