* Move expression handling from variable.rb to expression.rb

* Update test suite to validate parity
* Remove parentheses handling
* Split boolean into comparison and logical expressions

.github/dependabot.yaml

@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: github-actions
-    directory: "/"
-    schedule:
-      interval: weekly

.github/workflows/liquid.yml

@@ -31,8 +31,8 @@ jobs:
           - { ruby: ruby-head, allowed-failure: false, rubyopt: "--yjit" }
     name: Test Ruby ${{ matrix.entry.ruby }}
     steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@dffc446db9ba5a0c4446edb5bca1c5c473a806c5 # v1.235.0
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.entry.ruby }}
           bundler-cache: true
@@ -45,8 +45,8 @@ jobs:
   memory_profile:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@dffc446db9ba5a0c4446edb5bca1c5c473a806c5 # v1.235.0
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
         with:
           bundler-cache: true
       - run: bundle exec rake memory_profile:run

History.md

@@ -1,7 +1,6 @@
 # Liquid Change Log
 
-## 5.8.7
-* Expose body content in the `Doc` tag [James Meng]
+## 5.8.1 (unreleased)
 
 ## 5.8.1
 

lib/liquid.rb

@@ -80,6 +80,8 @@ require 'liquid/variable_lookup'
 require 'liquid/range_lookup'
 require 'liquid/resource_limits'
 require 'liquid/expression'
+require 'liquid/expression/comparison_expression'
+require 'liquid/expression/logical_expression'
 require 'liquid/template'
 require 'liquid/condition'
 require 'liquid/utils'

lib/liquid/expression.rb

@@ -51,6 +51,9 @@ module Liquid
       end
 
       def inner_parse(markup, ss, cache)
+        return LogicalExpression.parse(markup, ss, cache)    if LogicalExpression.logical?(markup)
+        return ComparisonExpression.parse(markup, ss, cache) if ComparisonExpression.comparison?(markup)
+
         if (markup.start_with?("(") && markup.end_with?(")")) && markup =~ RANGES_REGEX
           return RangeLookup.parse(
             Regexp.last_match(1),

lib/liquid/expression/comparison_expression.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Liquid
+  class Expression
+    class ComparisonExpression
+      COMPARISON_REGEX = /\A\s*(.+?)\s*(==|!=|<>|<=|>=|<|>|contains)\s*(.+)\s*\z/
+
+      class << self
+        def comparison?(markup)
+          markup =~ COMPARISON_REGEX
+        end
+
+        def parse(markup, ss, cache)
+          match = markup.match(COMPARISON_REGEX)
+
+          if match
+            left = Expression.parse(match[1].strip, ss, cache)
+            operator = match[2].strip
+            right = Expression.parse(match[3].strip, ss, cache)
+
+            return Condition.new(left, operator, right)
+          end
+
+          Condition.new(parse(markup, ss, cache), nil, nil)
+        end
+      end
+    end
+  end
+end

lib/liquid/expression/logical_expression.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Liquid
+  class Expression
+    class LogicalExpression
+      LOGICAL_REGEX = /\A\s*(.+?)\s+(and|or)\s+(.+)\s*\z/i
+      EXPRESSIONS_AND_OPERATORS = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o
+      BOOLEAN_OPERATORS = ['and', 'or'].freeze
+
+      class << self
+        def logical?(markup)
+          markup =~ LOGICAL_REGEX
+        end
+
+        def parse(markup, ss, cache)
+          expressions = markup.scan(EXPRESSIONS_AND_OPERATORS)
+
+          last_expr = expressions.pop
+
+          condition = if ComparisonExpression.comparison?(last_expr)
+            ComparisonExpression.parse(last_expr, ss, cache)
+          elsif LOGICAL_REGEX.match?(last_expr)
+            LogicalExpression.parse(last_expr, ss, cache)
+          else
+            Condition.new(Expression.parse(last_expr, ss, cache), nil, nil)
+          end
+
+          until expressions.empty?
+            operator = expressions.pop.to_s.strip
+            next unless BOOLEAN_OPERATORS.include?(operator)
+
+            expr = expressions.pop.to_s.strip
+
+            new_condition = if ComparisonExpression.comparison?(expr)
+              ComparisonExpression.parse(expr, ss, cache)
+            elsif LOGICAL_REGEX.match?(expr)
+              LogicalExpression.parse(expr, ss, cache)
+            else
+              Condition.new(Expression.parse(expr, ss, cache), nil, nil)
+            end
+
+            if operator == 'and'
+              new_condition.and(condition)
+            else # operator == 'or'
+              new_condition.or(condition)
+            end
+
+            condition = new_condition
+          end
+
+          condition
+        end
+      end
+    end
+  end
+end

lib/liquid/lexer.rb

@@ -14,6 +14,8 @@ module Liquid
     COMPARISON_LESS_THAN = [:comparison, "<"].freeze
     COMPARISON_LESS_THAN_OR_EQUAL = [:comparison, "<="].freeze
     COMPARISON_NOT_EQUAL_ALT = [:comparison, "<>"].freeze
+    BOOLEAN_AND = [:boolean_operator, "and"].freeze
+    BOOLEAN_OR = [:boolean_operator, "or"].freeze
     DASH = [:dash, "-"].freeze
     DOT = [:dot, "."].freeze
     DOTDOT = [:dotdot, ".."].freeze
@@ -151,6 +153,10 @@ module Liquid
               # Special case for "contains"
               output << if type == :id && t == "contains" && output.last&.first != :dot
                 COMPARISON_CONTAINS
+              elsif type == :id && t == "and" && output.last&.first != :dot
+                BOOLEAN_AND
+              elsif type == :id && t == "or" && output.last&.first != :dot
+                BOOLEAN_OR
               else
                 [type, t]
               end

lib/liquid/parser.rb

@@ -48,7 +48,7 @@ module Liquid
 
     def expression
       token = @tokens[@p]
-      case token[0]
+      expr = case token[0]
       when :id
         str = consume
         str << variable_lookups
@@ -69,6 +69,21 @@ module Liquid
       else
         raise SyntaxError, "#{token} is not a valid expression"
       end
+      if look(:comparison)
+        operator = consume(:comparison)
+        left     = expr
+        right    = expression
+
+        "#{left} #{operator} #{right}"
+      elsif look(:boolean_operator)
+        operator = consume(:boolean_operator)
+        left     = expr
+        right    = expression
+
+        "#{left} #{operator} #{right}"
+      else
+        expr
+      end
     end
 
     def argument

lib/liquid/standardfilters.rb

@@ -3,6 +3,7 @@
 require 'cgi'
 require 'base64'
 require 'bigdecimal'
+
 module Liquid
   module StandardFilters
     MAX_I32 = (1 << 31) - 1
@@ -711,16 +712,7 @@ module Liquid
       input.gsub(/\r?\n/, "<br />\n")
     end
 
-    # @liquid_public_docs
-    # @liquid_type filter
-    # @liquid_category date
-    # @liquid_summary
-    #   Formats a date according to a specified format string.
-    # @liquid_description
-    #   This filter formats a date using various format specifiers. If the format string is empty,
-    #   the original input is returned. If the input cannot be converted to a date, the original input is returned.
-    #
-    #   The following format specifiers can be used:
+    # Reformat a date using Ruby's core Time#strftime( string ) -> string
     #
     #   %a - The abbreviated weekday name (``Sun'')
     #   %A - The  full  weekday  name (``Sunday'')
@@ -749,8 +741,8 @@ module Liquid
     #   %Y - Year with century
     #   %Z - Time zone name
     #   %% - Literal ``%'' character
-    # @liquid_syntax date | date: string
-    # @liquid_return [string]
+    #
+    #   See also: http://www.ruby-doc.org/core/Time.html#method-i-strftime
     def date(input, format)
       str_format = Utils.to_s(format)
       return input if str_format.empty?
@@ -997,7 +989,7 @@ module Liquid
     end
 
     def raise_property_error(property)
-      raise Liquid::ArgumentError, "cannot select the property '#{Utils.to_s(property)}'"
+      raise Liquid::ArgumentError, "cannot select the property '#{property}'"
     end
 
     def apply_operation(input, operand, operation)
@@ -1069,10 +1061,7 @@ module Liquid
       end
 
       def uniq(&block)
-        to_a.uniq do |item|
-          item = Utils.to_liquid_value(item)
-          block ? yield(item) : item
-        end
+        to_a.uniq(&block)
       end
 
       def compact

lib/liquid/tags/assign.rb

@@ -9,10 +9,6 @@ module Liquid
   #   Creates a new variable.
   # @liquid_description
   #   You can create variables of any [basic type](/docs/api/liquid/basics#types), [object](/docs/api/liquid/objects), or object property.
-  #
-  #   > Caution:
-  #   > Predefined Liquid objects can be overridden by variables with the same name.
-  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
   # @liquid_syntax
   #   {% assign variable_name = value %}
   # @liquid_syntax_keyword variable_name The name of the variable being created.

lib/liquid/tags/capture.rb

@@ -9,10 +9,6 @@ module Liquid
   #   Creates a new variable with a string value.
   # @liquid_description
   #   You can create complex strings with Liquid logic and variables.
-  #
-  #   > Caution:
-  #   > Predefined Liquid objects can be overridden by variables with the same name.
-  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
   # @liquid_syntax
   #   {% capture variable %}
   #     value

lib/liquid/tags/decrement.rb

@@ -7,14 +7,10 @@ module Liquid
   # @liquid_name decrement
   # @liquid_summary
   #   Creates a new variable, with a default value of -1, that's decreased by 1 with each subsequent call.
-  #
-  #   > Caution:
-  #   > Predefined Liquid objects can be overridden by variables with the same name.
-  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
   # @liquid_description
   #   Variables that are declared with `decrement` are unique to the [layout](/themes/architecture/layouts), [template](/themes/architecture/templates),
   #   or [section](/themes/architecture/sections) file that they're created in. However, the variable is shared across
-  #   [snippets](/themes/architecture/snippets) included in the file.
+  #   [snippets](/themes/architecture#snippets) included in the file.
   #
   #   Similarly, variables that are created with `decrement` are independent from those created with [`assign`](/docs/api/liquid/tags/assign)
   #   and [`capture`](/docs/api/liquid/tags/capture). However, `decrement` and [`increment`](/docs/api/liquid/tags/increment) share

lib/liquid/tags/doc.rb

@@ -13,20 +13,17 @@ module Liquid
   #   Liquid code inside will be parsed but not executed. This facilitates
   #   tooling support for features like code completion, linting, and inline
   #   documentation.
-  #
-  #   For detailed documentation syntax and examples, see the
-  #   [`LiquidDoc` reference](/docs/storefronts/themes/tools/liquid-doc).
-  #
   # @liquid_syntax
   #   {% doc %}
   #     Renders a message.
   #
-  #     @param {string} foo - A string value.
-  #     @param {string} [bar] - An optional string value.
+  #     @param {string} foo - A foo value.
+  #     @param {string} [bar] - An optional bar value.
   #
   #     @example
   #     {% render 'message', foo: 'Hello', bar: 'World' %}
   #   {% enddoc %}
+  #   {{ foo }}, {{ bar }}!
   class Doc < Block
     NO_UNEXPECTED_ARGS = /\A\s*\z/
 
@@ -36,8 +33,6 @@ module Liquid
     end
 
     def parse(tokens)
-      @body = +""
-
       while (token = tokens.shift)
         tag_name = token =~ BlockBody::FullTokenPossiblyInvalid && Regexp.last_match(2)
 
@@ -45,10 +40,8 @@ module Liquid
 
         if tag_name == block_delimiter
           parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
-          @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
           return
         end
-        @body << token unless token.empty?
       end
 
       raise_tag_never_closed(block_name)
@@ -59,11 +52,11 @@ module Liquid
     end
 
     def blank?
-      @body.empty?
+      true
     end
 
     def nodelist
-      [@body]
+      []
     end
 
     private

lib/liquid/tags/include.rb

@@ -6,7 +6,7 @@ module Liquid
   # @liquid_category theme
   # @liquid_name include
   # @liquid_summary
-  #   Renders a [snippet](/themes/architecture/snippets).
+  #   Renders a [snippet](/themes/architecture#snippets).
   # @liquid_description
   #   Inside the snippet, you can access and alter variables that are [created](/docs/api/liquid/tags/variable-tags) outside of the
   #   snippet.

lib/liquid/tags/increment.rb

@@ -7,14 +7,10 @@ module Liquid
   # @liquid_name increment
   # @liquid_summary
   #   Creates a new variable, with a default value of 0, that's increased by 1 with each subsequent call.
-  #
-  #   > Caution:
-  #   > Predefined Liquid objects can be overridden by variables with the same name.
-  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
   # @liquid_description
   #   Variables that are declared with `increment` are unique to the [layout](/themes/architecture/layouts), [template](/themes/architecture/templates),
   #   or [section](/themes/architecture/sections) file that they're created in. However, the variable is shared across
-  #   [snippets](/themes/architecture/snippets) included in the file.
+  #   [snippets](/themes/architecture#snippets) included in the file.
   #
   #   Similarly, variables that are created with `increment` are independent from those created with [`assign`](/docs/api/liquid/tags/assign)
   #   and [`capture`](/docs/api/liquid/tags/capture). However, `increment` and [`decrement`](/docs/api/liquid/tags/decrement) share

lib/liquid/tags/render.rb

@@ -6,7 +6,7 @@ module Liquid
   # @liquid_category theme
   # @liquid_name render
   # @liquid_summary
-  #   Renders a [snippet](/themes/architecture/snippets) or [app block](/themes/architecture/sections/section-schema#render-app-blocks).
+  #   Renders a [snippet](/themes/architecture#snippets) or [app block](/themes/architecture/sections/section-schema#render-app-blocks).
   # @liquid_description
   #   Inside snippets and app blocks, you can't directly access variables that are [created](/docs/api/liquid/tags/variable-tags) outside
   #   of the snippet or app block. However, you can [specify variables as parameters](/docs/api/liquid/tags/render#render-passing-variables-to-a-snippet)

lib/liquid/utils.rb

@@ -2,9 +2,6 @@
 
 module Liquid
   module Utils
-    DECIMAL_REGEX = /\A-?\d+\.\d+\z/
-    UNIX_TIMESTAMP_REGEX = /\A\d+\z/
-
     def self.slice_collection(collection, from, to)
       if (from != 0 || !to.nil?) && collection.respond_to?(:load_slice)
         collection.load_slice(from, to)
@@ -55,7 +52,7 @@ module Liquid
       when Numeric
         obj
       when String
-        DECIMAL_REGEX.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
+        /\A-?\d+\.\d+\z/.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
       else
         if obj.respond_to?(:to_number)
           obj.to_number
@@ -76,7 +73,7 @@ module Liquid
       case obj
       when 'now', 'today'
         Time.now
-      when UNIX_TIMESTAMP_REGEX, Integer
+      when /\A\d+\z/, Integer
         Time.at(obj.to_i)
       when String
         Time.parse(obj)

lib/liquid/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Liquid
-  VERSION = "5.8.7"
+  VERSION = "5.8.1"
 end

test/integration/standard_filter_test.rb

@@ -560,23 +560,12 @@ class StandardFiltersTest < Minitest::Test
     end
   end
 
-  def test_map_with_value_property
-    array = [
-      { "handle" => "alpha", "value" => "A" },
-      { "handle" => "beta", "value" => "B" },
-      { "handle" => "gamma", "value" => "C" }
-    ]
-
-    assert_template_result("A B C", "{{ array | map: 'value' | join: ' ' }}", { "array" => array })
-  end
-
-  def test_map_returns_input_with_no_property
+  def test_map_returns_empty_with_no_property
     foo = [
       [1],
       [2],
       [3],
     ]
-
     assert_raises(Liquid::ArgumentError) do
       @filters.map(foo, nil)
     end
@@ -1044,23 +1033,6 @@ class StandardFiltersTest < Minitest::Test
     assert_template_result(expected_output, template, { "array" => array })
   end
 
-  def test_where_with_empty_string_is_a_no_op
-    environment = { "array" => ["alpha", "beta", "gamma"] }
-    expected_output = "alpha beta gamma"
-    template = "{{ array | where: '' | join: ' ' }}"
-
-    assert_template_result(expected_output, template, environment)
-  end
-
-  def test_where_with_nil_is_a_no_op
-    environment = { "array" => ["alpha", "beta", "gamma"] }
-    template = "{{ array | where: nil | join: ' ' }}"
-
-    assert_raises(Liquid::ArgumentError) do
-      assert_template_result("alpha beta gamma", template, environment)
-    end
-  end
-
   def test_where_with_value
     array = [
       { "handle" => "alpha", "ok" => true },
@@ -1296,33 +1268,6 @@ class StandardFiltersTest < Minitest::Test
     assert_template_result("0", "{{ input | sum: 'subtotal' }}", { "input" => input })
   end
 
-  def test_sum_with_non_string_property
-    input = [{ true => 1 }, { 1.0 => 0.2, 1 => -0.3 }, { 1..5 => 0.4 }]
-
-    assert_equal(1, @filters.sum(input, true))
-    assert_equal(0.2, @filters.sum(input, 1.0))
-    assert_equal(-0.3, @filters.sum(input, 1))
-    assert_equal(0.4, @filters.sum(input, (1..5)))
-    assert_equal(0, @filters.sum(input, nil))
-    assert_equal(0, @filters.sum(input, ""))
-  end
-
-  def test_uniq_with_to_liquid_value
-    input = [StringDrop.new("foo"), StringDrop.new("bar"), "foo"]
-    expected = [StringDrop.new("foo"), StringDrop.new("bar")]
-    result = @filters.uniq(input)
-
-    assert_equal(expected, result)
-  end
-
-  def test_uniq_with_to_liquid_value_pick_correct_classes
-    input = ["foo", StringDrop.new("foo"), StringDrop.new("bar")]
-    expected = [String, StringDrop]
-    result = @filters.uniq(input).map(&:class)
-
-    assert_equal(expected, result)
-  end
-
   private
 
   def with_timezone(tz)

test/test_helper.rb

@@ -146,35 +146,6 @@ class BooleanDrop < Liquid::Drop
   end
 end
 
-class StringDrop < Liquid::Drop
-  include Comparable
-
-  def initialize(value)
-    super()
-    @value = value
-  end
-
-  def to_liquid_value
-    @value
-  end
-
-  def to_s
-    @value
-  end
-
-  def to_str
-    @value
-  end
-
-  def inspect
-    "#<StringDrop @value=#{@value.inspect}>"
-  end
-
-  def <=>(other)
-    to_liquid_value <=> Liquid::Utils.to_liquid_value(other)
-  end
-end
-
 class ErrorDrop < Liquid::Drop
   def standard_error
     raise Liquid::StandardError, 'standard error'

test/unit/boolean_unit_test.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class BooleanUnitTest < Minitest::Test
+  include Liquid
+
+  def test_simple_boolean_comparison
+    assert_parity("1 > 0", "true")
+    assert_parity("1 < 0", "false")
+  end
+
+  def test_boolean_and_operator
+    assert_parity("true and true", "true")
+    assert_parity("true and false", "false")
+  end
+
+  def test_boolean_or_operator
+    assert_parity("true or false", "true")
+    assert_parity("false or false", "false")
+  end
+
+  def test_operator_precedence
+    assert_parity("false and false or true", "false")
+  end
+
+  def test_complex_boolean_expressions
+    assert_parity("true and true and true", "true")
+    assert_parity("true and false and true", "false")
+    assert_parity("false or false or true", "true")
+  end
+
+  def test_boolean_with_variables
+    assert_parity("a and b", "true", { "a" => true, "b" => true })
+    assert_parity("a and b", "false", { "a" => true, "b" => false })
+    assert_parity("a or b", "true", { "a" => false, "b" => true })
+    assert_parity("a or b", "false", { "a" => false, "b" => false })
+  end
+
+  def test_nil_equals_nil
+    assert_parity("nil == nil", "true")
+  end
+
+  def test_nil_not_equals_nil
+    assert_parity("nil != nil", "false")
+  end
+
+  def test_nil_not_equals_empty_string
+    assert_parity("nil == ''", "false")
+    assert_parity("nil != ''", "true")
+  end
+
+  def test_undefined_variable_in_comparisons
+    assert_parity("undefined_var == nil", "true")
+    assert_parity("undefined_var != nil", "false")
+  end
+
+  def test_undefined_variable_compared_to_empty_string
+    assert_parity("undefined_var == ''", "false")
+    assert_parity("undefined_var != ''", "true")
+  end
+
+  def test_boolean_variable_in_comparisons
+    assert_parity("t == true", "true", { "t" => true })
+    assert_parity("f == false", "true", { "f" => false })
+  end
+
+  def test_boolean_variable_compared_to_nil
+    assert_parity("t == nil", "false", { "t" => true })
+    assert_parity("f == nil", "false", { "f" => false })
+    assert_parity("f != nil", "true", { "f" => false })
+  end
+
+  def test_nil_and_undefined_variables_in_boolean_expressions
+    assert_parity("x == undefined_var", "true", { "x" => nil })
+    assert_parity("x != undefined_var", "false", { "x" => nil })
+  end
+
+  def test_nil_literal_in_or_expression
+    assert_parity("nil or true", "true")
+  end
+
+  def test_nil_variable_in_or_expression
+    assert_parity("x or false", "false", { "x" => nil })
+  end
+
+  def test_mixed_boolean_expressions
+    assert_parity("a > b and c < d", "true",  { "a" => 99, "b" => 0, "c" => 0,  "d" => 99 })
+    assert_parity("a > b and c < d", "false", { "a" => 99, "b" => 0, "c" => 99, "d" => 0  })
+  end
+
+  def test_boolean_assignment_shorthand
+    template = Liquid::Template.parse("{% assign lazy_load = media_position > 1 %}{{ lazy_load }}")
+    assert_equal("false", template.render("media_position" => 1))
+    assert_equal("true",  template.render("media_position" => 2))
+  end
+
+  def test_equality_operators
+    assert_parity_todo!("1 == 1", "true")
+    assert_parity_todo!("1 != 2", "true")
+    assert_parity_todo!("'hello' == 'hello'", "true")
+  end
+
+  def test_nil_renders_as_empty_string
+    assert_parity_todo!("nil", "false")
+  end
+
+  def test_nil_comparison_with_blank
+    assert_parity_todo!("nil_value == blank", "false")
+    assert_parity_todo!("nil_value != blank", "true")
+    assert_parity_todo!("undefined != blank", "true")
+    assert_parity_todo!("undefined == blank", "false")
+  end
+
+  def test_if_with_variables
+    assert_parity_todo!("value", "true",  { "value" => true })
+    assert_parity_todo!("value", "false", { "value" => false })
+    assert_parity_todo!("value", "false", { "value" => nil })
+    assert_parity_todo!("value", "true",  { "value" => "text" })
+    assert_parity_todo!("value", "true", { "value" => "" })
+  end
+
+  def test_nil_variable_in_and_expression
+    assert_parity_todo!("x and true", "false", { "x" => nil })
+  end
+
+  private
+
+  def assert_parity_todo!(liquid_expression, expected_result, args = {})
+    assert_parity_scenario(:condition, "{% if #{liquid_expression} %}true{% else %}false{% endif %}", expected_result, args)
+    test_name = caller_locations(1, 1)[0].label
+    puts "\e[33mTODO: parity for '#{test_name}'\e[0m"
+  end
+
+  def assert_parity(liquid_expression, expected_result, args = {})
+    assert_parity_scenario(:condition, "{% if #{liquid_expression} %}true{% else %}false{% endif %}", expected_result, args)
+    assert_parity_scenario(:expression, "{{ #{liquid_expression} }}", expected_result, args)
+  end
+
+  def assert_parity_scenario(kind, template, exp_output, args = {})
+    act_output = Liquid::Template.parse(template).render(args)
+
+    assert_equal(exp_output, act_output, <<~ERROR_MESSAGE)
+      #{kind.to_s.capitalize} template failure:
+      ---
+      #{template}
+      ---
+      args: #{args.inspect}
+    ERROR_MESSAGE
+  end
+end

test/unit/environment_test.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class EnvironmentTest < Minitest::Test
-  include Liquid
-
-  class UnsubscribeFooter < Liquid::Tag
-    def render(_context)
-      'Unsubscribe Footer'
-    end
-  end
-
-  def test_custom_tag
-    email_environment = Liquid::Environment.build do |environment|
-      environment.register_tag("unsubscribe_footer", UnsubscribeFooter)
-    end
-
-    assert(email_environment.tags["unsubscribe_footer"])
-    assert(email_environment.tag_for_name("unsubscribe_footer"))
-    template = Liquid::Template.parse("{% unsubscribe_footer %}", environment: email_environment)
-
-    assert_equal('Unsubscribe Footer', template.render)
-  end
-end

test/unit/lexer_unit_test.rb

@@ -141,6 +141,78 @@ class LexerUnitTest < Minitest::Test
     )
   end
 
+  def test_boolean_and_operator
+    exp = [
+      [:id, "true"],
+      [:boolean_operator, "and"],
+      [:id, "false"],
+      [:end_of_string],
+    ]
+    act = tokenize("true and false")
+    assert_equal(exp, act)
+  end
+
+  def test_boolean_or_operator
+    exp = [
+      [:id, "false"],
+      [:boolean_operator, "or"],
+      [:id, "true"],
+      [:end_of_string],
+    ]
+    act = tokenize("false or true")
+    assert_equal(exp, act)
+  end
+
+  def test_boolean_operators_in_complex_expressions
+    exp = [
+      [:id, "a"],
+      [:boolean_operator, "and"],
+      [:id, "b"],
+      [:boolean_operator, "or"],
+      [:id, "c"],
+      [:end_of_string],
+    ]
+    act = tokenize("a and b or c")
+    assert_equal(exp, act)
+  end
+
+  def test_boolean_operators_with_comparisons
+    exp = [
+      [:id, "a"],
+      [:comparison, ">"],
+      [:number, "5"],
+      [:boolean_operator, "and"],
+      [:id, "b"],
+      [:comparison, "<"],
+      [:number, "10"],
+      [:end_of_string],
+    ]
+    act = tokenize("a > 5 and b < 10")
+    assert_equal(exp, act)
+  end
+
+  def test_boolean_operators_as_property_names
+    exp = [
+      [:id, "obj"],
+      [:dot, "."],
+      [:id, "and"],
+      [:dot, "."],
+      [:id, "property"],
+      [:end_of_string],
+    ]
+    act = tokenize("obj.and.property")
+    assert_equal(exp, act)
+
+    exp = [
+      [:id, "obj"],
+      [:dot, "."],
+      [:id, "or"],
+      [:end_of_string],
+    ]
+    act = tokenize("obj.or")
+    assert_equal(exp, act)
+  end
+
   private
 
   def tokenize(input)

test/unit/tags/doc_tag_unit_test.rb

@@ -20,21 +20,6 @@ class DocTagUnitTest < Minitest::Test
     assert_template_result('', template)
   end
 
-  def test_doc_tag_body_content
-    doc_content = "  Documentation content\n  @param {string} foo - test\n"
-    template_source = "{% doc %}#{doc_content}{% enddoc %}"
-
-    doc_tag = nil
-    ParseTreeVisitor
-      .for(Template.parse(template_source).root)
-      .add_callback_for(Liquid::Doc) do |tag|
-        doc_tag = tag
-      end
-      .visit
-
-    assert_equal(doc_content, doc_tag.nodelist.first.to_s)
-  end
-
   def test_doc_tag_does_not_support_extra_arguments
     error = assert_raises(Liquid::SyntaxError) do
       template = <<~LIQUID.chomp
@@ -131,20 +116,6 @@ class DocTagUnitTest < Minitest::Test
     assert_template_result('', template)
   end
 
-  def test_doc_tag_captures_token_before_enddoc
-    template_source = "{% doc %}{{ incomplete{% enddoc %}"
-
-    doc_tag = nil
-    ParseTreeVisitor
-      .for(Template.parse(template_source).root)
-      .add_callback_for(Liquid::Doc) do |tag|
-        doc_tag = tag
-      end
-      .visit
-
-    assert_equal("{{ incomplete", doc_tag.nodelist.first.to_s)
-  end
-
   def test_doc_tag_preserves_error_line_numbers
     template = Liquid::Template.parse(<<~LIQUID.chomp, line_numbers: true)
       {% doc %}
@@ -174,11 +145,11 @@ class DocTagUnitTest < Minitest::Test
 
   def test_doc_tag_delimiter_handling
     assert_template_result('', <<~LIQUID.chomp)
-      {%- if true -%}
-        {%- doc -%}
-          {%- docEXTRA -%}wut{% enddocEXTRA -%}xyz
-        {%- enddoc -%}
-      {%- endif -%}
+      {% if true %}
+        {% doc %}
+          {% docEXTRA %}wut{% enddocEXTRA %}xyz
+        {% enddoc %}
+      {% endif %}
     LIQUID
 
     assert_template_result('', "{% doc %}123{% enddoc xyz %}")
@@ -196,80 +167,6 @@ class DocTagUnitTest < Minitest::Test
     )
   end
 
-  def test_doc_tag_blank_with_empty_content
-    template_source = "{% doc %}{% enddoc %}"
-
-    doc_tag = nil
-    ParseTreeVisitor
-      .for(Template.parse(template_source).root)
-      .add_callback_for(Liquid::Doc) do |tag|
-        doc_tag = tag
-      end
-      .visit
-
-    assert_equal(true, doc_tag.blank?)
-  end
-
-  def test_doc_tag_blank_with_content
-    template_source = "{% doc %}Some documentation{% enddoc %}"
-
-    doc_tag = nil
-    ParseTreeVisitor
-      .for(Template.parse(template_source).root)
-      .add_callback_for(Liquid::Doc) do |tag|
-        doc_tag = tag
-      end
-      .visit
-
-    assert_equal(false, doc_tag.blank?)
-  end
-
-  def test_doc_tag_blank_with_whitespace_only
-    template_source = "{% doc %}    {% enddoc %}"
-
-    doc_tag = nil
-    ParseTreeVisitor
-      .for(Template.parse(template_source).root)
-      .add_callback_for(Liquid::Doc) do |tag|
-        doc_tag = tag
-      end
-      .visit
-
-    assert_equal(false, doc_tag.blank?)
-  end
-
-  def test_doc_tag_nodelist_returns_array_with_body
-    doc_content = "Documentation content\n@param {string} foo"
-    template_source = "{% doc %}#{doc_content}{% enddoc %}"
-
-    doc_tag = nil
-    ParseTreeVisitor
-      .for(Template.parse(template_source).root)
-      .add_callback_for(Liquid::Doc) do |tag|
-        doc_tag = tag
-      end
-      .visit
-
-    assert_equal([doc_content], doc_tag.nodelist)
-    assert_equal(1, doc_tag.nodelist.length)
-    assert_equal(doc_content, doc_tag.nodelist.first)
-  end
-
-  def test_doc_tag_nodelist_with_empty_content
-    template_source = "{% doc %}{% enddoc %}"
-
-    doc_tag = nil
-    ParseTreeVisitor
-      .for(Template.parse(template_source).root)
-      .add_callback_for(Liquid::Doc) do |tag|
-        doc_tag = tag
-      end
-      .visit
-
-    assert_equal([""], doc_tag.nodelist)
-    assert_equal(1, doc_tag.nodelist.length)
-  end
-
   private
 
   def traversal(template)