Top Hat changes

Add find, find_index, has, and reject filters to arrays
Update branch with main
2026-09-29 23:25:14 -07:00 · 2024-12-05 08:57:53 +01:00 · 2024-12-03 14:42:47 +01:00 · 2024-12-03 14:14:36 +01:00 · 2024-12-03 14:11:15 +01:00 · 2024-12-03 14:07:26 +01:00
27 changed files with 724 additions and 243 deletions
@@ -8,6 +8,7 @@ end
 gemspec

 gem "base64"
+gem "webrick"

 group :benchmark, :test do
  gem 'benchmark-ips'
@@ -20,7 +20,7 @@ end

 class Servlet < LiquidServlet
  def index
-    { 'date' => Time.now }
+    { 'date' => Time.now, 'products' => products_list }
  end

  def products
@@ -29,11 +29,42 @@ class Servlet < LiquidServlet

  private

+  class Name < Liquid::Drop
+    attr_reader :raw, :origin
+
+    def initialize(raw, origin)
+      super()
+      @raw = raw
+      @origin = origin
+    end
+  end
+
+  class Price < Liquid::Drop
+    attr_reader :value, :unit
+
+    def initialize(value, unit = 'USD')
+      super()
+      @value = value
+      @unit = unit
+    end
+  end
+
+  class Product < Liquid::Drop
+    attr_reader :name, :price, :description
+
+    def initialize(name, origin, price, description)
+      super()
+      @name = Name.new(name, origin)
+      @price = Price.new(price)
+      @description = description
+    end
+  end
+
  def products_list
    [
-      { 'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
-      { 'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling' },
-      { 'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity' }
+      { 'name' => 'Alpine jacket',  'price' => { 'value' => 30000, 'unit' => 'USD' }, 'description' => 'the *alpine jacket* is a excellent product' },
+      { 'name' => 'Mountain boots', 'price' => { 'value' => 40000, 'unit' => 'BRL' }, 'description' => 'the *mountain boots* are perfect for hiking' },
+      { 'name' => 'Safety helmet',  'price' => { 'value' => 10000, 'unit' => 'USD' }, 'description' => 'the *safety helmet* provides essential protection for winter sports' }
    ]
  end

@@ -1,6 +1,71 @@
-<p>Hello world!</p>
+{% # theme-check-disable UnknownFilter, UndefinedObject %}
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Liquid filters playground</title>
+  <script>
+    setInterval(() => {
+      fetch(window.location.href)
+        .then(response => response.text())
+        .then(html => {
+          const parser = new DOMParser();
+          const newDoc = parser.parseFromString(html, 'text/html');
+          const newBody = newDoc.body;
+          document.body.innerHTML = newBody.innerHTML;
+        })
+        .catch(error => console.error('Error updating content:', error));
+    }, 1000);
+  </script>
+  <style>
+    body {
+      zoom: 2;
+      font-family: monospace
+    }
+  </style>
+</head>
+<body>

-<p>It is {{date}}</p>
+  <h1>
+    Liquid filters playground
+  </h1>
+
+  {{ products | map: "name" | json }}
+
+  <h2>
+    find
+  </h2>
+  <pre>
+    {% assign product = products | find: "name", "Mountain boots" %}
+    {{ product.name }} - {{ product.price.value }}
+
+    {% assign product = products | find: "price.unit", "USD" %}
+    {{ product.name }} - {{ product.price.value }}
+  </pre>
+
+  <h2>
+    find_index
+  </h2>
+  <pre>
+    {% assign index = products | find_index: "name", "Mountain boots" %}
+    {{ index }}
+  </pre>
+
+  <h2>
+    has
+  </h2>
+  <pre>
+    {{ products | has: "name", "Mountain boots" }}
+  </pre>


-<p>Check out the <a href="/products">Products</a> screen </p>
+  <h2>
+    reject
+  </h2>
+  <pre>
+    {{ products | map: "name" | join: ", " }}
+    {{ products | reject: "name", "Mountain boots" | map: "name" | join: ", " }}
+  </pre>
+
+</body>
+</html>
@@ -44,15 +44,11 @@ module Liquid
  VariableParser              = /\[(?>[^\[\]]+|\g<0>)*\]|#{VariableSegment}+\??/o

  RAISE_EXCEPTION_LAMBDA = ->(_e) { raise }
-
-  singleton_class.send(:attr_accessor, :cache_classes)
-  self.cache_classes = true
 end

 require "liquid/version"
 require "liquid/deprecations"
 require "liquid/const"
-require "liquid/template/tag_registry"
 require 'liquid/standardfilters'
 require 'liquid/file_system'
 require 'liquid/parser_switching'
@@ -72,7 +68,6 @@ require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
 require 'liquid/strainer_template'
-require 'liquid/strainer_factory'
 require 'liquid/expression'
 require 'liquid/context'
 require 'liquid/tag'
@@ -19,7 +19,7 @@ module Liquid

    # rubocop:disable Metrics/ParameterLists
    def self.build(environment: Environment.default, environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_environments: {}, &block)
-      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_environments, &block)
+      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_environments, environment, &block)
    end

    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_environments = {}, environment = Environment.default)
@@ -143,6 +143,7 @@ module Liquid
      check_overflow

      self.class.build(
+        environment: @environment,
        resource_limits: resource_limits,
        static_environments: static_environments,
        registers: Registers.new(registers),
@@ -41,7 +41,7 @@ module Liquid
      # @return [Environment] The new environment instance.
      def build(tags: nil, file_system: nil, error_mode: nil, exception_renderer: nil)
        ret = new
-        ret.tags = Template::TagRegistry.new(tags) if tags
+        ret.tags = tags if tags
        ret.file_system = file_system if file_system
        ret.error_mode = error_mode if error_mode
        ret.exception_renderer = exception_renderer if exception_renderer
@@ -74,7 +74,7 @@ module Liquid
    # Initializes a new environment instance.
    # @api private
    def initialize
-      @tags = Template::TagRegistry.new(Tags::STANDARD_TAGS)
+      @tags = Tags::STANDARD_TAGS.dup
      @error_mode = :lax
      @strainer_template = Class.new(StrainerTemplate).tap do |klass|
        klass.add_filter(StandardFilters)
@@ -73,7 +73,6 @@ module Liquid
    COMPARISON_LESS_THAN = [:comparison, "<"].freeze
    COMPARISON_LESS_THAN_OR_EQUAL = [:comparison, "<="].freeze
    COMPARISON_NOT_EQUAL_ALT = [:comparison, "<>"].freeze
-    CONTAINS = /contains(?=\s)/
    DASH = [:dash, "-"].freeze
    DOT = [:dot, "."].freeze
    DOTDOT = [:dotdot, ".."].freeze
@@ -90,7 +89,12 @@ module Liquid
    SINGLE_STRING_LITERAL = /'[^\']*'/
    WHITESPACE_OR_NOTHING = /\s*/

-    COMPARISON_JUMP_TABLE = [].tap do |table|
+    SINGLE_COMPARISON_TOKENS = [].tap do |table|
+      table["<".ord] = COMPARISON_LESS_THAN
+      table[">".ord] = COMPARISON_GREATER_THAN
+    end
+
+    TWO_CHARS_COMPARISON_JUMP_TABLE = [].tap do |table|
      table["=".ord] = [].tap do |sub_table|
        sub_table["=".ord] = COMPARISON_EQUAL
        sub_table.freeze
@@ -99,6 +103,9 @@ module Liquid
        sub_table["=".ord] = COMPARISION_NOT_EQUAL
        sub_table.freeze
      end
+    end
+
+    COMPARISON_JUMP_TABLE = [].tap do |table|
      table["<".ord] = [].tap do |sub_table|
        sub_table["=".ord] = COMPARISON_LESS_THAN_OR_EQUAL
        sub_table[">".ord] = COMPARISON_NOT_EQUAL_ALT
@@ -163,6 +170,7 @@ module Liquid

        break if @ss.eos?

+        start_pos = @ss.pos
        peeked = @ss.peek_byte

        if (special = SPECIAL_TABLE[peeked])
@@ -173,7 +181,7 @@ module Liquid
            @output << DOTDOT
          elsif special == DASH
            # Special case for negative numbers
-            if NUMBER_TABLE[@ss.peek_byte]
+            if (peeked_byte = @ss.peek_byte) && NUMBER_TABLE[peeked_byte]
              @ss.pos -= 1
              @output << [:number, @ss.scan(NUMBER_LITERAL)]
            else
@@ -182,26 +190,34 @@ module Liquid
          else
            @output << special
          end
-        elsif (sub_table = COMPARISON_JUMP_TABLE[peeked])
+        elsif (sub_table = TWO_CHARS_COMPARISON_JUMP_TABLE[peeked])
          @ss.scan_byte
-          if (found = sub_table[@ss.peek_byte])
+          if (peeked_byte = @ss.peek_byte) && (found = sub_table[peeked_byte])
            @output << found
            @ss.scan_byte
          else
-            raise SyntaxError, "Unexpected character #{peeked.chr}"
+            raise_syntax_error(start_pos)
+          end
+        elsif (sub_table = COMPARISON_JUMP_TABLE[peeked])
+          @ss.scan_byte
+          if (peeked_byte = @ss.peek_byte) && (found = sub_table[peeked_byte])
+            @output << found
+            @ss.scan_byte
+          else
+            @output << SINGLE_COMPARISON_TOKENS[peeked]
          end
        else
          type, pattern = NEXT_MATCHER_JUMP_TABLE[peeked]

          if type && (t = @ss.scan(pattern))
            # Special case for "contains"
-            @output << if type == :id && t == "contains"
+            @output << if type == :id && t == "contains" && @output.last&.first != :dot
              COMPARISON_CONTAINS
            else
              [type, t]
            end
          else
-            raise SyntaxError, "Unexpected character #{peeked.chr}"
+            raise_syntax_error(start_pos)
          end
        end
      end
@@ -209,6 +225,12 @@ module Liquid

      @output << EOS
    end
+
+    def raise_syntax_error(start_pos)
+      @ss.pos = start_pos
+      # the character could be a UTF-8 character, use getch to get all the bytes
+      raise SyntaxError, "Unexpected character #{@ss.getch}"
+    end
  end

  Lexer = StringScanner.instance_methods.include?(:scan_byte) ? Lexer2 : Lexer1
@@ -36,7 +36,7 @@ module Liquid
    protected

    def children
-      @node.respond_to?(:nodelist) ? Array(@node.nodelist) : []
+      @node.respond_to?(:nodelist) ? Array(@node.nodelist) : Const::EMPTY_ARRAY
    end
  end
 end
@@ -378,7 +378,7 @@ module Liquid
        end
      elsif ary.all? { |el| el.respond_to?(:[]) }
        begin
-          ary.sort { |a, b| nil_safe_compare(a[property], b[property]) }
+          ary.sort { |a, b| nil_safe_compare(fetch_property(a, property), fetch_property(b, property)) }
        rescue TypeError
          raise_property_error(property)
        end
@@ -407,7 +407,7 @@ module Liquid
        end
      elsif ary.all? { |el| el.respond_to?(:[]) }
        begin
-          ary.sort { |a, b| nil_safe_casecmp(a[property], b[property]) }
+          ary.sort { |a, b| nil_safe_casecmp(fetch_property(a, property), fetch_property(b, property)) }
        rescue TypeError
          raise_property_error(property)
        end
@@ -424,29 +424,59 @@ module Liquid
    # @liquid_syntax array | where: string, string
    # @liquid_return [array[untyped]]
    def where(input, property, target_value = nil)
-      ary = InputIterator.new(input, context)
+      filter_array(input, property, target_value, :select)
+    end

-      if ary.empty?
-        []
-      elsif target_value.nil?
-        ary.select do |item|
-          item[property]
-        rescue TypeError
-          raise_property_error(property)
-        rescue NoMethodError
-          return nil unless item.respond_to?(:[])
-          raise
-        end
-      else
-        ary.select do |item|
-          item[property] == target_value
-        rescue TypeError
-          raise_property_error(property)
-        rescue NoMethodError
-          return nil unless item.respond_to?(:[])
-          raise
-        end
-      end
+    # @liquid_public_docs
+    # @liquid_type filter
+    # @liquid_category array
+    # @liquid_summary
+    #   Filters an array to exclude items with a specific property value.
+    # @liquid_description
+    #   This requires you to provide both the property name and the associated value.
+    # @liquid_syntax array | reject: string, string
+    # @liquid_return [array[untyped]]
+    def reject(input, property, target_value = nil)
+      filter_array(input, property, target_value, :reject)
+    end
+
+    # @liquid_public_docs
+    # @liquid_type filter
+    # @liquid_category array
+    # @liquid_summary
+    #   Tests if any item in an array has a specific property value.
+    # @liquid_description
+    #   This requires you to provide both the property name and the associated value.
+    # @liquid_syntax array | some: string, string
+    # @liquid_return [boolean]
+    def has(input, property, target_value = nil)
+      filter_array(input, property, target_value, :any?)
+    end
+
+    # @liquid_public_docs
+    # @liquid_type filter
+    # @liquid_category array
+    # @liquid_summary
+    #   Returns the first item in an array with a specific property value.
+    # @liquid_description
+    #   This requires you to provide both the property name and the associated value.
+    # @liquid_syntax array | find: string, string
+    # @liquid_return [untyped]
+    def find(input, property, target_value = nil)
+      filter_array(input, property, target_value, :find)
+    end
+
+    # @liquid_public_docs
+    # @liquid_type filter
+    # @liquid_category array
+    # @liquid_summary
+    #   Returns the index of the first item in an array with a specific property value.
+    # @liquid_description
+    #   This requires you to provide both the property name and the associated value.
+    # @liquid_syntax array | find_index: string, string
+    # @liquid_return [number]
+    def find_index(input, property, target_value = nil)
+      filter_array(input, property, target_value, :find_index)
    end

    # @liquid_public_docs
@@ -465,7 +495,7 @@ module Liquid
        []
      else
        ary.uniq do |item|
-          item[property]
+          fetch_property(item, property)
        rescue TypeError
          raise_property_error(property)
        rescue NoMethodError
@@ -501,7 +531,7 @@ module Liquid
        if property == "to_liquid"
          e
        elsif e.respond_to?(:[])
-          r = e[property]
+          r = fetch_property(e, property)
          r.is_a?(Proc) ? r.call : r
        end
      end
@@ -525,7 +555,7 @@ module Liquid
        []
      else
        ary.reject do |item|
-          item[property].nil?
+          fetch_property(item, property).nil?
        rescue TypeError
          raise_property_error(property)
        rescue NoMethodError
@@ -899,7 +929,7 @@ module Liquid
        if property.nil?
          item
        elsif item.respond_to?(:[])
-          item[property]
+          fetch_property(item, property)
        else
          0
        end
@@ -918,6 +948,50 @@ module Liquid

    attr_reader :context

+    def filter_array(input, property, target_value, method)
+      ary = InputIterator.new(input, context)
+
+      return [] if ary.empty?
+
+      ary.public_send(method) do |item|
+        if target_value.nil?
+          fetch_property(item, property)
+        else
+          fetch_property(item, property) == target_value
+        end
+      rescue TypeError
+        raise_property_error(property)
+      rescue NoMethodError
+        return nil unless item.respond_to?(:[])
+        raise
+      end
+    end
+
+    def fetch_property(drop, property_or_keys)
+      ##
+      # This keeps backward compatibility by supporting properties containing
+      # dots. This is valid in Liquid syntax and used in some runtimes, such as
+      # Shopify with metafields.
+      #
+      # Using this approach, properties like 'price.value' can be accessed in
+      # both of the following examples:
+      #
+      # ```
+      # [
+      #   { 'name' => 'Item 1', 'price.price' => 40000 },
+      #   { 'name' => 'Item 2', 'price' => { 'value' => 39900 } }
+      # ]
+      # ```
+      value = drop[property_or_keys]
+
+      return value if !value.nil? || !property_or_keys.is_a?(String)
+
+      keys = property_or_keys.split('.')
+      keys.reduce(drop) do |drop, key|
+        drop.respond_to?(:[]) ? drop[key] : drop
+      end
+    end
+
    def raise_property_error(property)
      raise Liquid::ArgumentError, "cannot select the property '#{property}'"
    end
@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  # StrainerFactory is the factory for the filters system.
-  module StrainerFactory
-    extend self
-
-    def add_global_filter(filter, environment = Environment.default)
-      Deprecations.warn("StrainerFactory.add_global_filter", "Environment#register_filter")
-      environment.register_filter(filter)
-    end
-
-    def create(context, filters = Const::EMPTY_ARRAY, environment = Environment.default)
-      Deprecations.warn("StrainerFactory.create", "StrainerFactory.create_strainer")
-      environment.create_strainer(context, filters)
-    end
-
-    def global_filter_names(environment = Environment.default)
-      Deprecations.warn("StrainerFactory.global_filter_names", "Environment#filter_method_names")
-      Environment.strainer_template.filter_method_names
-    end
-  end
-end
@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Template
-    class TagRegistry
-      include Enumerable
-
-      def initialize(tags = nil)
-        @tags  = {}
-        @cache = {}
-        tags.each { |tag_name, klass| self[tag_name] = klass }
-        Deprecations.warn("Template::TagRegistry", "Use a Environment instance with zeitwerk")
-      end
-
-      def [](tag_name)
-        return nil unless @tags.key?(tag_name)
-        return @cache[tag_name] if Liquid.cache_classes
-
-        lookup_class(@tags[tag_name]).tap { |o| @cache[tag_name] = o }
-      end
-
-      def delete(tag_name)
-        Deprecations.warn("Template::TagRegistry#delete", "Use a Environment instance with immutable tags")
-        @tags.delete(tag_name)
-        @cache.delete(tag_name)
-      end
-
-      def []=(tag_name, klass)
-        @tags[tag_name]  = klass.name
-        @cache[tag_name] = klass
-      end
-
-      def each(&block)
-        @tags.each(&block)
-      end
-
-      private
-
-      def lookup_class(name)
-        Object.const_get(name)
-      end
-    end
-  end
-end
@@ -68,7 +68,7 @@ module Liquid
      @name = parse_context.parse_expression(p.expression)
      while p.consume?(:pipe)
        filtername = p.consume(:id)
-        filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
+        filterargs = p.consume?(:colon) ? parse_filterargs(p) : Const::EMPTY_ARRAY
        @filters << parse_filter_expressions(filtername, filterargs)
      end
      p.consume(:end_of_string)
@@ -2,5 +2,5 @@
 # frozen_string_literal: true

 module Liquid
-  VERSION = "5.6.0.alpha"
+  VERSION = "5.6.0.rc1"
 end
@@ -4,7 +4,8 @@ require 'benchmark/ips'
 require_relative 'theme_runner'

 RubyVM::YJIT.enable if defined?(RubyVM::YJIT)
-Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
+Liquid::Environment.default.error_mode = ARGV.first.to_sym if ARGV.first
+
 profiler = ThemeRunner.new

 Benchmark.ips do |x|
@@ -11,11 +11,12 @@ require_relative 'shop_filter'
 require_relative 'tag_filter'
 require_relative 'weight_filter'

-Liquid::Template.register_tag('paginate', Paginate)
-Liquid::Template.register_tag('form', CommentForm)
+default_environment = Liquid::Environment.default
+default_environment.register_tag('paginate', Paginate)
+default_environment.register_tag('form', CommentForm)

-Liquid::Template.register_filter(JsonFilter)
-Liquid::Template.register_filter(MoneyFilter)
-Liquid::Template.register_filter(WeightFilter)
-Liquid::Template.register_filter(ShopFilter)
-Liquid::Template.register_filter(TagFilter)
+default_environment.register_filter(JsonFilter)
+default_environment.register_filter(MoneyFilter)
+default_environment.register_filter(WeightFilter)
+default_environment.register_filter(ShopFilter)
+default_environment.register_filter(TagFilter)
@@ -672,6 +672,21 @@ class ContextTest < Minitest::Test
    assert_includes(result, "unscoped_products_count: 5")
  end

+  def test_new_isolated_context_inherits_parent_environment
+    global_environment = Liquid::Environment.build(tags: {})
+    context = Context.build(environment: global_environment)
+
+    subcontext = context.new_isolated_subcontext
+    assert_equal(global_environment, subcontext.environment)
+  end
+
+  def test_newly_built_context_inherits_parent_environment
+    global_environment = Liquid::Environment.build(tags: {})
+    context = Context.build(environment: global_environment)
+    assert_equal(global_environment, context.environment)
+    assert(context.environment.tags.each.to_a.empty?)
+  end
+
  private

  def assert_no_object_allocations
@@ -203,20 +203,19 @@ class ErrorHandlingTest < Minitest::Test
  end

  def test_setting_default_exception_renderer
-    old_exception_renderer = Liquid::Template.default_exception_renderer
    exceptions = []
-    Liquid::Template.default_exception_renderer = ->(e) {
+    default_exception_renderer = ->(e) {
      exceptions << e
      ''
    }
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.argument_error }}')
+
+    env = Liquid::Environment.build(exception_renderer: default_exception_renderer)
+    template = Liquid::Template.parse('This is a runtime error: {{ errors.argument_error }}', environment: env)

    output = template.render('errors' => ErrorDrop.new)

    assert_equal('This is a runtime error: ', output)
    assert_equal([Liquid::ArgumentError], template.errors.map(&:class))
-  ensure
-    Liquid::Template.default_exception_renderer = old_exception_renderer if old_exception_renderer
  end

  def test_setting_exception_renderer_on_environment
@@ -131,4 +131,16 @@ class ParsingQuirksTest < Minitest::Test
  def test_contains_in_id
    assert_template_result(' YES ', '{% if containsallshipments == true %} YES {% endif %}', { 'containsallshipments' => true })
  end
+
+  def test_incomplete_expression
+    with_error_mode(:lax) do
+      assert_template_result("false", "{% liquid assign foo = false -\n%}{{ foo }}")
+      assert_template_result("false", "{% liquid assign foo = false >\n%}{{ foo }}")
+      assert_template_result("false", "{% liquid assign foo = false <\n%}{{ foo }}")
+      assert_template_result("false", "{% liquid assign foo = false =\n%}{{ foo }}")
+      assert_template_result("false", "{% liquid assign foo = false !\n%}{{ foo }}")
+      assert_template_result("false", "{% liquid assign foo = false 1\n%}{{ foo }}")
+      assert_template_result("false", "{% liquid assign foo = false a\n%}{{ foo }}")
+    end
+  end
 end # ParsingQuirksTest
@@ -33,7 +33,7 @@ class ProfilerTest < Minitest::Test
  end

  def setup
-    Liquid::Template.file_system = ProfilingFileSystem.new
+    Liquid::Environment.default.file_system = ProfilingFileSystem.new
  end

  def test_template_allows_flagging_profiling
@@ -54,6 +54,30 @@ class TestEnumerable < Liquid::Drop
  end
 end

+class TestDeepEnumerable < Liquid::Drop
+  include Enumerable
+
+  class Product < Liquid::Drop
+    attr_reader :title, :price, :premium
+
+    def initialize(title:, price:, premium: nil)
+      @title = { "content" => title, "language" => "en" }
+      @price = { "value" => price, "unit" => "USD" }
+      @premium = { "category" => premium } if premium
+    end
+  end
+
+  def each(&block)
+    [
+      Product.new(title: "Pro goggles",    price: 1299),
+      Product.new(title: "Thermal gloves", price: 1299),
+      Product.new(title: "Alpine jacket",  price: 3999, premium: 'Basic'),
+      Product.new(title: "Mountain boots", price: 3899, premium: 'Pro'),
+      Product.new(title: "Safety helmet",  price: 1999)
+    ].each(&block)
+  end
+end
+
 class NumberLikeThing < Liquid::Drop
  def initialize(amount)
    @amount = amount
@@ -392,6 +416,15 @@ class StandardFiltersTest < Minitest::Test
    end
  end

+  def test_sort_natural_with_deep_enumerables
+    template = <<~LIQUID
+      {{- products | sort_natural: 'title.content' | map: 'title.content' | join: ', ' -}}
+    LIQUID
+    expected_output = "Alpine jacket, Mountain boots, Pro goggles, Safety helmet, Thermal gloves"
+
+    assert_template_result(expected_output, template, { "products" => TestDeepEnumerable.new })
+  end
+
  def test_legacy_sort_hash
    assert_equal([{ a: 1, b: 2 }], @filters.sort(a: 1, b: 2))
  end
@@ -428,6 +461,15 @@ class StandardFiltersTest < Minitest::Test
    end
  end

+  def test_uniq_with_deep_enumerables
+    template = <<~LIQUID
+      {{- products | uniq: 'price.value' | map: "title.content" | join: ', ' -}}
+    LIQUID
+    expected_output = "Pro goggles, Alpine jacket, Mountain boots, Safety helmet"
+
+    assert_template_result(expected_output, template, { "products" => TestDeepEnumerable.new })
+  end
+
  def test_compact_empty_array
    assert_equal([], @filters.compact([], "a"))
  end
@@ -444,6 +486,15 @@ class StandardFiltersTest < Minitest::Test
    end
  end

+  def test_compact_with_deep_enumerables
+    template = <<~LIQUID
+      {{- products | compact: 'premium.category' | map: 'title.content' | join: ', ' -}}
+    LIQUID
+    expected_output = "Alpine jacket, Mountain boots"
+
+    assert_template_result(expected_output, template, { "products" => TestDeepEnumerable.new })
+  end
+
  def test_reverse
    assert_equal([4, 3, 2, 1], @filters.reverse([1, 2, 3, 4]))
  end
@@ -553,6 +604,15 @@ class StandardFiltersTest < Minitest::Test
    assert_template_result("213", '{{ foo | sort: "bar" | map: "foo" }}', { "foo" => TestEnumerable.new })
  end

+  def test_sort_with_deep_enumerables
+    template = <<~LIQUID
+      {{- products | sort: 'price.value' | map: 'title.content' | join: ', ' -}}
+    LIQUID
+    expected_output = "Pro goggles, Thermal gloves, Safety helmet, Mountain boots, Alpine jacket"
+
+    assert_template_result(expected_output, template, { "products" => TestDeepEnumerable.new })
+  end
+
  def test_first_and_last_call_to_liquid
    assert_template_result('foobar', '{{ foo | first }}', { 'foo' => [ThingWithToLiquid.new] })
    assert_template_result('foobar', '{{ foo | last }}', { 'foo' => [ThingWithToLiquid.new] })
@@ -827,21 +887,219 @@ class StandardFiltersTest < Minitest::Test
    assert_template_result('abc', "{{ 'abc' | date: '%D' }}")
  end

-  def test_where
-    input = [
+  def test_reject
+    array = [
      { "handle" => "alpha", "ok" => true },
      { "handle" => "beta", "ok" => false },
      { "handle" => "gamma", "ok" => false },
      { "handle" => "delta", "ok" => true },
    ]

-    expectation = [
+    template = "{{ array | reject: 'ok' | map: 'handle' | join: ' ' }}"
+    expected_output = "beta gamma"
+
+    assert_template_result(expected_output, template, { "array" => array })
+  end
+
+  def test_reject_with_value
+    array = [
      { "handle" => "alpha", "ok" => true },
+      { "handle" => "beta", "ok" => false },
+      { "handle" => "gamma", "ok" => false },
      { "handle" => "delta", "ok" => true },
    ]

-    assert_equal(expectation, @filters.where(input, "ok", true))
-    assert_equal(expectation, @filters.where(input, "ok"))
+    template = "{{ array | reject: 'ok', true | map: 'handle' | join: ' ' }}"
+    expected_output = "beta gamma"
+
+    assert_template_result(expected_output, template, { "array" => array })
+  end
+
+  def test_reject_with_false_value
+    array = [
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "beta", "ok" => false },
+      { "handle" => "gamma", "ok" => false },
+      { "handle" => "delta", "ok" => true },
+    ]
+
+    template = "{{ array | reject: 'ok', false | map: 'handle' | join: ' ' }}"
+    expected_output = "alpha delta"
+
+    assert_template_result(expected_output, template, { "array" => array })
+  end
+
+  def test_reject_with_deep_enumerables
+    template = <<~LIQUID
+      {{- products | reject: 'title.content', 'Pro goggles' | map: 'price.value' | join: ', ' -}}
+    LIQUID
+    expected_output = "1299, 3999, 3899, 1999"
+
+    assert_template_result(expected_output, template, { "products" => TestDeepEnumerable.new })
+  end
+
+  def test_has
+    array = [
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "beta", "ok" => false },
+      { "handle" => "gamma", "ok" => false },
+      { "handle" => "delta", "ok" => false },
+    ]
+
+    expected_output = "true"
+
+    assert_template_result(expected_output, "{{ array | has: 'ok' }}", { "array" => array })
+    assert_template_result(expected_output, "{{ array | has: 'ok', true }}", { "array" => array })
+  end
+
+  def test_has_when_does_not_have_it
+    array = [
+      { "handle" => "alpha", "ok" => false },
+      { "handle" => "beta", "ok" => false },
+      { "handle" => "gamma", "ok" => false },
+      { "handle" => "delta", "ok" => false },
+    ]
+
+    expected_output = "false"
+
+    assert_template_result(expected_output, "{{ array | has: 'ok' }}", { "array" => array })
+    assert_template_result(expected_output, "{{ array | has: 'ok', true }}", { "array" => array })
+  end
+
+  def test_has_with_false_value
+    array = [
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "beta", "ok" => false },
+      { "handle" => "gamma", "ok" => false },
+      { "handle" => "delta", "ok" => true },
+    ]
+
+    template = "{{ array | has: 'ok', false }}"
+    expected_output = "true"
+
+    assert_template_result(expected_output, template, { "array" => array })
+  end
+
+  def test_has_with_false_value_when_does_not_have_it
+    array = [
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "beta", "ok" => true },
+      { "handle" => "gamma", "ok" => true },
+      { "handle" => "delta", "ok" => true },
+    ]
+
+    template = "{{ array | has: 'ok', false }}"
+    expected_output = "false"
+
+    assert_template_result(expected_output, template, { "array" => array })
+  end
+
+  def test_has_with_deep_enumerables
+    template = <<~LIQUID
+      {{- products | has: 'title.content', 'Pro goggles' -}},
+      {{- products | has: 'title.content', 'foo' -}}
+    LIQUID
+    expected_output = "true,false"
+
+    assert_template_result(expected_output, template, { "products" => TestDeepEnumerable.new })
+  end
+
+  def test_find_with_value
+    products = [
+      { "title" => "Pro goggles",    "price" => 1299 },
+      { "title" => "Thermal gloves", "price" => 1499 },
+      { "title" => "Alpine jacket",  "price" => 3999 },
+      { "title" => "Mountain boots", "price" => 3899 },
+      { "title" => "Safety helmet",  "price" => 1999 }
+    ]
+
+    template = <<~LIQUID
+      {%- assign product = products | find: 'price', 3999 -%}
+      {{- product.title -}}
+    LIQUID
+    expected_output = "Alpine jacket"
+
+    assert_template_result(expected_output, template, { "products" => products })
+  end
+
+  def test_find_with_deep_enumerables
+    template = <<~LIQUID
+      {%- assign product = products | find: 'title.content', 'Pro goggles' -%}
+      {{- product.title.content -}}
+    LIQUID
+    expected_output = "Pro goggles"
+
+    assert_template_result(expected_output, template, { "products" => TestDeepEnumerable.new })
+  end
+
+  def test_find_index_with_value
+    products = [
+      { "title" => "Pro goggles",    "price" => 1299 },
+      { "title" => "Thermal gloves", "price" => 1499 },
+      { "title" => "Alpine jacket",  "price" => 3999 },
+      { "title" => "Mountain boots", "price" => 3899 },
+      { "title" => "Safety helmet",  "price" => 1999 }
+    ]
+
+    template = <<~LIQUID
+      {%- assign index = products | find_index: 'price', 3999 -%}
+      {{- index -}}
+    LIQUID
+    expected_output = "2"
+
+    assert_template_result(expected_output, template, { "products" => products })
+  end
+
+  def test_find_index_with_deep_enumerables
+    template = <<~LIQUID
+      {%- assign index = products | find_index: 'title.content', 'Alpine jacket' -%}
+      {{- index -}}
+    LIQUID
+    expected_output = "2"
+
+    assert_template_result(expected_output, template, { "products" => TestDeepEnumerable.new })
+  end
+
+  def test_where
+    array = [
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "beta", "ok" => false },
+      { "handle" => "gamma", "ok" => false },
+      { "handle" => "delta", "ok" => true },
+    ]
+
+    template = "{{ array | where: 'ok' | map: 'handle' | join: ' ' }}"
+    expected_output = "alpha delta"
+
+    assert_template_result(expected_output, template, { "array" => array })
+  end
+
+  def test_where_with_value
+    array = [
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "beta", "ok" => false },
+      { "handle" => "gamma", "ok" => false },
+      { "handle" => "delta", "ok" => true },
+    ]
+
+    template = "{{ array | where: 'ok', true | map: 'handle' | join: ' ' }}"
+    expected_output = "alpha delta"
+
+    assert_template_result(expected_output, template, { "array" => array })
+  end
+
+  def test_where_with_false_value
+    array = [
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "beta", "ok" => false },
+      { "handle" => "gamma", "ok" => false },
+      { "handle" => "delta", "ok" => true },
+    ]
+
+    template = "{{ array | where: 'ok', false | map: 'handle' | join: ' ' }}"
+    expected_output = "beta gamma"
+
+    assert_template_result(expected_output, template, { "array" => array })
  end

  def test_where_string_keys
@@ -900,6 +1158,15 @@ class StandardFiltersTest < Minitest::Test
    assert_nil(@filters.where([nil], "ok"))
  end

+  def test_where_with_deep_enumerables
+    template = <<~LIQUID
+      {{- products | where: 'title.content', 'Pro goggles' | map: 'price.value' -}}
+    LIQUID
+    expected_output = "1299"
+
+    assert_template_result(expected_output, template, { "products" => TestDeepEnumerable.new })
+  end
+
  def test_all_filters_never_raise_non_liquid_exception
    test_drop = TestDrop.new(value: "test")
    test_drop.context = Context.new
@@ -1051,6 +1318,15 @@ class StandardFiltersTest < Minitest::Test
    assert_template_result("0", "{{ input | sum: 'subtotal' }}", { "input" => input })
  end

+  def test_sum_with_deep_enumerables
+    template = <<~LIQUID
+      {{- products | sum: 'price.value' -}}
+    LIQUID
+    expected_output = "12495"
+
+    assert_template_result(expected_output, template, { "products" => TestDeepEnumerable.new })
+  end
+
  private

  def with_timezone(tz)
@@ -174,10 +174,10 @@ class IncludeTagTest < Minitest::Test
      end
    end

-    Liquid::Template.file_system = infinite_file_system.new
+    env = Liquid::Environment.build(file_system: infinite_file_system.new)

    assert_raises(Liquid::StackLevelError) do
-      Template.parse("{% include 'loop' %}").render!
+      Template.parse("{% include 'loop' %}", environment: env).render!
    end
  end

@@ -264,26 +264,27 @@ class IncludeTagTest < Minitest::Test
  end

  def test_does_not_add_error_in_strict_mode_for_missing_variable
-    Liquid::Template.file_system = TestFileSystem.new
+    env = Liquid::Environment.build(file_system: TestFileSystem.new)

-    a = Liquid::Template.parse(' {% include "nested_template" %}')
+    a = Liquid::Template.parse(' {% include "nested_template" %}', environment: env)
    a.render!
    assert_empty(a.errors)
  end

  def test_passing_options_to_included_templates
-    Liquid::Template.file_system = TestFileSystem.new
+    env = Liquid::Environment.build(file_system: TestFileSystem.new)
+
    assert_raises(Liquid::SyntaxError) do
-      Template.parse("{% include template %}", error_mode: :strict).render!("template" => '{{ "X" || downcase }}')
+      Template.parse("{% include template %}", error_mode: :strict, environment: env).render!("template" => '{{ "X" || downcase }}')
    end
    with_error_mode(:lax) do
-      assert_equal('x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: true).render!("template" => '{{ "X" || downcase }}'))
+      assert_equal('x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: true, environment: env).render!("template" => '{{ "X" || downcase }}'))
    end
    assert_raises(Liquid::SyntaxError) do
-      Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:locale]).render!("template" => '{{ "X" || downcase }}')
+      Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:locale], environment: env).render!("template" => '{{ "X" || downcase }}')
    end
    with_error_mode(:lax) do
-      assert_equal('x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:error_mode]).render!("template" => '{{ "X" || downcase }}'))
+      assert_equal('x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:error_mode], environment: env).render!("template" => '{{ "X" || downcase }}'))
    end
  end

@@ -334,8 +335,11 @@ class IncludeTagTest < Minitest::Test
  end

  def test_including_with_strict_variables
-    Liquid::Template.file_system = StubFileSystem.new({ "simple" => "simple" })
-    template = Liquid::Template.parse("{% include 'simple' %}", error_mode: :warn)
+    env = Liquid::Environment.build(
+      file_system: StubFileSystem.new('simple' => 'simple'),
+    )
+
+    template = Liquid::Template.parse("{% include 'simple' %}", error_mode: :warn, environment: env)
    template.render(nil, strict_variables: true)

    assert_equal([], template.errors)
@@ -82,19 +82,22 @@ class RenderTagTest < Minitest::Test
  end

  def test_recursively_rendered_template_does_not_produce_endless_loop
-    Liquid::Template.file_system = StubFileSystem.new('loop' => '{% render "loop" %}')
+    env = Liquid::Environment.build(
+      file_system: StubFileSystem.new('loop' => '{% render "loop" %}'),
+    )

    assert_raises(Liquid::StackLevelError) do
-      Template.parse('{% render "loop" %}').render!
+      Template.parse('{% render "loop" %}', environment: env).render!
    end
  end

  def test_sub_contexts_count_towards_the_same_recursion_limit
-    Liquid::Template.file_system = StubFileSystem.new(
-      'loop_render' => '{% render "loop_render" %}',
+    env = Liquid::Environment.build(
+      file_system: StubFileSystem.new('loop_render' => '{% render "loop_render" %}'),
    )
+
    assert_raises(Liquid::StackLevelError) do
-      Template.parse('{% render "loop_render" %}').render!
+      Template.parse('{% render "loop_render" %}', environment: env).render!
    end
  end

@@ -13,7 +13,7 @@ if (env_mode = ENV['LIQUID_PARSER_MODE'])
  puts "-- #{env_mode.upcase} ERROR MODE"
  mode = env_mode.to_sym
 end
-Liquid::Template.error_mode = mode
+Liquid::Environment.default.error_mode = mode

 if ENV['LIQUID_C'] == '1'
  puts "-- LIQUID C"
@@ -88,11 +88,11 @@ module Minitest
    end

    def with_error_mode(mode)
-      old_mode = Liquid::Template.error_mode
-      Liquid::Template.error_mode = mode
+      old_mode = Liquid::Environment.default.error_mode
+      Liquid::Environment.default.error_mode = mode
      yield
    ensure
-      Liquid::Template.error_mode = old_mode
+      Liquid::Environment.default.error_mode = old_mode
    end

    def with_custom_tag(tag_name, tag_class, &block)
@@ -2,7 +2,7 @@

 require 'test_helper'

-class StrainerFactoryUnitTest < Minitest::Test
+class EnvironmentFilterTest < Minitest::Test
  include Liquid

  module AccessScopeFilters
@@ -16,8 +16,6 @@ class StrainerFactoryUnitTest < Minitest::Test
    private :private_filter
  end

-  StrainerFactory.add_global_filter(AccessScopeFilters)
-
  module LateAddedFilter
    def late_added_filter(_input)
      "filtered"
@@ -25,24 +23,28 @@ class StrainerFactoryUnitTest < Minitest::Test
  end

  def setup
-    @context = Context.build
+    @environment = Liquid::Environment.build do |env|
+      env.register_filter(AccessScopeFilters)
+    end
+
+    @context = Context.build(environment: @environment)
  end

  def test_strainer
-    strainer = StrainerFactory.create(@context)
+    strainer = @environment.create_strainer(@context)
    assert_equal(5, strainer.invoke('size', 'input'))
    assert_equal("public", strainer.invoke("public_filter"))
  end

  def test_stainer_raises_argument_error
-    strainer = StrainerFactory.create(@context)
+    strainer = @environment.create_strainer(@context)
    assert_raises(Liquid::ArgumentError) do
      strainer.invoke("public_filter", 1)
    end
  end

  def test_stainer_argument_error_contains_backtrace
-    strainer = StrainerFactory.create(@context)
+    strainer = @environment.create_strainer(@context)

    exception = assert_raises(Liquid::ArgumentError) do
      strainer.invoke("public_filter", 1)
@@ -57,7 +59,7 @@ class StrainerFactoryUnitTest < Minitest::Test
  end

  def test_strainer_only_invokes_public_filter_methods
-    strainer = StrainerFactory.create(@context)
+    strainer = @environment.create_strainer(@context)
    assert_equal(false, strainer.class.invokable?('__test__'))
    assert_equal(false, strainer.class.invokable?('test'))
    assert_equal(false, strainer.class.invokable?('instance_eval'))
@@ -66,18 +68,18 @@ class StrainerFactoryUnitTest < Minitest::Test
  end

  def test_strainer_returns_nil_if_no_filter_method_found
-    strainer = StrainerFactory.create(@context)
+    strainer = @environment.create_strainer(@context)
    assert_nil(strainer.invoke("private_filter"))
    assert_nil(strainer.invoke("undef_the_filter"))
  end

  def test_strainer_returns_first_argument_if_no_method_and_arguments_given
-    strainer = StrainerFactory.create(@context)
+    strainer = @environment.create_strainer(@context)
    assert_equal("password", strainer.invoke("undef_the_method", "password"))
  end

  def test_strainer_only_allows_methods_defined_in_filters
-    strainer = StrainerFactory.create(@context)
+    strainer = @environment.create_strainer(@context)
    assert_equal("1 + 1", strainer.invoke("instance_eval", "1 + 1"))
    assert_equal("puts",  strainer.invoke("__send__", "puts", "Hi Mom"))
    assert_equal("has_method?", strainer.invoke("invoke", "has_method?", "invoke"))
@@ -86,7 +88,9 @@ class StrainerFactoryUnitTest < Minitest::Test
  def test_strainer_uses_a_class_cache_to_avoid_method_cache_invalidation
    a = Module.new
    b = Module.new
-    strainer = StrainerFactory.create(@context, [a, b])
+
+    strainer = @environment.create_strainer(@context, [a, b])
+
    assert_kind_of(StrainerTemplate, strainer)
    assert_kind_of(a, strainer)
    assert_kind_of(b, strainer)
@@ -94,8 +98,10 @@ class StrainerFactoryUnitTest < Minitest::Test
  end

  def test_add_global_filter_clears_cache
-    assert_equal('input', StrainerFactory.create(@context).invoke('late_added_filter', 'input'))
-    StrainerFactory.add_global_filter(LateAddedFilter)
-    assert_equal('filtered', StrainerFactory.create(nil).invoke('late_added_filter', 'input'))
+    assert_equal('input', @environment.create_strainer(@context).invoke('late_added_filter', 'input'))
+
+    @environment.register_filter(LateAddedFilter)
+
+    assert_equal('filtered', @environment.create_strainer(nil).invoke('late_added_filter', 'input'))
  end
 end
@@ -6,58 +6,134 @@ class LexerUnitTest < Minitest::Test
  include Liquid

  def test_strings
-    tokens = Lexer.new(%( 'this is a test""' "wat 'lol'")).tokenize
-    assert_equal([[:string, %('this is a test""')], [:string, %("wat 'lol'")], [:end_of_string]], tokens)
+    assert_equal(
+      [[:string, %('this is a test""')], [:string, %("wat 'lol'")], [:end_of_string]],
+      tokenize(%( 'this is a test""' "wat 'lol'")),
+    )
  end

  def test_integer
-    tokens = Lexer.new('hi 50').tokenize
-    assert_equal([[:id, 'hi'], [:number, '50'], [:end_of_string]], tokens)
+    assert_equal(
+      [[:id, 'hi'], [:number, '50'], [:end_of_string]],
+      tokenize('hi 50'),
+    )
  end

  def test_float
-    tokens = Lexer.new('hi 5.0').tokenize
-    assert_equal([[:id, 'hi'], [:number, '5.0'], [:end_of_string]], tokens)
+    assert_equal(
+      [[:id, 'hi'], [:number, '5.0'], [:end_of_string]],
+      tokenize('hi 5.0'),
+    )
  end

  def test_comparison
-    tokens = Lexer.new('== <> contains ').tokenize
-    assert_equal([[:comparison, '=='], [:comparison, '<>'], [:comparison, 'contains'], [:end_of_string]], tokens)
+    assert_equal(
+      [[:comparison, '=='], [:comparison, '<>'], [:comparison, 'contains'], [:end_of_string]],
+      tokenize('== <> contains '),
+    )
+  end
+
+  def test_comparison_without_whitespace
+    assert_equal(
+      [[:number, '1'], [:comparison, '>'], [:number, '0'], [:end_of_string]],
+      tokenize('1>0'),
+    )
+  end
+
+  def test_comparison_with_negative_number
+    assert_equal(
+      [[:number, '1'], [:comparison, '>'], [:number, '-1'], [:end_of_string]],
+      tokenize('1>-1'),
+    )
+  end
+
+  def test_raise_for_invalid_comparison
+    assert_raises(SyntaxError) do
+      tokenize('1>!1')
+    end
+
+    assert_raises(SyntaxError) do
+      tokenize('1=<1')
+    end
+
+    assert_raises(SyntaxError) do
+      tokenize('1!!1')
+    end
  end

  def test_specials
-    tokens = Lexer.new('| .:').tokenize
-    assert_equal([[:pipe, '|'], [:dot, '.'], [:colon, ':'], [:end_of_string]], tokens)
-    tokens = Lexer.new('[,]').tokenize
-    assert_equal([[:open_square, '['], [:comma, ','], [:close_square, ']'], [:end_of_string]], tokens)
+    assert_equal(
+      [[:pipe, '|'], [:dot, '.'], [:colon, ':'], [:end_of_string]],
+      tokenize('| .:'),
+    )
+
+    assert_equal(
+      [[:open_square, '['], [:comma, ','], [:close_square, ']'], [:end_of_string]],
+      tokenize('[,]'),
+    )
  end

  def test_fancy_identifiers
-    tokens = Lexer.new('hi five?').tokenize
-    assert_equal([[:id, 'hi'], [:id, 'five?'], [:end_of_string]], tokens)
+    assert_equal([[:id, 'hi'], [:id, 'five?'], [:end_of_string]], tokenize('hi five?'))

-    tokens = Lexer.new('2foo').tokenize
-    assert_equal([[:number, '2'], [:id, 'foo'], [:end_of_string]], tokens)
+    assert_equal([[:number, '2'], [:id, 'foo'], [:end_of_string]], tokenize('2foo'))
  end

  def test_whitespace
-    tokens = Lexer.new("five|\n\t ==").tokenize
-    assert_equal([[:id, 'five'], [:pipe, '|'], [:comparison, '=='], [:end_of_string]], tokens)
+    assert_equal(
+      [[:id, 'five'], [:pipe, '|'], [:comparison, '=='], [:end_of_string]],
+      tokenize("five|\n\t =="),
+    )
  end

  def test_unexpected_character
    assert_raises(SyntaxError) do
-      Lexer.new("%").tokenize
+      tokenize("%")
    end
  end

  def test_negative_numbers
-    tokens = Lexer.new("foo | default: -1").tokenize
-    assert_equal([[:id, 'foo'], [:pipe, '|'], [:id, 'default'], [:colon, ":"], [:number, '-1'], [:end_of_string]], tokens)
+    assert_equal(
+      [[:id, 'foo'], [:pipe, '|'], [:id, 'default'], [:colon, ":"], [:number, '-1'], [:end_of_string]],
+      tokenize("foo | default: -1"),
+    )
  end

  def test_greater_than_two_digits
-    tokens = Lexer.new("foo > 12").tokenize
-    assert_equal([[:id, 'foo'], [:comparison, '>'], [:number, '12'], [:end_of_string]], tokens)
+    assert_equal(
+      [[:id, 'foo'], [:comparison, '>'], [:number, '12'], [:end_of_string]],
+      tokenize("foo > 12"),
+    )
+  end
+
+  def test_error_with_utf8_character
+    error = assert_raises(SyntaxError) do
+      tokenize("1 < 1Ø")
+    end
+
+    assert_equal(
+      'Liquid syntax error: Unexpected character Ø',
+      error.message,
+    )
+  end
+
+  def test_contains_as_attribute_name
+    assert_equal(
+      [[:id, "a"], [:dot, "."], [:id, "contains"], [:dot, "."], [:id, "b"], [:end_of_string]],
+      tokenize("a.contains.b"),
+    )
+  end
+
+  def test_tokenize_incomplete_expression
+    assert_equal([[:id, "false"], [:dash, "-"], [:end_of_string]], tokenize("false -"))
+    assert_equal([[:id, "false"], [:comparison, "<"], [:end_of_string]], tokenize("false <"))
+    assert_equal([[:id, "false"], [:comparison, ">"], [:end_of_string]], tokenize("false >"))
+    assert_equal([[:id, "false"], [:number, "1"], [:end_of_string]], tokenize("false 1"))
+  end
+
+  private
+
+  def tokenize(input)
+    Lexer.new(input).tokenize
  end
 end
@@ -25,11 +25,13 @@ class StrainerTemplateUnitTest < Minitest::Test
  end

  def test_add_filter_raises_when_module_privately_overrides_registered_public_methods
-    strainer = Context.new.strainer
-
    error = assert_raises(Liquid::MethodOverrideError) do
-      strainer.class.add_filter(PrivateMethodOverrideFilter)
+      Liquid::Environment.build do |env|
+        env.register_filter(PublicMethodOverrideFilter)
+        env.register_filter(PrivateMethodOverrideFilter)
+      end
    end
+
    assert_equal('Liquid error: Filter overrides registered public methods as non public: public_filter', error.message)
  end

@@ -42,11 +44,13 @@ class StrainerTemplateUnitTest < Minitest::Test
  end

  def test_add_filter_raises_when_module_overrides_registered_public_method_as_protected
-    strainer = Context.new.strainer
-
    error = assert_raises(Liquid::MethodOverrideError) do
-      strainer.class.add_filter(ProtectedMethodOverrideFilter)
+      Liquid::Environment.build do |env|
+        env.register_filter(PublicMethodOverrideFilter)
+        env.register_filter(ProtectedMethodOverrideFilter)
+      end
    end
+
    assert_equal('Liquid error: Filter overrides registered public methods as non public: public_filter', error.message)
  end

@@ -20,50 +20,12 @@ class TemplateUnitTest < Minitest::Test
    assert_equal(fixture("en_locale.yml"), locale.path)
  end

-  def test_with_cache_classes_tags_returns_the_same_class
-    original_cache_setting = Liquid.cache_classes
-    Liquid.cache_classes   = true
-
-    original_klass = Class.new
-    Object.send(:const_set, :CustomTag, original_klass)
-    Template.register_tag('custom', CustomTag)
-
-    Object.send(:remove_const, :CustomTag)
-
-    new_klass = Class.new
-    Object.send(:const_set, :CustomTag, new_klass)
-
-    assert(Template.tags['custom'].equal?(original_klass))
-  ensure
-    Object.send(:remove_const, :CustomTag)
-    Liquid.cache_classes = original_cache_setting
-  end
-
-  def test_without_cache_classes_tags_reloads_the_class
-    original_cache_setting = Liquid.cache_classes
-    Liquid.cache_classes   = false
-
-    original_klass = Class.new
-    Object.send(:const_set, :CustomTag, original_klass)
-    with_custom_tag('custom', CustomTag) do
-      Object.send(:remove_const, :CustomTag)
-
-      new_klass = Class.new
-      Object.send(:const_set, :CustomTag, new_klass)
-
-      assert(Template.tags['custom'].equal?(new_klass))
-    end
-  ensure
-    Object.send(:remove_const, :CustomTag)
-    Liquid.cache_classes = original_cache_setting
-  end
-
  class FakeTag; end

  def test_tags_can_be_looped_over
    with_custom_tag('fake', FakeTag) do
      result = Template.tags.map { |name, klass| [name, klass] }
-      assert(result.include?(["fake", "TemplateUnitTest::FakeTag"]))
+      assert(result.include?(["fake", TemplateUnitTest::FakeTag]))
    end
  end
Author	SHA1	Message	Date
Guilherme Carreiro	4df1145c24	Top Hat changes	2024-12-05 08:57:53 +01:00
Guilherme Carreiro	41a77c68c6	Add `find`, `find_index`, `has`, and `reject` filters to arrays	2024-12-03 14:42:47 +01:00
Guilherme Carreiro	3d1e2d434e	Update branch with main	2024-12-03 14:14:36 +01:00
Anders SøgaardandGuilherme Carreiro	1058a7768f	Add deep search for filter taking in properties #1749	2024-12-03 14:11:15 +01:00
Anders SøgaardandGuilherme Carreiro	4b01977067	Add reject filter #1573	2024-12-03 14:07:26 +01:00
Ian Ker-Seymer	42b6763546	Bump to `v5.6.0.rc1`	2024-11-04 15:26:56 -05:00
Michael GoandGitHub	e5d18c83bb	Merge pull request #1848 from Shopify/env-warn-cleanup clean up all warnings by using new Environment	2024-11-04 16:17:17 -04:00
Michael Go	c77ff68573	clean up all warnings by using new Environment	2024-11-04 16:15:05 -04:00
Ian Ker-SeymerandGitHub	b0cba0bfd2	Remove `Liquid.cache_classes` option (#1847 )	2024-11-04 14:41:56 -05:00
Michael GoandGitHub	8d8661349a	Merge pull request #1843 from Shopify/empty-array avoid allocating new empty array	2024-11-04 15:36:46 -04:00
Michael Go	1f3ea7322b	avoid allocating new empty array	2024-11-04 15:35:45 -04:00
Michael GoandGitHub	06f44226c0	Merge pull request #1846 from Shopify/env-propgating propagate Environment on new Context creation	2024-11-04 15:33:50 -04:00
Michael GoandGitHub	4bd22a26dc	Merge pull request #1845 from Shopify/remove-tag-registry remove TagRegistry	2024-11-04 15:33:30 -04:00
Michael Go	3ed54bfdf9	propagate Environment on new Context creation	2024-11-04 15:32:07 -04:00
Michael Go	29986d3704	remove TagRegistry	2024-11-04 15:22:56 -04:00
Michael GoandGitHub	8e40f8050a	Merge pull request #1838 from Shopify/quirky-lexer-parsing fix parsing quirky incomplete expressions	2024-10-30 13:52:47 -03:00
Michael Go	ffce6de8bb	avoid using StringScanner eos	2024-10-30 13:45:10 -03:00
Michael Go	f00670cb01	refactor lexer unit test	2024-10-30 13:44:36 -03:00
Michael Go	f6a3e25e2e	fix parsing quirky incomplete expressions	2024-10-30 13:44:35 -03:00
Michael GoandGitHub	f6ffc37cf2	Merge pull request #1840 from Shopify/fix-lexer-contains-as-id fix lexer parsing ID 'contains' as comparison	2024-10-30 13:43:48 -03:00
Michael Go	1375a9e4dc	fix lexer parsing ID 'contains' as comparison	2024-10-30 13:39:55 -03:00
Michael GoandGitHub	c626dfa1a1	Merge pull request #1839 from Shopify/lexer-parse-error-with-utf8 raise syntax error from lexer parser with UTF-8 character	2024-10-30 13:39:05 -03:00
Michael Go	8a9f33a060	raise syntax error from lexer parser with utf8 character	2024-10-29 22:04:37 -03:00
Michael GoandGitHub	1943441361	Merge pull request #1835 from Shopify/fix-multibyte-variable-parsing fix parsing Variable blockbody with multibyte character	2024-10-28 19:31:21 -03:00
Michael GoandGitHub	36251e640c	Merge pull request #1837 from Shopify/lexer-comparison-fix fix lexer parsing comparison without whitespaces	2024-10-28 19:31:11 -03:00
Michael Go	d94293a464	fix lexer parsing comparison without whitespaces	2024-10-28 19:30:12 -03:00