don't create string scanner for liquid tag

mini opt
appease rubocop
2026-09-15 00:40:40 -07:00 · 2024-11-01 17:31:05 -03:00 · 2024-11-01 17:30:18 -03:00 · 2024-11-01 17:24:09 -03:00 · 2024-11-01 17:19:50 -03:00 · 2024-11-01 17:11:10 -03:00
31 changed files with 406 additions and 592 deletions
@@ -8,7 +8,6 @@ end
 gemspec

 gem "base64"
-gem "webrick"

 group :benchmark, :test do
  gem 'benchmark-ips'
@@ -29,3 +28,5 @@ group :test do
    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'main'
  end
 end
+
+gem "strscan", ">= 3.1"
@@ -73,7 +73,7 @@ end

 namespace :benchmark do
  desc "Run the liquid benchmark with lax parsing"
-  task :run do
+  task :lax do
    ruby "./performance/benchmark.rb lax"
  end

@@ -82,6 +82,9 @@ namespace :benchmark do
    ruby "./performance/benchmark.rb strict"
  end

+  desc "Run the liquid benchmark with both lax and strict parsing"
+  task run: [:lax, :strict]
+
  desc "Run unit benchmarks"
  task :unit do
    Dir["./performance/unit/*_benchmark.rb"].each do |file|
@@ -20,7 +20,7 @@ end

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

  def products
@@ -29,42 +29,11 @@ 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' => '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' }
+      { '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' }
    ]
  end

@@ -1,71 +1,6 @@
-{% # 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>Hello world!</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>It is {{date}}</p>


-  <h2>
-    reject
-  </h2>
-  <pre>
-    {{ products | map: "name" | join: ", " }}
-    {{ products | reject: "name", "Mountain boots" | map: "name" | join: ", " }}
-  </pre>
-
-</body>
-</html>
+<p>Check out the <a href="/products">Products</a> screen </p>
@@ -44,11 +44,15 @@ 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'
@@ -68,6 +72,7 @@ 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, environment, &block)
+      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_environments, &block)
    end

    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_environments = {}, environment = Environment.default)
@@ -143,7 +143,6 @@ 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 = tags if tags
+        ret.tags = Template::TagRegistry.new(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 = Tags::STANDARD_TAGS.dup
+      @tags = Template::TagRegistry.new(Tags::STANDARD_TAGS)
      @error_mode = :lax
      @strainer_template = Class.new(StrainerTemplate).tap do |klass|
        klass.add_filter(StandardFilters)
@@ -92,6 +92,7 @@ module Liquid
    SINGLE_COMPARISON_TOKENS = [].tap do |table|
      table["<".ord] = COMPARISON_LESS_THAN
      table[">".ord] = COMPARISON_GREATER_THAN
+      table.freeze
    end

    TWO_CHARS_COMPARISON_JUMP_TABLE = [].tap do |table|
@@ -103,18 +104,17 @@ module Liquid
        sub_table["=".ord] = COMPARISION_NOT_EQUAL
        sub_table.freeze
      end
+      table.freeze
    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
-        RUBY_WHITESPACE.each { |c| sub_table[c.ord] = COMPARISON_LESS_THAN }
        sub_table.freeze
      end
      table[">".ord] = [].tap do |sub_table|
        sub_table["=".ord] = COMPARISON_GREATER_THAN_OR_EQUAL
-        RUBY_WHITESPACE.each { |c| sub_table[c.ord] = COMPARISON_GREATER_THAN }
        sub_table.freeze
      end
      table.freeze
@@ -233,5 +233,6 @@ module Liquid
    end
  end

+  # Remove this once we can depend on strscan >= 3.1.1
  Lexer = StringScanner.instance_methods.include?(:scan_byte) ? Lexer2 : Lexer1
 end
@@ -36,7 +36,7 @@ module Liquid
    protected

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

-    # @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)
+      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
    end

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

+require "strscan"
+
 module Liquid
-  class Tokenizer
+  class Tokenizer1
    attr_reader :line_number, :for_liquid_tag

    def initialize(source, line_numbers = false, line_number: nil, for_liquid_tag: false)
@@ -42,4 +44,147 @@ module Liquid
      tokens
    end
  end
+
+  class Tokenizer2
+    attr_reader :line_number, :for_liquid_tag
+
+    TAG_END = /%\}/
+    TAG_OR_VARIABLE_START = /\{[\{\%]/
+    NEWLINE = /\n/
+
+    OPEN_CURLEY = "{".ord
+    CLOSE_CURLEY = "}".ord
+    PERCENTAGE = "%".ord
+
+    def initialize(source, line_numbers = false, line_number: nil, for_liquid_tag: false)
+      @line_number    = line_number || (line_numbers ? 1 : nil)
+      @for_liquid_tag = for_liquid_tag
+      @source         = source
+      @offset         = 0
+      @tokens         = []
+      tokenize
+    end
+
+    def shift
+      token = @tokens[@offset]
+
+      return unless token
+
+      @offset += 1
+
+      if @line_number
+        @line_number += @for_liquid_tag ? 1 : token.count("\n")
+      end
+
+      token
+    end
+
+    private
+
+    def tokenize
+      if @for_liquid_tag
+        @tokens = @source.split("\n")
+      else
+        @ss = StringScanner.new(@source)
+        @tokens << shift_normal until @ss.eos?
+      end
+
+      @ss = nil
+      @source = nil
+    end
+
+    def shift_normal
+      token = next_token
+
+      return unless token
+
+      token
+    end
+
+    def next_token
+      # possible states: :text, :tag, :variable
+      byte_a = @ss.peek_byte
+
+      if byte_a == OPEN_CURLEY
+        @ss.scan_byte
+
+        byte_b = @ss.peek_byte
+
+        if byte_b == PERCENTAGE
+          @ss.scan_byte
+          return next_tag_token
+        elsif byte_b == OPEN_CURLEY
+          @ss.scan_byte
+          return next_variable_token
+        end
+
+        @ss.pos -= 1
+      end
+
+      next_text_token
+    end
+
+    def next_text_token
+      start = @ss.pos
+
+      unless @ss.skip_until(TAG_OR_VARIABLE_START)
+        token = @ss.rest
+        @ss.terminate
+        return token
+      end
+
+      pos = @ss.pos -= 2
+      @source.byteslice(start, pos - start)
+    end
+
+    def next_variable_token
+      start = @ss.pos - 2
+
+      byte_a = byte_b = @ss.scan_byte
+
+      while byte_b
+        byte_a = @ss.scan_byte while byte_a && (byte_a != CLOSE_CURLEY && byte_a != OPEN_CURLEY)
+
+        break unless byte_a
+
+        if @ss.eos?
+          return byte_a == CLOSE_CURLEY ? @source.byteslice(start, @ss.pos - start) : "{{"
+        end
+
+        byte_b = @ss.scan_byte
+
+        if byte_a == CLOSE_CURLEY
+          if byte_b == CLOSE_CURLEY
+            return @source.byteslice(start, @ss.pos - start)
+          elsif byte_b != CLOSE_CURLEY
+            @ss.pos -= 1
+            return @source.byteslice(start, @ss.pos - start)
+          end
+        elsif byte_a == OPEN_CURLEY && byte_b == PERCENTAGE
+          return next_tag_token_with_start(start)
+        end
+
+        byte_a = byte_b
+      end
+
+      "{{"
+    end
+
+    def next_tag_token
+      start = @ss.pos - 2
+      if (len = @ss.skip_until(TAG_END))
+        @source.byteslice(start, len + 2)
+      else
+        "{%"
+      end
+    end
+
+    def next_tag_token_with_start(start)
+      @ss.skip_until(TAG_END)
+      @source.byteslice(start, @ss.pos - start)
+    end
+  end
+
+  # Remove this once we can depend on strscan >= 3.1.1
+  Tokenizer = StringScanner.instance_methods.include?(:scan_byte) ? Tokenizer2 : Tokenizer1
 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) : Const::EMPTY_ARRAY
+        filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
        @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.rc1"
+  VERSION = "5.6.0.alpha"
 end
@@ -4,19 +4,21 @@ require 'benchmark/ips'
 require_relative 'theme_runner'

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

 Benchmark.ips do |x|
-  x.time   = 10
-  x.warmup = 5
+  x.time   = 20
+  x.warmup = 10

  puts
  puts "Running benchmark for #{x.time} seconds (with #{x.warmup} seconds warmup)."
  puts

-  x.report("parse:") { profiler.compile }
-  x.report("render:") { profiler.render }
-  x.report("parse & render:") { profiler.run }
+  phase = ENV["PHASE"] || "all"
+
+  x.report("tokenize:") { profiler.tokenize } if phase == "all" || phase == "tokenize"
+  x.report("parse:") { profiler.compile } if phase == "all" || phase == "parse"
+  x.report("render:") { profiler.render } if phase == "all" || phase == "render"
+  x.report("parse & render:") { profiler.run } if phase == "all" || phase == "run"
 end
@@ -11,12 +11,11 @@ require_relative 'shop_filter'
 require_relative 'tag_filter'
 require_relative 'weight_filter'

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

-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)
+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)
@@ -48,6 +48,14 @@ class ThemeRunner
    end
  end

+  # `tokenize` will just test the tokenizen portion of liquid without any templates
+  def tokenize
+    @tests.each do |test_hash|
+      tokenizer = Liquid::Tokenizer.new(test_hash[:liquid], true)
+      while tokenizer.shift; end
+    end
+  end
+
  # `run` is called to benchmark rendering and compiling at the same time
  def run
    each_test do |liquid, layout, assigns, page_template, template_name|
@@ -672,21 +672,6 @@ 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,19 +203,20 @@ class ErrorHandlingTest < Minitest::Test
  end

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

    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
@@ -134,6 +134,14 @@ class ParsingQuirksTest < Minitest::Test

  def test_incomplete_expression
    with_error_mode(:lax) do
+      assert_template_result("false", "{{ false - }}")
+      assert_template_result("false", "{{ false > }}")
+      assert_template_result("false", "{{ false < }}")
+      assert_template_result("false", "{{ false = }}")
+      assert_template_result("false", "{{ false ! }}")
+      assert_template_result("false", "{{ false 1 }}")
+      assert_template_result("false", "{{ false a }}")
+
      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 }}")
@@ -33,7 +33,7 @@ class ProfilerTest < Minitest::Test
  end

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

  def test_template_allows_flagging_profiling
@@ -54,30 +54,6 @@ 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
@@ -416,15 +392,6 @@ 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
@@ -461,15 +428,6 @@ 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
@@ -486,15 +444,6 @@ 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
@@ -604,15 +553,6 @@ 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] })
@@ -887,219 +827,21 @@ class StandardFiltersTest < Minitest::Test
    assert_template_result('abc', "{{ 'abc' | date: '%D' }}")
  end

-  def test_reject
-    array = [
-      { "handle" => "alpha", "ok" => true },
-      { "handle" => "beta", "ok" => false },
-      { "handle" => "gamma", "ok" => false },
-      { "handle" => "delta", "ok" => true },
-    ]
-
-    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 },
-    ]
-
-    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 = [
+    input = [
      { "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 = [
+    expectation = [
      { "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 })
+    assert_equal(expectation, @filters.where(input, "ok", true))
+    assert_equal(expectation, @filters.where(input, "ok"))
  end

  def test_where_string_keys
@@ -1158,15 +900,6 @@ 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
@@ -1318,15 +1051,6 @@ 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

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

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

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

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

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

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

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

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

    assert_equal([], template.errors)
@@ -16,6 +16,7 @@ class RawTagTest < Minitest::Test
    assert_template_result('>{{ test }}<', '> {%- raw -%}{{ test }}{%- endraw -%} <')
    assert_template_result("> inner  <", "> {%- raw -%} inner {%- endraw %} <")
    assert_template_result("> inner <", "> {%- raw -%} inner {%- endraw -%} <")
+    assert_template_result("{Hello}", "{% raw %}{{% endraw %}Hello{% raw %}}{% endraw %}")
  end

  def test_open_tag_in_raw
@@ -82,22 +82,19 @@ class RenderTagTest < Minitest::Test
  end

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

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

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

@@ -88,11 +88,11 @@ module Minitest
    end

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

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

 require 'test_helper'

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

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

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

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

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

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

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

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

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

  def test_strainer_returns_nil_if_no_filter_method_found
-    strainer = @environment.create_strainer(@context)
+    strainer = StrainerFactory.create(@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 = @environment.create_strainer(@context)
+    strainer = StrainerFactory.create(@context)
    assert_equal("password", strainer.invoke("undef_the_method", "password"))
  end

  def test_strainer_only_allows_methods_defined_in_filters
-    strainer = @environment.create_strainer(@context)
+    strainer = StrainerFactory.create(@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"))
@@ -88,9 +86,7 @@ class EnvironmentFilterTest < Minitest::Test
  def test_strainer_uses_a_class_cache_to_avoid_method_cache_invalidation
    a = Module.new
    b = Module.new
-
-    strainer = @environment.create_strainer(@context, [a, b])
-
+    strainer = StrainerFactory.create(@context, [a, b])
    assert_kind_of(StrainerTemplate, strainer)
    assert_kind_of(a, strainer)
    assert_kind_of(b, strainer)
@@ -98,10 +94,8 @@ class EnvironmentFilterTest < Minitest::Test
  end

  def test_add_global_filter_clears_cache
-    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'))
+    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'))
  end
 end
@@ -25,13 +25,11 @@ class StrainerTemplateUnitTest < Minitest::Test
  end

  def test_add_filter_raises_when_module_privately_overrides_registered_public_methods
-    error = assert_raises(Liquid::MethodOverrideError) do
-      Liquid::Environment.build do |env|
-        env.register_filter(PublicMethodOverrideFilter)
-        env.register_filter(PrivateMethodOverrideFilter)
-      end
-    end
+    strainer = Context.new.strainer

+    error = assert_raises(Liquid::MethodOverrideError) do
+      strainer.class.add_filter(PrivateMethodOverrideFilter)
+    end
    assert_equal('Liquid error: Filter overrides registered public methods as non public: public_filter', error.message)
  end

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

  def test_add_filter_raises_when_module_overrides_registered_public_method_as_protected
-    error = assert_raises(Liquid::MethodOverrideError) do
-      Liquid::Environment.build do |env|
-        env.register_filter(PublicMethodOverrideFilter)
-        env.register_filter(ProtectedMethodOverrideFilter)
-      end
-    end
+    strainer = Context.new.strainer

+    error = assert_raises(Liquid::MethodOverrideError) do
+      strainer.class.add_filter(ProtectedMethodOverrideFilter)
+    end
    assert_equal('Liquid error: Filter overrides registered public methods as non public: public_filter', error.message)
  end

@@ -20,12 +20,50 @@ 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

@@ -6,6 +6,7 @@ class TokenizerTest < Minitest::Test
  def test_tokenize_strings
    assert_equal([' '], tokenize(' '))
    assert_equal(['hello world'], tokenize('hello world'))
+    assert_equal(['{}'], tokenize('{}'))
  end

  def test_tokenize_variables
@@ -30,6 +31,19 @@ class TokenizerTest < Minitest::Test
    assert_equal([1, 1, 3], tokenize_line_numbers(" {{\n funk \n}} "))
  end

+  def test_incomplete_curly_braces
+    assert_equal(["{{.}", " "], tokenize('{{.} '))
+    assert_equal(["{{}", "%}"], tokenize('{{}%}'))
+    assert_equal(["{{}}", "}"], tokenize('{{}}}'))
+  end
+
+  def test_unmatching_start_and_end
+    assert_equal(["{{%}"], tokenize('{{%}'))
+    assert_equal(["{{%%%}}"], tokenize('{{%%%}}'))
+    assert_equal(["{%", "}}"], tokenize('{%}}'))
+    assert_equal(["{%%}", "}"], tokenize('{%%}}'))
+  end
+
  private

  def new_tokenizer(source, parse_context: Liquid::ParseContext.new, start_line_number: nil)
Author	SHA1	Message	Date
Michael Go	fe2ba1d8da	don't create string scanner for liquid tag	2024-11-01 17:31:05 -03:00
Michael Go	fa51b8be40	mini opt	2024-11-01 17:30:18 -03:00
Michael Go	f77075895a	appease rubocop	2024-11-01 17:24:09 -03:00
Michael Go	579b899e24	mini opt	2024-11-01 17:19:50 -03:00
Michael Go	7ac53a3639	use String#split for liquid tag tokenization	2024-11-01 17:11:10 -03:00
Michael Go	f49ceed826	mini opt	2024-11-01 17:06:28 -03:00
Michael Go	d2b68b81a7	undo mini opt	2024-11-01 17:02:09 -03:00
Michael Go	7d9ffdce03	mini opt	2024-11-01 16:36:25 -03:00
Michael Go	2e4d02f4d1	mini opt	2024-11-01 16:22:01 -03:00
Ian Ker-SeymerandGitHub	a0c64e4cbd	Update strscan comment	2024-10-31 16:57:52 -04:00
Michael Go	b4907f6323	pre-calculate tokens	2024-10-31 15:46:48 -03:00
Michael Go	78ef372878	backward compatible tokenizer	2024-10-30 14:31:55 -03:00
Michael Go	2a829b889e	add more quirky lexer parsing unit test	2024-10-30 13:54:01 -03:00
Michael Go	15d117926d	more less strict strscan version requirement	2024-10-30 13:54:01 -03:00
Michael Go	936f73dc30	refactor tokenizer to simulate original regex properly	2024-10-30 13:54:01 -03:00
Michael Go	fecbc62533	remove unnecessary comparison jump table entries	2024-10-30 13:54:01 -03:00
Michael Go	b7b6400985	fix typo	2024-10-30 13:54:01 -03:00
Ian Ker-SeymerandMichael Go	be8e329cef	more opt	2024-10-30 13:54:01 -03:00
Ian Ker-SeymerandMichael Go	d76663f570	more opt	2024-10-30 13:54:01 -03:00
Ian Ker-SeymerandMichael Go	f42c6b0608	more opt	2024-10-30 13:54:01 -03:00
Ian Ker-SeymerandMichael Go	aa45356133	Avoid method dispatch	2024-10-30 13:54:01 -03:00
Michael Go	a406603e9f	more micro optimization	2024-10-30 13:54:01 -03:00
Michael Go	54975ddac1	more micro optimization	2024-10-30 13:54:01 -03:00
Michael Go	91e1563e1c	more micro optimization	2024-10-30 13:54:01 -03:00
Michael Go	0346337c05	more micro optimization	2024-10-30 13:54:01 -03:00
Michael Go	649b64ffd4	more micro optimization	2024-10-30 13:54:01 -03:00
Michael Go	48d6a03de6	more micro optimization	2024-10-30 13:54:01 -03:00
Michael Go	9e0c5f4747	more micro optimization	2024-10-30 13:54:00 -03:00
Michael Go	e06ac1bc9c	more micro optimization	2024-10-30 13:54:00 -03:00
Michael Go	c2baa4c270	more micro optimization	2024-10-30 13:54:00 -03:00
Michael Go	b81d1c8c5d	more micro optimization	2024-10-30 13:54:00 -03:00
Michael Go	e3c2fd47b2	more micro optimization	2024-10-30 13:54:00 -03:00
Michael Go	1b3927ee1d	more micro optimization	2024-10-30 13:54:00 -03:00
Michael Go	6ad7508ce2	more micro optimization	2024-10-30 13:54:00 -03:00
Michael Go	ddb969af8b	more micro optimization	2024-10-30 13:54:00 -03:00
Michael Go	128935dcef	micro optimization	2024-10-30 13:54:00 -03:00
Michael Go	b545e3ae6a	lazy tokenizer	2024-10-30 13:54:00 -03:00
Michael Go	59699075a2	refactor lexer unit test	2024-10-30 13:53:57 -03:00
Michael Go	12b5a35e26	fix parsing quirky incomplete expressions	2024-10-30 13:53:34 -03:00