Vendor bundled gems for deployment

16 files changed, 1474 insertions, 0 deletions

diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/block_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/block_unit_test.rb
new file mode 100644
index 0000000..6a27a7d
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/block_unit_test.rb
@@ -0,0 +1,58 @@
+require 'test_helper'
+
+class BlockUnitTest < Minitest::Test
+  include Liquid
+
+  def test_blankspace
+    template = Liquid::Template.parse("  ")
+    assert_equal ["  "], template.root.nodelist
+  end
+
+  def test_variable_beginning
+    template = Liquid::Template.parse("{{funk}}  ")
+    assert_equal 2, template.root.nodelist.size
+    assert_equal Variable, template.root.nodelist[0].class
+    assert_equal String, template.root.nodelist[1].class
+  end
+
+  def test_variable_end
+    template = Liquid::Template.parse("  {{funk}}")
+    assert_equal 2, template.root.nodelist.size
+    assert_equal String, template.root.nodelist[0].class
+    assert_equal Variable, template.root.nodelist[1].class
+  end
+
+  def test_variable_middle
+    template = Liquid::Template.parse("  {{funk}}  ")
+    assert_equal 3, template.root.nodelist.size
+    assert_equal String, template.root.nodelist[0].class
+    assert_equal Variable, template.root.nodelist[1].class
+    assert_equal String, template.root.nodelist[2].class
+  end
+
+  def test_variable_many_embedded_fragments
+    template = Liquid::Template.parse("  {{funk}} {{so}} {{brother}} ")
+    assert_equal 7, template.root.nodelist.size
+    assert_equal [String, Variable, String, Variable, String, Variable, String],
+      block_types(template.root.nodelist)
+  end
+
+  def test_with_block
+    template = Liquid::Template.parse("  {% comment %} {% endcomment %} ")
+    assert_equal [String, Comment, String], block_types(template.root.nodelist)
+    assert_equal 3, template.root.nodelist.size
+  end
+
+  def test_with_custom_tag
+    Liquid::Template.register_tag("testtag", Block)
+    assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
+  ensure
+    Liquid::Template.tags.delete('testtag')
+  end
+
+  private
+
+  def block_types(nodelist)
+    nodelist.collect(&:class)
+  end
+end # VariableTest
diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/condition_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/condition_unit_test.rb
new file mode 100644
index 0000000..b3b90e8
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/condition_unit_test.rb
@@ -0,0 +1,166 @@
+require 'test_helper'
+
+class ConditionUnitTest < Minitest::Test
+  include Liquid
+
+  def setup
+    @context = Liquid::Context.new
+  end
+
+  def test_basic_condition
+    assert_equal false, Condition.new(1, '==', 2).evaluate
+    assert_equal true,  Condition.new(1, '==', 1).evaluate
+  end
+
+  def test_default_operators_evalute_true
+    assert_evaluates_true 1, '==', 1
+    assert_evaluates_true 1, '!=', 2
+    assert_evaluates_true 1, '<>', 2
+    assert_evaluates_true 1, '<', 2
+    assert_evaluates_true 2, '>', 1
+    assert_evaluates_true 1, '>=', 1
+    assert_evaluates_true 2, '>=', 1
+    assert_evaluates_true 1, '<=', 2
+    assert_evaluates_true 1, '<=', 1
+    # negative numbers
+    assert_evaluates_true 1, '>', -1
+    assert_evaluates_true -1, '<', 1
+    assert_evaluates_true 1.0, '>', -1.0
+    assert_evaluates_true -1.0, '<', 1.0
+  end
+
+  def test_default_operators_evalute_false
+    assert_evaluates_false 1, '==', 2
+    assert_evaluates_false 1, '!=', 1
+    assert_evaluates_false 1, '<>', 1
+    assert_evaluates_false 1, '<', 0
+    assert_evaluates_false 2, '>', 4
+    assert_evaluates_false 1, '>=', 3
+    assert_evaluates_false 2, '>=', 4
+    assert_evaluates_false 1, '<=', 0
+    assert_evaluates_false 1, '<=', 0
+  end
+
+  def test_contains_works_on_strings
+    assert_evaluates_true 'bob', 'contains', 'o'
+    assert_evaluates_true 'bob', 'contains', 'b'
+    assert_evaluates_true 'bob', 'contains', 'bo'
+    assert_evaluates_true 'bob', 'contains', 'ob'
+    assert_evaluates_true 'bob', 'contains', 'bob'
+
+    assert_evaluates_false 'bob', 'contains', 'bob2'
+    assert_evaluates_false 'bob', 'contains', 'a'
+    assert_evaluates_false 'bob', 'contains', '---'
+  end
+
+  def test_invalid_comparation_operator
+    assert_evaluates_argument_error 1, '~~', 0
+  end
+
+  def test_comparation_of_int_and_str
+    assert_evaluates_argument_error '1', '>', 0
+    assert_evaluates_argument_error '1', '<', 0
+    assert_evaluates_argument_error '1', '>=', 0
+    assert_evaluates_argument_error '1', '<=', 0
+  end
+
+  def test_hash_compare_backwards_compatibility
+    assert_nil Condition.new({}, '>', 2).evaluate
+    assert_nil Condition.new(2, '>', {}).evaluate
+    assert_equal false, Condition.new({}, '==', 2).evaluate
+    assert_equal true, Condition.new({ 'a' => 1 }, '==', { 'a' => 1 }).evaluate
+    assert_equal true, Condition.new({ 'a' => 2 }, 'contains', 'a').evaluate
+  end
+
+  def test_contains_works_on_arrays
+    @context = Liquid::Context.new
+    @context['array'] = [1, 2, 3, 4, 5]
+    array_expr = VariableLookup.new("array")
+
+    assert_evaluates_false array_expr, 'contains', 0
+    assert_evaluates_true array_expr, 'contains', 1
+    assert_evaluates_true array_expr, 'contains', 2
+    assert_evaluates_true array_expr, 'contains', 3
+    assert_evaluates_true array_expr, 'contains', 4
+    assert_evaluates_true array_expr, 'contains', 5
+    assert_evaluates_false array_expr, 'contains', 6
+    assert_evaluates_false array_expr, 'contains', "1"
+  end
+
+  def test_contains_returns_false_for_nil_operands
+    @context = Liquid::Context.new
+    assert_evaluates_false VariableLookup.new('not_assigned'), 'contains', '0'
+    assert_evaluates_false 0, 'contains', VariableLookup.new('not_assigned')
+  end
+
+  def test_contains_return_false_on_wrong_data_type
+    assert_evaluates_false 1, 'contains', 0
+  end
+
+  def test_contains_with_string_left_operand_coerces_right_operand_to_string
+    assert_evaluates_true ' 1 ', 'contains', 1
+    assert_evaluates_false ' 1 ', 'contains', 2
+  end
+
+  def test_or_condition
+    condition = Condition.new(1, '==', 2)
+
+    assert_equal false, condition.evaluate
+
+    condition.or Condition.new(2, '==', 1)
+
+    assert_equal false, condition.evaluate
+
+    condition.or Condition.new(1, '==', 1)
+
+    assert_equal true, condition.evaluate
+  end
+
+  def test_and_condition
+    condition = Condition.new(1, '==', 1)
+
+    assert_equal true, condition.evaluate
+
+    condition.and Condition.new(2, '==', 2)
+
+    assert_equal true, condition.evaluate
+
+    condition.and Condition.new(2, '==', 1)
+
+    assert_equal false, condition.evaluate
+  end
+
+  def test_should_allow_custom_proc_operator
+    Condition.operators['starts_with'] = proc { |cond, left, right| left =~ %r{^#{right}} }
+
+    assert_evaluates_true 'bob', 'starts_with', 'b'
+    assert_evaluates_false 'bob', 'starts_with', 'o'
+  ensure
+    Condition.operators.delete 'starts_with'
+  end
+
+  def test_left_or_right_may_contain_operators
+    @context = Liquid::Context.new
+    @context['one'] = @context['another'] = "gnomeslab-and-or-liquid"
+
+    assert_evaluates_true VariableLookup.new("one"), '==', VariableLookup.new("another")
+  end
+
+  private
+
+  def assert_evaluates_true(left, op, right)
+    assert Condition.new(left, op, right).evaluate(@context),
+      "Evaluated false: #{left} #{op} #{right}"
+  end
+
+  def assert_evaluates_false(left, op, right)
+    assert !Condition.new(left, op, right).evaluate(@context),
+      "Evaluated true: #{left} #{op} #{right}"
+  end
+
+  def assert_evaluates_argument_error(left, op, right)
+    assert_raises(Liquid::ArgumentError) do
+      Condition.new(left, op, right).evaluate(@context)
+    end
+  end
+end # ConditionTest
diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/context_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/context_unit_test.rb
new file mode 100644
index 0000000..d9bfedb
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/context_unit_test.rb
@@ -0,0 +1,490 @@
+require 'test_helper'
+
+class HundredCentes
+  def to_liquid
+    100
+  end
+end
+
+class CentsDrop < Liquid::Drop
+  def amount
+    HundredCentes.new
+  end
+
+  def non_zero?
+    true
+  end
+end
+
+class ContextSensitiveDrop < Liquid::Drop
+  def test
+    @context['test']
+  end
+end
+
+class Category < Liquid::Drop
+  attr_accessor :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def to_liquid
+    CategoryDrop.new(self)
+  end
+end
+
+class CategoryDrop
+  attr_accessor :category, :context
+  def initialize(category)
+    @category = category
+  end
+end
+
+class CounterDrop < Liquid::Drop
+  def count
+    @count ||= 0
+    @count += 1
+  end
+end
+
+class ArrayLike
+  def fetch(index)
+  end
+
+  def [](index)
+    @counts ||= []
+    @counts[index] ||= 0
+    @counts[index] += 1
+  end
+
+  def to_liquid
+    self
+  end
+end
+
+class ContextUnitTest < Minitest::Test
+  include Liquid
+
+  def setup
+    @context = Liquid::Context.new
+  end
+
+  def test_variables
+    @context['string'] = 'string'
+    assert_equal 'string', @context['string']
+
+    @context['num'] = 5
+    assert_equal 5, @context['num']
+
+    @context['time'] = Time.parse('2006-06-06 12:00:00')
+    assert_equal Time.parse('2006-06-06 12:00:00'), @context['time']
+
+    @context['date'] = Date.today
+    assert_equal Date.today, @context['date']
+
+    now = DateTime.now
+    @context['datetime'] = now
+    assert_equal now, @context['datetime']
+
+    @context['bool'] = true
+    assert_equal true, @context['bool']
+
+    @context['bool'] = false
+    assert_equal false, @context['bool']
+
+    @context['nil'] = nil
+    assert_nil @context['nil']
+    assert_nil @context['nil']
+  end
+
+  def test_variables_not_existing
+    assert_nil @context['does_not_exist']
+  end
+
+  def test_scoping
+    @context.push
+    @context.pop
+
+    assert_raises(Liquid::ContextError) do
+      @context.pop
+    end
+
+    assert_raises(Liquid::ContextError) do
+      @context.push
+      @context.pop
+      @context.pop
+    end
+  end
+
+  def test_length_query
+    @context['numbers'] = [1, 2, 3, 4]
+
+    assert_equal 4, @context['numbers.size']
+
+    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4 }
+
+    assert_equal 4, @context['numbers.size']
+
+    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 'size' => 1000 }
+
+    assert_equal 1000, @context['numbers.size']
+  end
+
+  def test_hyphenated_variable
+    @context['oh-my'] = 'godz'
+    assert_equal 'godz', @context['oh-my']
+  end
+
+  def test_add_filter
+    filter = Module.new do
+      def hi(output)
+        output + ' hi!'
+      end
+    end
+
+    context = Context.new
+    context.add_filters(filter)
+    assert_equal 'hi? hi!', context.invoke(:hi, 'hi?')
+
+    context = Context.new
+    assert_equal 'hi?', context.invoke(:hi, 'hi?')
+
+    context.add_filters(filter)
+    assert_equal 'hi? hi!', context.invoke(:hi, 'hi?')
+  end
+
+  def test_only_intended_filters_make_it_there
+    filter = Module.new do
+      def hi(output)
+        output + ' hi!'
+      end
+    end
+
+    context = Context.new
+    assert_equal "Wookie", context.invoke("hi", "Wookie")
+
+    context.add_filters(filter)
+    assert_equal "Wookie hi!", context.invoke("hi", "Wookie")
+  end
+
+  def test_add_item_in_outer_scope
+    @context['test'] = 'test'
+    @context.push
+    assert_equal 'test', @context['test']
+    @context.pop
+    assert_equal 'test', @context['test']
+  end
+
+  def test_add_item_in_inner_scope
+    @context.push
+    @context['test'] = 'test'
+    assert_equal 'test', @context['test']
+    @context.pop
+    assert_nil @context['test']
+  end
+
+  def test_hierachical_data
+    @context['hash'] = { "name" => 'tobi' }
+    assert_equal 'tobi', @context['hash.name']
+    assert_equal 'tobi', @context['hash["name"]']
+  end
+
+  def test_keywords
+    assert_equal true, @context['true']
+    assert_equal false, @context['false']
+  end
+
+  def test_digits
+    assert_equal 100, @context['100']
+    assert_equal 100.00, @context['100.00']
+  end
+
+  def test_strings
+    assert_equal "hello!", @context['"hello!"']
+    assert_equal "hello!", @context["'hello!'"]
+  end
+
+  def test_merge
+    @context.merge({ "test" => "test" })
+    assert_equal 'test', @context['test']
+    @context.merge({ "test" => "newvalue", "foo" => "bar" })
+    assert_equal 'newvalue', @context['test']
+    assert_equal 'bar', @context['foo']
+  end
+
+  def test_array_notation
+    @context['test'] = [1, 2, 3, 4, 5]
+
+    assert_equal 1, @context['test[0]']
+    assert_equal 2, @context['test[1]']
+    assert_equal 3, @context['test[2]']
+    assert_equal 4, @context['test[3]']
+    assert_equal 5, @context['test[4]']
+  end
+
+  def test_recoursive_array_notation
+    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
+
+    assert_equal 1, @context['test.test[0]']
+
+    @context['test'] = [{ 'test' => 'worked' }]
+
+    assert_equal 'worked', @context['test[0].test']
+  end
+
+  def test_hash_to_array_transition
+    @context['colors'] = {
+      'Blue'    => ['003366', '336699', '6699CC', '99CCFF'],
+      'Green'   => ['003300', '336633', '669966', '99CC99'],
+      'Yellow'  => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'],
+      'Red'     => ['660000', '993333', 'CC6666', 'FF9999']
+    }
+
+    assert_equal '003366', @context['colors.Blue[0]']
+    assert_equal 'FF9999', @context['colors.Red[3]']
+  end
+
+  def test_try_first
+    @context['test'] = [1, 2, 3, 4, 5]
+
+    assert_equal 1, @context['test.first']
+    assert_equal 5, @context['test.last']
+
+    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
+
+    assert_equal 1, @context['test.test.first']
+    assert_equal 5, @context['test.test.last']
+
+    @context['test'] = [1]
+    assert_equal 1, @context['test.first']
+    assert_equal 1, @context['test.last']
+  end
+
+  def test_access_hashes_with_hash_notation
+    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
+    @context['product'] = { 'variants' => [ { 'title' => 'draft151cm' }, { 'title' => 'element151cm' } ] }
+
+    assert_equal 5, @context['products["count"]']
+    assert_equal 'deepsnow', @context['products["tags"][0]']
+    assert_equal 'deepsnow', @context['products["tags"].first']
+    assert_equal 'draft151cm', @context['product["variants"][0]["title"]']
+    assert_equal 'element151cm', @context['product["variants"][1]["title"]']
+    assert_equal 'draft151cm', @context['product["variants"][0]["title"]']
+    assert_equal 'element151cm', @context['product["variants"].last["title"]']
+  end
+
+  def test_access_variable_with_hash_notation
+    @context['foo'] = 'baz'
+    @context['bar'] = 'foo'
+
+    assert_equal 'baz', @context['["foo"]']
+    assert_equal 'baz', @context['[bar]']
+  end
+
+  def test_access_hashes_with_hash_access_variables
+    @context['var'] = 'tags'
+    @context['nested'] = { 'var' => 'tags' }
+    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
+
+    assert_equal 'deepsnow', @context['products[var].first']
+    assert_equal 'freestyle', @context['products[nested.var].last']
+  end
+
+  def test_hash_notation_only_for_hash_access
+    @context['array'] = [1, 2, 3, 4, 5]
+    @context['hash'] = { 'first' => 'Hello' }
+
+    assert_equal 1, @context['array.first']
+    assert_nil @context['array["first"]']
+    assert_equal 'Hello', @context['hash["first"]']
+  end
+
+  def test_first_can_appear_in_middle_of_callchain
+    @context['product'] = { 'variants' => [ { 'title' => 'draft151cm' }, { 'title' => 'element151cm' } ] }
+
+    assert_equal 'draft151cm', @context['product.variants[0].title']
+    assert_equal 'element151cm', @context['product.variants[1].title']
+    assert_equal 'draft151cm', @context['product.variants.first.title']
+    assert_equal 'element151cm', @context['product.variants.last.title']
+  end
+
+  def test_cents
+    @context.merge("cents" => HundredCentes.new)
+    assert_equal 100, @context['cents']
+  end
+
+  def test_nested_cents
+    @context.merge("cents" => { 'amount' => HundredCentes.new })
+    assert_equal 100, @context['cents.amount']
+
+    @context.merge("cents" => { 'cents' => { 'amount' => HundredCentes.new } })
+    assert_equal 100, @context['cents.cents.amount']
+  end
+
+  def test_cents_through_drop
+    @context.merge("cents" => CentsDrop.new)
+    assert_equal 100, @context['cents.amount']
+  end
+
+  def test_nested_cents_through_drop
+    @context.merge("vars" => { "cents" => CentsDrop.new })
+    assert_equal 100, @context['vars.cents.amount']
+  end
+
+  def test_drop_methods_with_question_marks
+    @context.merge("cents" => CentsDrop.new)
+    assert @context['cents.non_zero?']
+  end
+
+  def test_context_from_within_drop
+    @context.merge("test" => '123', "vars" => ContextSensitiveDrop.new)
+    assert_equal '123', @context['vars.test']
+  end
+
+  def test_nested_context_from_within_drop
+    @context.merge("test" => '123', "vars" => { "local" => ContextSensitiveDrop.new })
+    assert_equal '123', @context['vars.local.test']
+  end
+
+  def test_ranges
+    @context.merge("test" => '5')
+    assert_equal (1..5), @context['(1..5)']
+    assert_equal (1..5), @context['(1..test)']
+    assert_equal (5..5), @context['(test..test)']
+  end
+
+  def test_cents_through_drop_nestedly
+    @context.merge("cents" => { "cents" => CentsDrop.new })
+    assert_equal 100, @context['cents.cents.amount']
+
+    @context.merge("cents" => { "cents" => { "cents" => CentsDrop.new } })
+    assert_equal 100, @context['cents.cents.cents.amount']
+  end
+
+  def test_drop_with_variable_called_only_once
+    @context['counter'] = CounterDrop.new
+
+    assert_equal 1, @context['counter.count']
+    assert_equal 2, @context['counter.count']
+    assert_equal 3, @context['counter.count']
+  end
+
+  def test_drop_with_key_called_only_once
+    @context['counter'] = CounterDrop.new
+
+    assert_equal 1, @context['counter["count"]']
+    assert_equal 2, @context['counter["count"]']
+    assert_equal 3, @context['counter["count"]']
+  end
+
+  def test_proc_as_variable
+    @context['dynamic'] = proc { 'Hello' }
+
+    assert_equal 'Hello', @context['dynamic']
+  end
+
+  def test_lambda_as_variable
+    @context['dynamic'] = proc { 'Hello' }
+
+    assert_equal 'Hello', @context['dynamic']
+  end
+
+  def test_nested_lambda_as_variable
+    @context['dynamic'] = { "lambda" => proc { 'Hello' } }
+
+    assert_equal 'Hello', @context['dynamic.lambda']
+  end
+
+  def test_array_containing_lambda_as_variable
+    @context['dynamic'] = [1, 2, proc { 'Hello' }, 4, 5]
+
+    assert_equal 'Hello', @context['dynamic[2]']
+  end
+
+  def test_lambda_is_called_once
+    @context['callcount'] = proc { @global ||= 0; @global += 1; @global.to_s }
+
+    assert_equal '1', @context['callcount']
+    assert_equal '1', @context['callcount']
+    assert_equal '1', @context['callcount']
+
+    @global = nil
+  end
+
+  def test_nested_lambda_is_called_once
+    @context['callcount'] = { "lambda" => proc { @global ||= 0; @global += 1; @global.to_s } }
+
+    assert_equal '1', @context['callcount.lambda']
+    assert_equal '1', @context['callcount.lambda']
+    assert_equal '1', @context['callcount.lambda']
+
+    @global = nil
+  end
+
+  def test_lambda_in_array_is_called_once
+    @context['callcount'] = [1, 2, proc { @global ||= 0; @global += 1; @global.to_s }, 4, 5]
+
+    assert_equal '1', @context['callcount[2]']
+    assert_equal '1', @context['callcount[2]']
+    assert_equal '1', @context['callcount[2]']
+
+    @global = nil
+  end
+
+  def test_access_to_context_from_proc
+    @context.registers[:magic] = 345392
+
+    @context['magic'] = proc { @context.registers[:magic] }
+
+    assert_equal 345392, @context['magic']
+  end
+
+  def test_to_liquid_and_context_at_first_level
+    @context['category'] = Category.new("foobar")
+    assert_kind_of CategoryDrop, @context['category']
+    assert_equal @context, @context['category'].context
+  end
+
+  def test_interrupt_avoids_object_allocations
+    @context.interrupt? # ruby 3.0.0 allocates on the first call
+    assert_no_object_allocations do
+      @context.interrupt?
+    end
+  end
+
+  def test_context_initialization_with_a_proc_in_environment
+    contx = Context.new([test: ->(c) { c['poutine'] }], { test: :foo })
+
+    assert contx
+    assert_nil contx['poutine']
+  end
+
+  def test_apply_global_filter
+    global_filter_proc = ->(output) { "#{output} filtered" }
+
+    context = Context.new
+    context.global_filter = global_filter_proc
+
+    assert_equal 'hi filtered', context.apply_global_filter('hi')
+  end
+
+  def test_apply_global_filter_when_no_global_filter_exist
+    context = Context.new
+    assert_equal 'hi', context.apply_global_filter('hi')
+  end
+
+  private
+
+  def assert_no_object_allocations
+    unless RUBY_ENGINE == 'ruby'
+      skip "stackprof needed to count object allocations"
+    end
+    require 'stackprof'
+
+    profile = StackProf.run(mode: :object) do
+      yield
+    end
+    assert_equal 0, profile[:samples]
+  end
+end # ContextTest
diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/file_system_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/file_system_unit_test.rb
new file mode 100644
index 0000000..2c7250b
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/file_system_unit_test.rb
@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class FileSystemUnitTest < Minitest::Test
+  include Liquid
+
+  def test_default
+    assert_raises(FileSystemError) do
+      BlankFileSystem.new.read_template_file("dummy")
+    end
+  end
+
+  def test_local
+    file_system = Liquid::LocalFileSystem.new("/some/path")
+    assert_equal "/some/path/_mypartial.liquid", file_system.full_path("mypartial")
+    assert_equal "/some/path/dir/_mypartial.liquid", file_system.full_path("dir/mypartial")
+
+    assert_raises(FileSystemError) do
+      file_system.full_path("../dir/mypartial")
+    end
+
+    assert_raises(FileSystemError) do
+      file_system.full_path("/dir/../../dir/mypartial")
+    end
+
+    assert_raises(FileSystemError) do
+      file_system.full_path("/etc/passwd")
+    end
+  end
+
+  def test_custom_template_filename_patterns
+    file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
+    assert_equal "/some/path/mypartial.html", file_system.full_path("mypartial")
+    assert_equal "/some/path/dir/mypartial.html", file_system.full_path("dir/mypartial")
+  end
+end # FileSystemTest
diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/i18n_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/i18n_unit_test.rb
new file mode 100644
index 0000000..b57500e
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/i18n_unit_test.rb
@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class I18nUnitTest < Minitest::Test
+  include Liquid
+
+  def setup
+    @i18n = I18n.new(fixture("en_locale.yml"))
+  end
+
+  def test_simple_translate_string
+    assert_equal "less is more", @i18n.translate("simple")
+  end
+
+  def test_nested_translate_string
+    assert_equal "something wasn't right", @i18n.translate("errors.syntax.oops")
+  end
+
+  def test_single_string_interpolation
+    assert_equal "something different", @i18n.translate("whatever", something: "different")
+  end
+
+  # def test_raises_translation_error_on_undefined_interpolation_key
+  #   assert_raises I18n::TranslationError do
+  #     @i18n.translate("whatever", :oopstypos => "yes")
+  #   end
+  # end
+
+  def test_raises_unknown_translation
+    assert_raises I18n::TranslationError do
+      @i18n.translate("doesnt_exist")
+    end
+  end
+
+  def test_sets_default_path_to_en
+    assert_equal I18n::DEFAULT_LOCALE, I18n.new.path
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/lexer_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/lexer_unit_test.rb
new file mode 100644
index 0000000..5adcf2b
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/lexer_unit_test.rb
@@ -0,0 +1,51 @@
+require 'test_helper'
+
+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
+  end
+
+  def test_integer
+    tokens = Lexer.new('hi 50').tokenize
+    assert_equal [[:id, 'hi'], [:number, '50'], [:end_of_string]], tokens
+  end
+
+  def test_float
+    tokens = Lexer.new('hi 5.0').tokenize
+    assert_equal [[:id, 'hi'], [:number, '5.0'], [:end_of_string]], tokens
+  end
+
+  def test_comparison
+    tokens = Lexer.new('== <> contains ').tokenize
+    assert_equal [[:comparison, '=='], [:comparison, '<>'], [:comparison, 'contains'], [:end_of_string]], tokens
+  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
+  end
+
+  def test_fancy_identifiers
+    tokens = Lexer.new('hi five?').tokenize
+    assert_equal [[:id, 'hi'], [:id, 'five?'], [:end_of_string]], tokens
+
+    tokens = Lexer.new('2foo').tokenize
+    assert_equal [[:number, '2'], [:id, 'foo'], [:end_of_string]], tokens
+  end
+
+  def test_whitespace
+    tokens = Lexer.new("five|\n\t ==").tokenize
+    assert_equal [[:id, 'five'], [:pipe, '|'], [:comparison, '=='], [:end_of_string]], tokens
+  end
+
+  def test_unexpected_character
+    assert_raises(SyntaxError) do
+      Lexer.new("%").tokenize
+    end
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/parser_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/parser_unit_test.rb
new file mode 100644
index 0000000..9f23337
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/parser_unit_test.rb
@@ -0,0 +1,82 @@
+require 'test_helper'
+
+class ParserUnitTest < Minitest::Test
+  include Liquid
+
+  def test_consume
+    p = Parser.new("wat: 7")
+    assert_equal 'wat', p.consume(:id)
+    assert_equal ':', p.consume(:colon)
+    assert_equal '7', p.consume(:number)
+  end
+
+  def test_jump
+    p = Parser.new("wat: 7")
+    p.jump(2)
+    assert_equal '7', p.consume(:number)
+  end
+
+  def test_consume?
+    p = Parser.new("wat: 7")
+    assert_equal 'wat', p.consume?(:id)
+    assert_equal false, p.consume?(:dot)
+    assert_equal ':', p.consume(:colon)
+    assert_equal '7', p.consume?(:number)
+  end
+
+  def test_id?
+    p = Parser.new("wat 6 Peter Hegemon")
+    assert_equal 'wat', p.id?('wat')
+    assert_equal false, p.id?('endgame')
+    assert_equal '6', p.consume(:number)
+    assert_equal 'Peter', p.id?('Peter')
+    assert_equal false, p.id?('Achilles')
+  end
+
+  def test_look
+    p = Parser.new("wat 6 Peter Hegemon")
+    assert_equal true, p.look(:id)
+    assert_equal 'wat', p.consume(:id)
+    assert_equal false, p.look(:comparison)
+    assert_equal true, p.look(:number)
+    assert_equal true, p.look(:id, 1)
+    assert_equal false, p.look(:number, 1)
+  end
+
+  def test_expressions
+    p = Parser.new("hi.there hi?[5].there? hi.there.bob")
+    assert_equal 'hi.there', p.expression
+    assert_equal 'hi?[5].there?', p.expression
+    assert_equal 'hi.there.bob', p.expression
+
+    p = Parser.new("567 6.0 'lol' \"wut\"")
+    assert_equal '567', p.expression
+    assert_equal '6.0', p.expression
+    assert_equal "'lol'", p.expression
+    assert_equal '"wut"', p.expression
+  end
+
+  def test_ranges
+    p = Parser.new("(5..7) (1.5..9.6) (young..old) (hi[5].wat..old)")
+    assert_equal '(5..7)', p.expression
+    assert_equal '(1.5..9.6)', p.expression
+    assert_equal '(young..old)', p.expression
+    assert_equal '(hi[5].wat..old)', p.expression
+  end
+
+  def test_arguments
+    p = Parser.new("filter: hi.there[5], keyarg: 7")
+    assert_equal 'filter', p.consume(:id)
+    assert_equal ':', p.consume(:colon)
+    assert_equal 'hi.there[5]', p.argument
+    assert_equal ',', p.consume(:comma)
+    assert_equal 'keyarg: 7', p.argument
+  end
+
+  def test_invalid_expression
+    assert_raises(SyntaxError) do
+      p = Parser.new("==")
+      p.expression
+    end
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/regexp_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/regexp_unit_test.rb
new file mode 100644
index 0000000..0821229
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/regexp_unit_test.rb
@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class RegexpUnitTest < Minitest::Test
+  include Liquid
+
+  def test_empty
+    assert_equal [], ''.scan(QuotedFragment)
+  end
+
+  def test_quote
+    assert_equal ['"arg 1"'], '"arg 1"'.scan(QuotedFragment)
+  end
+
+  def test_words
+    assert_equal ['arg1', 'arg2'], 'arg1 arg2'.scan(QuotedFragment)
+  end
+
+  def test_tags
+    assert_equal ['<tr>', '</tr>'], '<tr> </tr>'.scan(QuotedFragment)
+    assert_equal ['<tr></tr>'], '<tr></tr>'.scan(QuotedFragment)
+    assert_equal ['<style', 'class="hello">', '</style>'], %(<style class="hello">' </style>).scan(QuotedFragment)
+  end
+
+  def test_double_quoted_words
+    assert_equal ['arg1', 'arg2', '"arg 3"'], 'arg1 arg2 "arg 3"'.scan(QuotedFragment)
+  end
+
+  def test_single_quoted_words
+    assert_equal ['arg1', 'arg2', "'arg 3'"], 'arg1 arg2 \'arg 3\''.scan(QuotedFragment)
+  end
+
+  def test_quoted_words_in_the_middle
+    assert_equal ['arg1', 'arg2', '"arg 3"', 'arg4'], 'arg1 arg2 "arg 3" arg4   '.scan(QuotedFragment)
+  end
+
+  def test_variable_parser
+    assert_equal ['var'],                               'var'.scan(VariableParser)
+    assert_equal ['var', 'method'],                     'var.method'.scan(VariableParser)
+    assert_equal ['var', '[method]'],                   'var[method]'.scan(VariableParser)
+    assert_equal ['var', '[method]', '[0]'],            'var[method][0]'.scan(VariableParser)
+    assert_equal ['var', '["method"]', '[0]'],          'var["method"][0]'.scan(VariableParser)
+    assert_equal ['var', '[method]', '[0]', 'method'],  'var[method][0].method'.scan(VariableParser)
+  end
+end # RegexpTest
diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/strainer_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/strainer_unit_test.rb
new file mode 100644
index 0000000..5ce2100
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/strainer_unit_test.rb
@@ -0,0 +1,164 @@
+require 'test_helper'
+
+class StrainerUnitTest < Minitest::Test
+  include Liquid
+
+  module AccessScopeFilters
+    def public_filter
+      "public"
+    end
+
+    def private_filter
+      "private"
+    end
+    private :private_filter
+  end
+
+  Strainer.global_filter(AccessScopeFilters)
+
+  def test_strainer
+    strainer = Strainer.create(nil)
+    assert_equal 5, strainer.invoke('size', 'input')
+    assert_equal "public", strainer.invoke("public_filter")
+  end
+
+  def test_stainer_raises_argument_error
+    strainer = Strainer.create(nil)
+    assert_raises(Liquid::ArgumentError) do
+      strainer.invoke("public_filter", 1)
+    end
+  end
+
+  def test_stainer_argument_error_contains_backtrace
+    strainer = Strainer.create(nil)
+    begin
+      strainer.invoke("public_filter", 1)
+    rescue Liquid::ArgumentError => e
+      assert_match(
+        /\ALiquid error: wrong number of arguments \((1 for 0|given 1, expected 0)\)\z/,
+        e.message)
+      assert_equal e.backtrace[0].split(':')[0], __FILE__
+    end
+  end
+
+  def test_strainer_only_invokes_public_filter_methods
+    strainer = Strainer.create(nil)
+    assert_equal false, strainer.class.invokable?('__test__')
+    assert_equal false, strainer.class.invokable?('test')
+    assert_equal false, strainer.class.invokable?('instance_eval')
+    assert_equal false, strainer.class.invokable?('__send__')
+    assert_equal true, strainer.class.invokable?('size') # from the standard lib
+  end
+
+  def test_strainer_returns_nil_if_no_filter_method_found
+    strainer = Strainer.create(nil)
+    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 = Strainer.create(nil)
+    assert_equal "password", strainer.invoke("undef_the_method", "password")
+  end
+
+  def test_strainer_only_allows_methods_defined_in_filters
+    strainer = Strainer.create(nil)
+    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")
+  end
+
+  def test_strainer_uses_a_class_cache_to_avoid_method_cache_invalidation
+    a = Module.new
+    b = Module.new
+    strainer = Strainer.create(nil, [a, b])
+    assert_kind_of Strainer, strainer
+    assert_kind_of a, strainer
+    assert_kind_of b, strainer
+    assert_kind_of Liquid::StandardFilters, strainer
+  end
+
+  def test_add_filter_when_wrong_filter_class
+    c = Context.new
+    s = c.strainer
+    wrong_filter = ->(v) { v.reverse }
+
+    assert_raises ArgumentError do
+      s.class.add_filter(wrong_filter)
+    end
+  end
+
+  module PrivateMethodOverrideFilter
+    private
+
+    def public_filter
+      "overriden as private"
+    end
+  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)
+    end
+    assert_equal 'Liquid error: Filter overrides registered public methods as non public: public_filter', error.message
+  end
+
+  module ProtectedMethodOverrideFilter
+    protected
+
+    def public_filter
+      "overriden as protected"
+    end
+  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)
+    end
+    assert_equal 'Liquid error: Filter overrides registered public methods as non public: public_filter', error.message
+  end
+
+  module PublicMethodOverrideFilter
+    def public_filter
+      "public"
+    end
+  end
+
+  def test_add_filter_does_not_raise_when_module_overrides_previously_registered_method
+    strainer = Context.new.strainer
+    strainer.class.add_filter(PublicMethodOverrideFilter)
+    assert strainer.class.filter_methods.include?('public_filter')
+  end
+
+  module LateAddedFilter
+    def late_added_filter(input)
+      "filtered"
+    end
+  end
+
+  def test_global_filter_clears_cache
+    assert_equal 'input', Strainer.create(nil).invoke('late_added_filter', 'input')
+    Strainer.global_filter(LateAddedFilter)
+    assert_equal 'filtered', Strainer.create(nil).invoke('late_added_filter', 'input')
+  end
+
+  def test_add_filter_does_not_include_already_included_module
+    mod = Module.new do
+      class << self
+        attr_accessor :include_count
+        def included(mod)
+          self.include_count += 1
+        end
+      end
+      self.include_count = 0
+    end
+    strainer = Context.new.strainer
+    strainer.class.add_filter(mod)
+    strainer.class.add_filter(mod)
+    assert_equal 1, mod.include_count
+  end
+end # StrainerTest
diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/tag_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/tag_unit_test.rb
new file mode 100644
index 0000000..c4b901b
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/tag_unit_test.rb
@@ -0,0 +1,21 @@
+require 'test_helper'
+
+class TagUnitTest < Minitest::Test
+  include Liquid
+
+  def test_tag
+    tag = Tag.parse('tag', "", Tokenizer.new(""), ParseContext.new)
+    assert_equal 'liquid::tag', tag.name
+    assert_equal '', tag.render(Context.new)
+  end
+
+  def test_return_raw_text_of_tag
+    tag = Tag.parse("long_tag", "param1, param2, param3", Tokenizer.new(""), ParseContext.new)
+    assert_equal("long_tag param1, param2, param3", tag.raw)
+  end
+
+  def test_tag_name_should_return_name_of_the_tag
+    tag = Tag.parse("some_tag", "", Tokenizer.new(""), ParseContext.new)
+    assert_equal 'some_tag', tag.tag_name
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/tags/case_tag_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/tags/case_tag_unit_test.rb
new file mode 100644
index 0000000..7110308
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/tags/case_tag_unit_test.rb
@@ -0,0 +1,10 @@
+require 'test_helper'
+
+class CaseTagUnitTest < Minitest::Test
+  include Liquid
+
+  def test_case_nodelist
+    template = Liquid::Template.parse('{% case var %}{% when true %}WHEN{% else %}ELSE{% endcase %}')
+    assert_equal ['WHEN', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/tags/for_tag_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/tags/for_tag_unit_test.rb
new file mode 100644
index 0000000..b8fc520
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/tags/for_tag_unit_test.rb
@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class ForTagUnitTest < Minitest::Test
+  def test_for_nodelist
+    template = Liquid::Template.parse('{% for item in items %}FOR{% endfor %}')
+    assert_equal ['FOR'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten
+  end
+
+  def test_for_else_nodelist
+    template = Liquid::Template.parse('{% for item in items %}FOR{% else %}ELSE{% endfor %}')
+    assert_equal ['FOR', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/tags/if_tag_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/tags/if_tag_unit_test.rb
new file mode 100644
index 0000000..7ecfc40
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/tags/if_tag_unit_test.rb
@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class IfTagUnitTest < Minitest::Test
+  def test_if_nodelist
+    template = Liquid::Template.parse('{% if true %}IF{% else %}ELSE{% endif %}')
+    assert_equal ['IF', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/template_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/template_unit_test.rb
new file mode 100644
index 0000000..6328be5
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/template_unit_test.rb
@@ -0,0 +1,78 @@
+require 'test_helper'
+
+class TemplateUnitTest < Minitest::Test
+  include Liquid
+
+  def test_sets_default_localization_in_document
+    t = Template.new
+    t.parse('{%comment%}{%endcomment%}')
+    assert_instance_of I18n, t.root.nodelist[0].options[:locale]
+  end
+
+  def test_sets_default_localization_in_context_with_quick_initialization
+    t = Template.new
+    t.parse('{%comment%}{%endcomment%}', locale: I18n.new(fixture("en_locale.yml")))
+
+    locale = t.root.nodelist[0].options[:locale]
+    assert_instance_of I18n, locale
+    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)
+    Template.tags.delete('custom')
+    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)
+    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?(new_klass)
+  ensure
+    Object.send(:remove_const, :CustomTag)
+    Template.tags.delete('custom')
+    Liquid.cache_classes = original_cache_setting
+  end
+
+  class FakeTag; end
+
+  def test_tags_delete
+    Template.register_tag('fake', FakeTag)
+    assert_equal FakeTag, Template.tags['fake']
+
+    Template.tags.delete('fake')
+    assert_nil Template.tags['fake']
+  end
+
+  def test_tags_can_be_looped_over
+    Template.register_tag('fake', FakeTag)
+    result = Template.tags.map { |name, klass| [name, klass] }
+    assert result.include?(["fake", "TemplateUnitTest::FakeTag"])
+  ensure
+    Template.tags.delete('fake')
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/tokenizer_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/tokenizer_unit_test.rb
new file mode 100644
index 0000000..de84c1f
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/tokenizer_unit_test.rb
@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class TokenizerTest < Minitest::Test
+  def test_tokenize_strings
+    assert_equal [' '], tokenize(' ')
+    assert_equal ['hello world'], tokenize('hello world')
+  end
+
+  def test_tokenize_variables
+    assert_equal ['{{funk}}'], tokenize('{{funk}}')
+    assert_equal [' ', '{{funk}}', ' '], tokenize(' {{funk}} ')
+    assert_equal [' ', '{{funk}}', ' ', '{{so}}', ' ', '{{brother}}', ' '], tokenize(' {{funk}} {{so}} {{brother}} ')
+    assert_equal [' ', '{{  funk  }}', ' '], tokenize(' {{  funk  }} ')
+  end
+
+  def test_tokenize_blocks
+    assert_equal ['{%comment%}'], tokenize('{%comment%}')
+    assert_equal [' ', '{%comment%}', ' '], tokenize(' {%comment%} ')
+
+    assert_equal [' ', '{%comment%}', ' ', '{%endcomment%}', ' '], tokenize(' {%comment%} {%endcomment%} ')
+    assert_equal ['  ', '{% comment %}', ' ', '{% endcomment %}', ' '], tokenize("  {% comment %} {% endcomment %} ")
+  end
+
+  def test_calculate_line_numbers_per_token_with_profiling
+    assert_equal [1],       tokenize_line_numbers("{{funk}}")
+    assert_equal [1, 1, 1], tokenize_line_numbers(" {{funk}} ")
+    assert_equal [1, 2, 2], tokenize_line_numbers("\n{{funk}}\n")
+    assert_equal [1, 1, 3], tokenize_line_numbers(" {{\n funk \n}} ")
+  end
+
+  private
+
+  def tokenize(source)
+    tokenizer = Liquid::Tokenizer.new(source)
+    tokens = []
+    while t = tokenizer.shift
+      tokens << t
+    end
+    tokens
+  end
+
+  def tokenize_line_numbers(source)
+    tokenizer = Liquid::Tokenizer.new(source, true)
+    line_numbers = []
+    loop do
+      line_number = tokenizer.line_number
+      if tokenizer.shift
+        line_numbers << line_number
+      else
+        break
+      end
+    end
+    line_numbers
+  end
+end
diff --git a/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/variable_unit_test.rb b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/variable_unit_test.rb
new file mode 100644
index 0000000..5a21ace
--- /dev/null
+++ b/vendor/bundle/ruby/3.4.0/gems/liquid-4.0.4/test/unit/variable_unit_test.rb
@@ -0,0 +1,162 @@
+require 'test_helper'
+
+class VariableUnitTest < Minitest::Test
+  include Liquid
+
+  def test_variable
+    var = create_variable('hello')
+    assert_equal VariableLookup.new('hello'), var.name
+  end
+
+  def test_filters
+    var = create_variable('hello | textileze')
+    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal [['textileze', []]], var.filters
+
+    var = create_variable('hello | textileze | paragraph')
+    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal [['textileze', []], ['paragraph', []]], var.filters
+
+    var = create_variable(%( hello | strftime: '%Y'))
+    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal [['strftime', ['%Y']]], var.filters
+
+    var = create_variable(%( 'typo' | link_to: 'Typo', true ))
+    assert_equal 'typo', var.name
+    assert_equal [['link_to', ['Typo', true]]], var.filters
+
+    var = create_variable(%( 'typo' | link_to: 'Typo', false ))
+    assert_equal 'typo', var.name
+    assert_equal [['link_to', ['Typo', false]]], var.filters
+
+    var = create_variable(%( 'foo' | repeat: 3 ))
+    assert_equal 'foo', var.name
+    assert_equal [['repeat', [3]]], var.filters
+
+    var = create_variable(%( 'foo' | repeat: 3, 3 ))
+    assert_equal 'foo', var.name
+    assert_equal [['repeat', [3, 3]]], var.filters
+
+    var = create_variable(%( 'foo' | repeat: 3, 3, 3 ))
+    assert_equal 'foo', var.name
+    assert_equal [['repeat', [3, 3, 3]]], var.filters
+
+    var = create_variable(%( hello | strftime: '%Y, okay?'))
+    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal [['strftime', ['%Y, okay?']]], var.filters
+
+    var = create_variable(%( hello | things: "%Y, okay?", 'the other one'))
+    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal [['things', ['%Y, okay?', 'the other one']]], var.filters
+  end
+
+  def test_filter_with_date_parameter
+    var = create_variable(%( '2006-06-06' | date: "%m/%d/%Y"))
+    assert_equal '2006-06-06', var.name
+    assert_equal [['date', ['%m/%d/%Y']]], var.filters
+  end
+
+  def test_filters_without_whitespace
+    var = create_variable('hello | textileze | paragraph')
+    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal [['textileze', []], ['paragraph', []]], var.filters
+
+    var = create_variable('hello|textileze|paragraph')
+    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal [['textileze', []], ['paragraph', []]], var.filters
+
+    var = create_variable("hello|replace:'foo','bar'|textileze")
+    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal [['replace', ['foo', 'bar']], ['textileze', []]], var.filters
+  end
+
+  def test_symbol
+    var = create_variable("http://disney.com/logo.gif | image: 'med' ", error_mode: :lax)
+    assert_equal VariableLookup.new('http://disney.com/logo.gif'), var.name
+    assert_equal [['image', ['med']]], var.filters
+  end
+
+  def test_string_to_filter
+    var = create_variable("'http://disney.com/logo.gif' | image: 'med' ")
+    assert_equal 'http://disney.com/logo.gif', var.name
+    assert_equal [['image', ['med']]], var.filters
+  end
+
+  def test_string_single_quoted
+    var = create_variable(%( "hello" ))
+    assert_equal 'hello', var.name
+  end
+
+  def test_string_double_quoted
+    var = create_variable(%( 'hello' ))
+    assert_equal 'hello', var.name
+  end
+
+  def test_integer
+    var = create_variable(%( 1000 ))
+    assert_equal 1000, var.name
+  end
+
+  def test_float
+    var = create_variable(%( 1000.01 ))
+    assert_equal 1000.01, var.name
+  end
+
+  def test_dashes
+    assert_equal VariableLookup.new('foo-bar'), create_variable('foo-bar').name
+    assert_equal VariableLookup.new('foo-bar-2'), create_variable('foo-bar-2').name
+
+    with_error_mode :strict do
+      assert_raises(Liquid::SyntaxError) { create_variable('foo - bar') }
+      assert_raises(Liquid::SyntaxError) { create_variable('-foo') }
+      assert_raises(Liquid::SyntaxError) { create_variable('2foo') }
+    end
+  end
+
+  def test_string_with_special_chars
+    var = create_variable(%( 'hello! $!@.;"ddasd" ' ))
+    assert_equal 'hello! $!@.;"ddasd" ', var.name
+  end
+
+  def test_string_dot
+    var = create_variable(%( test.test ))
+    assert_equal VariableLookup.new('test.test'), var.name
+  end
+
+  def test_filter_with_keyword_arguments
+    var = create_variable(%( hello | things: greeting: "world", farewell: 'goodbye'))
+    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal [['things', [], { 'greeting' => 'world', 'farewell' => 'goodbye' }]], var.filters
+  end
+
+  def test_lax_filter_argument_parsing
+    var = create_variable(%( number_of_comments | pluralize: 'comment': 'comments' ), error_mode: :lax)
+    assert_equal VariableLookup.new('number_of_comments'), var.name
+    assert_equal [['pluralize', ['comment', 'comments']]], var.filters
+  end
+
+  def test_strict_filter_argument_parsing
+    with_error_mode(:strict) do
+      assert_raises(SyntaxError) do
+        create_variable(%( number_of_comments | pluralize: 'comment': 'comments' ))
+      end
+    end
+  end
+
+  def test_output_raw_source_of_variable
+    var = create_variable(%( name_of_variable | upcase ))
+    assert_equal " name_of_variable | upcase ", var.raw
+  end
+
+  def test_variable_lookup_interface
+    lookup = VariableLookup.new('a.b.c')
+    assert_equal 'a', lookup.name
+    assert_equal ['b', 'c'], lookup.lookups
+  end
+
+  private
+
+  def create_variable(markup, options = {})
+    Variable.new(markup, ParseContext.new(options))
+  end
+end