Add bin and edit workflow

bin/gems/liquid-4.0.4/test/fixtures/en_locale.yml

@@ -0,0 +1,9 @@
+---
+  simple: "less is more"
+  whatever: "something %{something}"
+  errors:
+    i18n:
+      undefined_interpolation: "undefined key %{key}"
+      unknown_translation: "translation '%{name}' wasn't found"
+    syntax:
+      oops: "something wasn't right"

bin/gems/liquid-4.0.4/test/integration/assign_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+class AssignTest < Minitest::Test
+  include Liquid
+
+  def test_assign_with_hyphen_in_variable_name
+    template_source = <<-END_TEMPLATE
+    {% assign this-thing = 'Print this-thing' %}
+    {{ this-thing }}
+    END_TEMPLATE
+    template = Template.parse(template_source)
+    rendered = template.render!
+    assert_equal "Print this-thing", rendered.strip
+  end
+
+  def test_assigned_variable
+    assert_template_result('.foo.',
+      '{% assign foo = values %}.{{ foo[0] }}.',
+      'values' => %w(foo bar baz))
+
+    assert_template_result('.bar.',
+      '{% assign foo = values %}.{{ foo[1] }}.',
+      'values' => %w(foo bar baz))
+  end
+
+  def test_assign_with_filter
+    assert_template_result('.bar.',
+      '{% assign foo = values | split: "," %}.{{ foo[1] }}.',
+      'values' => "foo,bar,baz")
+  end
+
+  def test_assign_syntax_error
+    assert_match_syntax_error(/assign/,
+      '{% assign foo not values %}.',
+      'values' => "foo,bar,baz")
+  end
+
+  def test_assign_uses_error_mode
+    with_error_mode(:strict) do
+      assert_raises(SyntaxError) do
+        Template.parse("{% assign foo = ('X' | downcase) %}")
+      end
+    end
+    with_error_mode(:lax) do
+      assert Template.parse("{% assign foo = ('X' | downcase) %}")
+    end
+  end
+end # AssignTest

bin/gems/liquid-4.0.4/test/integration/blank_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+
+class FoobarTag < Liquid::Tag
+  def render(*args)
+    " "
+  end
+
+  Liquid::Template.register_tag('foobar', FoobarTag)
+end
+
+class BlankTestFileSystem
+  def read_template_file(template_path)
+    template_path
+  end
+end
+
+class BlankTest < Minitest::Test
+  include Liquid
+  N = 10
+
+  def wrap_in_for(body)
+    "{% for i in (1..#{N}) %}#{body}{% endfor %}"
+  end
+
+  def wrap_in_if(body)
+    "{% if true %}#{body}{% endif %}"
+  end
+
+  def wrap(body)
+    wrap_in_for(body) + wrap_in_if(body)
+  end
+
+  def test_new_tags_are_not_blank_by_default
+    assert_template_result(" " * N, wrap_in_for("{% foobar %}"))
+  end
+
+  def test_loops_are_blank
+    assert_template_result("", wrap_in_for(" "))
+  end
+
+  def test_if_else_are_blank
+    assert_template_result("", "{% if true %} {% elsif false %} {% else %} {% endif %}")
+  end
+
+  def test_unless_is_blank
+    assert_template_result("", wrap("{% unless true %} {% endunless %}"))
+  end
+
+  def test_mark_as_blank_only_during_parsing
+    assert_template_result(" " * (N + 1), wrap(" {% if false %} this never happens, but still, this block is not blank {% endif %}"))
+  end
+
+  def test_comments_are_blank
+    assert_template_result("", wrap(" {% comment %} whatever {% endcomment %} "))
+  end
+
+  def test_captures_are_blank
+    assert_template_result("", wrap(" {% capture foo %} whatever {% endcapture %} "))
+  end
+
+  def test_nested_blocks_are_blank_but_only_if_all_children_are
+    assert_template_result("", wrap(wrap(" ")))
+    assert_template_result("\n       but this is not " * (N + 1),
+      wrap('{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
+      {% if true %} but this is not {% endif %}'))
+  end
+
+  def test_assigns_are_blank
+    assert_template_result("", wrap(' {% assign foo = "bar" %} '))
+  end
+
+  def test_whitespace_is_blank
+    assert_template_result("", wrap(" "))
+    assert_template_result("", wrap("\t"))
+  end
+
+  def test_whitespace_is_not_blank_if_other_stuff_is_present
+    body = "     x "
+    assert_template_result(body * (N + 1), wrap(body))
+  end
+
+  def test_increment_is_not_blank
+    assert_template_result(" 0" * 2 * (N + 1), wrap("{% assign foo = 0 %} {% increment foo %} {% decrement foo %}"))
+  end
+
+  def test_cycle_is_not_blank
+    assert_template_result("  " * ((N + 1) / 2) + " ", wrap("{% cycle ' ', ' ' %}"))
+  end
+
+  def test_raw_is_not_blank
+    assert_template_result("  " * (N + 1), wrap(" {% raw %} {% endraw %}"))
+  end
+
+  def test_include_is_blank
+    Liquid::Template.file_system = BlankTestFileSystem.new
+    assert_template_result "foobar" * (N + 1), wrap("{% include 'foobar' %}")
+    assert_template_result " foobar " * (N + 1), wrap("{% include ' foobar ' %}")
+    assert_template_result "   " * (N + 1), wrap(" {% include ' ' %} ")
+  end
+
+  def test_case_is_blank
+    assert_template_result("", wrap(" {% assign foo = 'bar' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
+    assert_template_result("", wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
+    assert_template_result("   x  " * (N + 1), wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} x {% endcase %} "))
+  end
+end

bin/gems/liquid-4.0.4/test/integration/block_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+
+class BlockTest < Minitest::Test
+  include Liquid
+
+  def test_unexpected_end_tag
+    exc = assert_raises(SyntaxError) do
+      Template.parse("{% if true %}{% endunless %}")
+    end
+    assert_equal exc.message, "Liquid syntax error: 'endunless' is not a valid delimiter for if tags. use endif"
+  end
+end

bin/gems/liquid-4.0.4/test/integration/capture_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+class CaptureTest < Minitest::Test
+  include Liquid
+
+  def test_captures_block_content_in_variable
+    assert_template_result("test string", "{% capture 'var' %}test string{% endcapture %}{{var}}", {})
+  end
+
+  def test_capture_with_hyphen_in_variable_name
+    template_source = <<-END_TEMPLATE
+    {% capture this-thing %}Print this-thing{% endcapture %}
+    {{ this-thing }}
+    END_TEMPLATE
+    template = Template.parse(template_source)
+    rendered = template.render!
+    assert_equal "Print this-thing", rendered.strip
+  end
+
+  def test_capture_to_variable_from_outer_scope_if_existing
+    template_source = <<-END_TEMPLATE
+    {% assign var = '' %}
+    {% if true %}
+    {% capture var %}first-block-string{% endcapture %}
+    {% endif %}
+    {% if true %}
+    {% capture var %}test-string{% endcapture %}
+    {% endif %}
+    {{var}}
+    END_TEMPLATE
+    template = Template.parse(template_source)
+    rendered = template.render!
+    assert_equal "test-string", rendered.gsub(/\s/, '')
+  end
+
+  def test_assigning_from_capture
+    template_source = <<-END_TEMPLATE
+    {% assign first = '' %}
+    {% assign second = '' %}
+    {% for number in (1..3) %}
+    {% capture first %}{{number}}{% endcapture %}
+    {% assign second = first %}
+    {% endfor %}
+    {{ first }}-{{ second }}
+    END_TEMPLATE
+    template = Template.parse(template_source)
+    rendered = template.render!
+    assert_equal "3-3", rendered.gsub(/\s/, '')
+  end
+end # CaptureTest

bin/gems/liquid-4.0.4/test/integration/context_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class ContextTest < Minitest::Test
+  include Liquid
+
+  def test_override_global_filter
+    global = Module.new do
+      def notice(output)
+        "Global #{output}"
+      end
+    end
+
+    local = Module.new do
+      def notice(output)
+        "Local #{output}"
+      end
+    end
+
+    with_global_filter(global) do
+      assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
+      assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, filters: [local])
+    end
+  end
+
+  def test_has_key_will_not_add_an_error_for_missing_keys
+    with_error_mode :strict do
+      context = Context.new
+      context.key?('unknown')
+      assert_empty context.errors
+    end
+  end
+end

bin/gems/liquid-4.0.4/test/integration/document_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class DocumentTest < Minitest::Test
+  include Liquid
+
+  def test_unexpected_outer_tag
+    exc = assert_raises(SyntaxError) do
+      Template.parse("{% else %}")
+    end
+    assert_equal exc.message, "Liquid syntax error: Unexpected outer 'else' tag"
+  end
+
+  def test_unknown_tag
+    exc = assert_raises(SyntaxError) do
+      Template.parse("{% foo %}")
+    end
+    assert_equal exc.message, "Liquid syntax error: Unknown tag 'foo'"
+  end
+end

bin/gems/liquid-4.0.4/test/integration/drop_test.rb

@@ -0,0 +1,247 @@
+require 'test_helper'
+
+class ContextDrop < Liquid::Drop
+  def scopes
+    @context.scopes.size
+  end
+
+  def scopes_as_array
+    (1..@context.scopes.size).to_a
+  end
+
+  def loop_pos
+    @context['forloop.index']
+  end
+
+  def liquid_method_missing(method)
+    @context[method]
+  end
+end
+
+class ProductDrop < Liquid::Drop
+  class TextDrop < Liquid::Drop
+    def array
+      ['text1', 'text2']
+    end
+
+    def text
+      'text1'
+    end
+  end
+
+  class CatchallDrop < Liquid::Drop
+    def liquid_method_missing(method)
+      'catchall_method: ' << method.to_s
+    end
+  end
+
+  def texts
+    TextDrop.new
+  end
+
+  def catchall
+    CatchallDrop.new
+  end
+
+  def context
+    ContextDrop.new
+  end
+
+  def user_input
+    "foo"
+  end
+
+  protected
+
+  def callmenot
+    "protected"
+  end
+end
+
+class EnumerableDrop < Liquid::Drop
+  def liquid_method_missing(method)
+    method
+  end
+
+  def size
+    3
+  end
+
+  def first
+    1
+  end
+
+  def count
+    3
+  end
+
+  def min
+    1
+  end
+
+  def max
+    3
+  end
+
+  def each
+    yield 1
+    yield 2
+    yield 3
+  end
+end
+
+class RealEnumerableDrop < Liquid::Drop
+  include Enumerable
+
+  def liquid_method_missing(method)
+    method
+  end
+
+  def each
+    yield 1
+    yield 2
+    yield 3
+  end
+end
+
+class DropsTest < Minitest::Test
+  include Liquid
+
+  def test_product_drop
+    tpl = Liquid::Template.parse('  ')
+    assert_equal '  ', tpl.render!('product' => ProductDrop.new)
+  end
+
+  def test_drop_does_only_respond_to_whitelisted_methods
+    assert_equal "", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse("{{ product.whatever }}").render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new)
+  end
+
+  def test_drops_respond_to_to_liquid
+    assert_equal "text1", Liquid::Template.parse("{{ product.to_liquid.texts.text }}").render!('product' => ProductDrop.new)
+    assert_equal "text1", Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new)
+  end
+
+  def test_text_drop
+    output = Liquid::Template.parse(' {{ product.texts.text }} ').render!('product' => ProductDrop.new)
+    assert_equal ' text1 ', output
+  end
+
+  def test_catchall_unknown_method
+    output = Liquid::Template.parse(' {{ product.catchall.unknown }} ').render!('product' => ProductDrop.new)
+    assert_equal ' catchall_method: unknown ', output
+  end
+
+  def test_catchall_integer_argument_drop
+    output = Liquid::Template.parse(' {{ product.catchall[8] }} ').render!('product' => ProductDrop.new)
+    assert_equal ' catchall_method: 8 ', output
+  end
+
+  def test_text_array_drop
+    output = Liquid::Template.parse('{% for text in product.texts.array %} {{text}} {% endfor %}').render!('product' => ProductDrop.new)
+    assert_equal ' text1  text2 ', output
+  end
+
+  def test_context_drop
+    output = Liquid::Template.parse(' {{ context.bar }} ').render!('context' => ContextDrop.new, 'bar' => "carrot")
+    assert_equal ' carrot ', output
+  end
+
+  def test_nested_context_drop
+    output = Liquid::Template.parse(' {{ product.context.foo }} ').render!('product' => ProductDrop.new, 'foo' => "monkey")
+    assert_equal ' monkey ', output
+  end
+
+  def test_protected
+    output = Liquid::Template.parse(' {{ product.callmenot }} ').render!('product' => ProductDrop.new)
+    assert_equal '  ', output
+  end
+
+  def test_object_methods_not_allowed
+    [:dup, :clone, :singleton_class, :eval, :class_eval, :inspect].each do |method|
+      output = Liquid::Template.parse(" {{ product.#{method} }} ").render!('product' => ProductDrop.new)
+      assert_equal '  ', output
+    end
+  end
+
+  def test_scope
+    assert_equal '1', Liquid::Template.parse('{{ context.scopes }}').render!('context' => ContextDrop.new)
+    assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ context.scopes }}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
+  end
+
+  def test_scope_though_proc
+    assert_equal '1', Liquid::Template.parse('{{ s }}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] })
+    assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ s }}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] }, 'dummy' => [1])
+    assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] }, 'dummy' => [1])
+  end
+
+  def test_scope_with_assigns
+    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{{a}}').render!('context' => ContextDrop.new)
+    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal 'test', Liquid::Template.parse('{% assign header_gif = "test"%}{{header_gif}}').render!('context' => ContextDrop.new)
+    assert_equal 'test', Liquid::Template.parse("{% assign header_gif = 'test'%}{{header_gif}}").render!('context' => ContextDrop.new)
+  end
+
+  def test_scope_from_tags
+    assert_equal '1', Liquid::Template.parse('{% for i in context.scopes_as_array %}{{i}}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '12', Liquid::Template.parse('{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
+  end
+
+  def test_access_context_from_drop
+    assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{{ context.loop_pos }}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1, 2, 3])
+  end
+
+  def test_enumerable_drop
+    assert_equal '123', Liquid::Template.parse('{% for c in collection %}{{c}}{% endfor %}').render!('collection' => EnumerableDrop.new)
+  end
+
+  def test_enumerable_drop_size
+    assert_equal '3', Liquid::Template.parse('{{collection.size}}').render!('collection' => EnumerableDrop.new)
+  end
+
+  def test_enumerable_drop_will_invoke_liquid_method_missing_for_clashing_method_names
+    ["select", "each", "map", "cycle"].each do |method|
+      assert_equal method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
+      assert_equal method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
+      assert_equal method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
+      assert_equal method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
+    end
+  end
+
+  def test_some_enumerable_methods_still_get_invoked
+    [ :count, :max ].each do |method|
+      assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
+      assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
+      assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
+      assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
+    end
+
+    assert_equal "yes", Liquid::Template.parse("{% if collection contains 3 %}yes{% endif %}").render!('collection' => RealEnumerableDrop.new)
+
+    [ :min, :first ].each do |method|
+      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
+      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
+      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
+      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
+    end
+  end
+
+  def test_empty_string_value_access
+    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => '')
+  end
+
+  def test_nil_value_access
+    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => nil)
+  end
+
+  def test_default_to_s_on_drops
+    assert_equal 'ProductDrop', Liquid::Template.parse("{{ product }}").render!('product' => ProductDrop.new)
+    assert_equal 'EnumerableDrop', Liquid::Template.parse('{{ collection }}').render!('collection' => EnumerableDrop.new)
+  end
+end # DropsTest

bin/gems/liquid-4.0.4/test/integration/error_handling_test.rb

@@ -0,0 +1,260 @@
+require 'test_helper'
+
+class ErrorHandlingTest < Minitest::Test
+  include Liquid
+
+  def test_templates_parsed_with_line_numbers_renders_them_in_errors
+    template = <<-LIQUID
+      Hello,
+
+      {{ errors.standard_error }} will raise a standard error.
+
+      Bla bla test.
+
+      {{ errors.syntax_error }} will raise a syntax error.
+
+      This is an argument error: {{ errors.argument_error }}
+
+      Bla.
+    LIQUID
+
+    expected = <<-TEXT
+      Hello,
+
+      Liquid error (line 3): standard error will raise a standard error.
+
+      Bla bla test.
+
+      Liquid syntax error (line 7): syntax error will raise a syntax error.
+
+      This is an argument error: Liquid error (line 9): argument error
+
+      Bla.
+    TEXT
+
+    output = Liquid::Template.parse(template, line_numbers: true).render('errors' => ErrorDrop.new)
+    assert_equal expected, output
+  end
+
+  def test_standard_error
+    template = Liquid::Template.parse(' {{ errors.standard_error }} ')
+    assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
+
+    assert_equal 1, template.errors.size
+    assert_equal StandardError, template.errors.first.class
+  end
+
+  def test_syntax
+    template = Liquid::Template.parse(' {{ errors.syntax_error }} ')
+    assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
+
+    assert_equal 1, template.errors.size
+    assert_equal SyntaxError, template.errors.first.class
+  end
+
+  def test_argument
+    template = Liquid::Template.parse(' {{ errors.argument_error }} ')
+    assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
+
+    assert_equal 1, template.errors.size
+    assert_equal ArgumentError, template.errors.first.class
+  end
+
+  def test_missing_endtag_parse_time_error
+    assert_raises(Liquid::SyntaxError) do
+      Liquid::Template.parse(' {% for a in b %} ... ')
+    end
+  end
+
+  def test_unrecognized_operator
+    with_error_mode(:strict) do
+      assert_raises(SyntaxError) do
+        Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
+      end
+    end
+  end
+
+  def test_lax_unrecognized_operator
+    template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :lax)
+    assert_equal ' Liquid error: Unknown operator =! ', template.render
+    assert_equal 1, template.errors.size
+    assert_equal Liquid::ArgumentError, template.errors.first.class
+  end
+
+  def test_with_line_numbers_adds_numbers_to_parser_errors
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse(%q(
+          foobar
+
+          {% "cat" | foobar %}
+
+          bla
+        ),
+        line_numbers: true
+      )
+    end
+
+    assert_match(/Liquid syntax error \(line 4\)/, err.message)
+  end
+
+  def test_with_line_numbers_adds_numbers_to_parser_errors_with_whitespace_trim
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse(%q(
+          foobar
+
+          {%- "cat" | foobar -%}
+
+          bla
+        ),
+        line_numbers: true
+      )
+    end
+
+    assert_match(/Liquid syntax error \(line 4\)/, err.message)
+  end
+
+  def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors
+    template = Liquid::Template.parse('
+        foobar
+
+        {% if 1 =! 2 %}ok{% endif %}
+
+        bla
+            ',
+      error_mode: :warn,
+      line_numbers: true
+    )
+
+    assert_equal ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
+      template.warnings.map(&:message)
+  end
+
+  def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse('
+          foobar
+
+          {% if 1 =! 2 %}ok{% endif %}
+
+          bla
+                ',
+        error_mode: :strict,
+        line_numbers: true
+      )
+    end
+
+    assert_equal 'Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message
+  end
+
+  def test_syntax_errors_in_nested_blocks_have_correct_line_number
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse('
+          foobar
+
+          {% if 1 != 2 %}
+            {% foo %}
+          {% endif %}
+
+          bla
+                ',
+        line_numbers: true
+      )
+    end
+
+    assert_equal "Liquid syntax error (line 5): Unknown tag 'foo'", err.message
+  end
+
+  def test_strict_error_messages
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :strict)
+    end
+    assert_equal 'Liquid syntax error: Unexpected character = in "1 =! 2"', err.message
+
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse('{{%%%}}', error_mode: :strict)
+    end
+    assert_equal 'Liquid syntax error: Unexpected character % in "{{%%%}}"', err.message
+  end
+
+  def test_warnings
+    template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', error_mode: :warn)
+    assert_equal 3, template.warnings.size
+    assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].to_s(false)
+    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false)
+    assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false)
+    assert_equal '', template.render
+  end
+
+  def test_warning_line_numbers
+    template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", error_mode: :warn, line_numbers: true)
+    assert_equal 'Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message
+    assert_equal 'Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message
+    assert_equal 'Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
+    assert_equal 3, template.warnings.size
+    assert_equal [1, 2, 3], template.warnings.map(&:line_number)
+  end
+
+  # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
+  def test_exceptions_propagate
+    assert_raises Exception do
+      template = Liquid::Template.parse('{{ errors.exception }}')
+      template.render('errors' => ErrorDrop.new)
+    end
+  end
+
+  def test_default_exception_renderer_with_internal_error
+    template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
+
+    output = template.render({ 'errors' => ErrorDrop.new })
+
+    assert_equal 'This is a runtime error: Liquid error (line 1): internal', output
+    assert_equal [Liquid::InternalError], template.errors.map(&:class)
+  end
+
+  def test_setting_default_exception_renderer
+    old_exception_renderer = Liquid::Template.default_exception_renderer
+    exceptions = []
+    Liquid::Template.default_exception_renderer = ->(e) { exceptions << e; '' }
+    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_exception_renderer_exposing_non_liquid_error
+    template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
+    exceptions = []
+    handler = ->(e) { exceptions << e; e.cause }
+
+    output = template.render({ 'errors' => ErrorDrop.new }, exception_renderer: handler)
+
+    assert_equal 'This is a runtime error: runtime error', output
+    assert_equal [Liquid::InternalError], exceptions.map(&:class)
+    assert_equal exceptions, template.errors
+    assert_equal '#<RuntimeError: runtime error>', exceptions.first.cause.inspect
+  end
+
+  class TestFileSystem
+    def read_template_file(template_path)
+      "{{ errors.argument_error }}"
+    end
+  end
+
+  def test_included_template_name_with_line_numbers
+    old_file_system = Liquid::Template.file_system
+
+    begin
+      Liquid::Template.file_system = TestFileSystem.new
+      template = Liquid::Template.parse("Argument error:\n{% include 'product' %}", line_numbers: true)
+      page = template.render('errors' => ErrorDrop.new)
+    ensure
+      Liquid::Template.file_system = old_file_system
+    end
+    assert_equal "Argument error:\nLiquid error (product line 1): argument error", page
+    assert_equal "product", template.errors.first.template_name
+  end
+end

bin/gems/liquid-4.0.4/test/integration/filter_test.rb

@@ -0,0 +1,178 @@
+require 'test_helper'
+
+module MoneyFilter
+  def money(input)
+    sprintf(' %d$ ', input)
+  end
+
+  def money_with_underscore(input)
+    sprintf(' %d$ ', input)
+  end
+end
+
+module CanadianMoneyFilter
+  def money(input)
+    sprintf(' %d$ CAD ', input)
+  end
+end
+
+module SubstituteFilter
+  def substitute(input, params = {})
+    input.gsub(/%\{(\w+)\}/) { |match| params[$1] }
+  end
+end
+
+class FiltersTest < Minitest::Test
+  include Liquid
+
+  module OverrideObjectMethodFilter
+    def tap(input)
+      "tap overridden"
+    end
+  end
+
+  def setup
+    @context = Context.new
+  end
+
+  def test_local_filter
+    @context['var'] = 1000
+    @context.add_filters(MoneyFilter)
+
+    assert_equal ' 1000$ ', Template.parse("{{var | money}}").render(@context)
+  end
+
+  def test_underscore_in_filter_name
+    @context['var'] = 1000
+    @context.add_filters(MoneyFilter)
+    assert_equal ' 1000$ ', Template.parse("{{var | money_with_underscore}}").render(@context)
+  end
+
+  def test_second_filter_overwrites_first
+    @context['var'] = 1000
+    @context.add_filters(MoneyFilter)
+    @context.add_filters(CanadianMoneyFilter)
+
+    assert_equal ' 1000$ CAD ', Template.parse("{{var | money}}").render(@context)
+  end
+
+  def test_size
+    @context['var'] = 'abcd'
+    @context.add_filters(MoneyFilter)
+
+    assert_equal '4', Template.parse("{{var | size}}").render(@context)
+  end
+
+  def test_join
+    @context['var'] = [1, 2, 3, 4]
+
+    assert_equal "1 2 3 4", Template.parse("{{var | join}}").render(@context)
+  end
+
+  def test_sort
+    @context['value'] = 3
+    @context['numbers'] = [2, 1, 4, 3]
+    @context['words'] = ['expected', 'as', 'alphabetic']
+    @context['arrays'] = ['flower', 'are']
+    @context['case_sensitive'] = ['sensitive', 'Expected', 'case']
+
+    assert_equal '1 2 3 4', Template.parse("{{numbers | sort | join}}").render(@context)
+    assert_equal 'alphabetic as expected', Template.parse("{{words | sort | join}}").render(@context)
+    assert_equal '3', Template.parse("{{value | sort}}").render(@context)
+    assert_equal 'are flower', Template.parse("{{arrays | sort | join}}").render(@context)
+    assert_equal 'Expected case sensitive', Template.parse("{{case_sensitive | sort | join}}").render(@context)
+  end
+
+  def test_sort_natural
+    @context['words'] = ['case', 'Assert', 'Insensitive']
+    @context['hashes'] = [{ 'a' => 'A' }, { 'a' => 'b' }, { 'a' => 'C' }]
+    @context['objects'] = [TestObject.new('A'), TestObject.new('b'), TestObject.new('C')]
+
+    # Test strings
+    assert_equal 'Assert case Insensitive', Template.parse("{{words | sort_natural | join}}").render(@context)
+
+    # Test hashes
+    assert_equal 'A b C', Template.parse("{{hashes | sort_natural: 'a' | map: 'a' | join}}").render(@context)
+
+    # Test objects
+    assert_equal 'A b C', Template.parse("{{objects | sort_natural: 'a' | map: 'a' | join}}").render(@context)
+  end
+
+  def test_compact
+    @context['words'] = ['a', nil, 'b', nil, 'c']
+    @context['hashes'] = [{ 'a' => 'A' }, { 'a' => nil }, { 'a' => 'C' }]
+    @context['objects'] = [TestObject.new('A'), TestObject.new(nil), TestObject.new('C')]
+
+    # Test strings
+    assert_equal 'a b c', Template.parse("{{words | compact | join}}").render(@context)
+
+    # Test hashes
+    assert_equal 'A C', Template.parse("{{hashes | compact: 'a' | map: 'a' | join}}").render(@context)
+
+    # Test objects
+    assert_equal 'A C', Template.parse("{{objects | compact: 'a' | map: 'a' | join}}").render(@context)
+  end
+
+  def test_strip_html
+    @context['var'] = "<b>bla blub</a>"
+
+    assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context)
+  end
+
+  def test_strip_html_ignore_comments_with_html
+    @context['var'] = "<!-- split and some <ul> tag --><b>bla blub</a>"
+
+    assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context)
+  end
+
+  def test_capitalize
+    @context['var'] = "blub"
+
+    assert_equal "Blub", Template.parse("{{ var | capitalize }}").render(@context)
+  end
+
+  def test_nonexistent_filter_is_ignored
+    @context['var'] = 1000
+
+    assert_equal '1000', Template.parse("{{ var | xyzzy }}").render(@context)
+  end
+
+  def test_filter_with_keyword_arguments
+    @context['surname'] = 'john'
+    @context['input'] = 'hello %{first_name}, %{last_name}'
+    @context.add_filters(SubstituteFilter)
+    output = Template.parse(%({{ input | substitute: first_name: surname, last_name: 'doe' }})).render(@context)
+    assert_equal 'hello john, doe', output
+  end
+
+  def test_override_object_method_in_filter
+    assert_equal "tap overridden", Template.parse("{{var | tap}}").render!({ 'var' => 1000 }, filters: [OverrideObjectMethodFilter])
+
+    # tap still treated as a non-existent filter
+    assert_equal "1000", Template.parse("{{var | tap}}").render!({ 'var' => 1000 })
+  end
+end
+
+class FiltersInTemplate < Minitest::Test
+  include Liquid
+
+  def test_local_global
+    with_global_filter(MoneyFilter) do
+      assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, filters: CanadianMoneyFilter)
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, filters: [CanadianMoneyFilter])
+    end
+  end
+
+  def test_local_filter_with_deprecated_syntax
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, CanadianMoneyFilter)
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, [CanadianMoneyFilter])
+  end
+end # FiltersTest
+
+class TestObject < Liquid::Drop
+  attr_accessor :a
+  def initialize(a)
+    @a = a
+  end
+end

bin/gems/liquid-4.0.4/test/integration/hash_ordering_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class HashOrderingTest < Minitest::Test
+  module MoneyFilter
+    def money(input)
+      sprintf(' %d$ ', input)
+    end
+  end
+
+  module CanadianMoneyFilter
+    def money(input)
+      sprintf(' %d$ CAD ', input)
+    end
+  end
+
+  include Liquid
+
+  def test_global_register_order
+    with_global_filter(MoneyFilter, CanadianMoneyFilter) do
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, nil)
+    end
+  end
+end

bin/gems/liquid-4.0.4/test/integration/output_test.rb

@@ -0,0 +1,123 @@
+require 'test_helper'
+
+module FunnyFilter
+  def make_funny(input)
+    'LOL'
+  end
+
+  def cite_funny(input)
+    "LOL: #{input}"
+  end
+
+  def add_smiley(input, smiley = ":-)")
+    "#{input} #{smiley}"
+  end
+
+  def add_tag(input, tag = "p", id = "foo")
+    %(<#{tag} id="#{id}">#{input}</#{tag}>)
+  end
+
+  def paragraph(input)
+    "<p>#{input}</p>"
+  end
+
+  def link_to(name, url)
+    %(<a href="#{url}">#{name}</a>)
+  end
+end
+
+class OutputTest < Minitest::Test
+  include Liquid
+
+  def setup
+    @assigns = {
+      'best_cars' => 'bmw',
+      'car' => { 'bmw' => 'good', 'gm' => 'bad' }
+    }
+  end
+
+  def test_variable
+    text = %( {{best_cars}} )
+
+    expected = %( bmw )
+    assert_equal expected, Template.parse(text).render!(@assigns)
+  end
+
+  def test_variable_traversing_with_two_brackets
+    text = %({{ site.data.menu[include.menu][include.locale] }})
+    assert_equal "it works!", Template.parse(text).render!(
+      "site" => { "data" => { "menu" => { "foo" => { "bar" => "it works!" } } } },
+      "include" => { "menu" => "foo", "locale" => "bar" }
+    )
+  end
+
+  def test_variable_traversing
+    text = %( {{car.bmw}} {{car.gm}} {{car.bmw}} )
+
+    expected = %( good bad good )
+    assert_equal expected, Template.parse(text).render!(@assigns)
+  end
+
+  def test_variable_piping
+    text = %( {{ car.gm | make_funny }} )
+    expected = %( LOL )
+
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+  end
+
+  def test_variable_piping_with_input
+    text = %( {{ car.gm | cite_funny }} )
+    expected = %( LOL: bad )
+
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+  end
+
+  def test_variable_piping_with_args
+    text = %! {{ car.gm | add_smiley : ':-(' }} !
+    expected = %| bad :-( |
+
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+  end
+
+  def test_variable_piping_with_no_args
+    text = %( {{ car.gm | add_smiley }} )
+    expected = %| bad :-) |
+
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+  end
+
+  def test_multiple_variable_piping_with_args
+    text = %! {{ car.gm | add_smiley : ':-(' | add_smiley : ':-('}} !
+    expected = %| bad :-( :-( |
+
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+  end
+
+  def test_variable_piping_with_multiple_args
+    text = %( {{ car.gm | add_tag : 'span', 'bar'}} )
+    expected = %( <span id="bar">bad</span> )
+
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+  end
+
+  def test_variable_piping_with_variable_args
+    text = %( {{ car.gm | add_tag : 'span', car.bmw}} )
+    expected = %( <span id="good">bad</span> )
+
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+  end
+
+  def test_multiple_pipings
+    text = %( {{ best_cars | cite_funny | paragraph }} )
+    expected = %( <p>LOL: bmw</p> )
+
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+  end
+
+  def test_link_to
+    text = %( {{ 'Typo' | link_to: 'http://typo.leetsoft.com' }} )
+    expected = %( <a href="http://typo.leetsoft.com">Typo</a> )
+
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+  end
+end # OutputTest

bin/gems/liquid-4.0.4/test/integration/parse_tree_visitor_test.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class ParseTreeVisitorTest < Minitest::Test
+  include Liquid
+
+  def test_variable
+    assert_equal(
+      ["test"],
+      visit(%({{ test }}))
+    )
+  end
+
+  def test_varible_with_filter
+    assert_equal(
+      ["test", "infilter"],
+      visit(%({{ test | split: infilter }}))
+    )
+  end
+
+  def test_dynamic_variable
+    assert_equal(
+      ["test", "inlookup"],
+      visit(%({{ test[inlookup] }}))
+    )
+  end
+
+  def test_if_condition
+    assert_equal(
+      ["test"],
+      visit(%({% if test %}{% endif %}))
+    )
+  end
+
+  def test_complex_if_condition
+    assert_equal(
+      ["test"],
+      visit(%({% if 1 == 1 and 2 == test %}{% endif %}))
+    )
+  end
+
+  def test_if_body
+    assert_equal(
+      ["test"],
+      visit(%({% if 1 == 1 %}{{ test }}{% endif %}))
+    )
+  end
+
+  def test_unless_condition
+    assert_equal(
+      ["test"],
+      visit(%({% unless test %}{% endunless %}))
+    )
+  end
+
+  def test_complex_unless_condition
+    assert_equal(
+      ["test"],
+      visit(%({% unless 1 == 1 and 2 == test %}{% endunless %}))
+    )
+  end
+
+  def test_unless_body
+    assert_equal(
+      ["test"],
+      visit(%({% unless 1 == 1 %}{{ test }}{% endunless %}))
+    )
+  end
+
+  def test_elsif_condition
+    assert_equal(
+      ["test"],
+      visit(%({% if 1 == 1 %}{% elsif test %}{% endif %}))
+    )
+  end
+
+  def test_complex_elsif_condition
+    assert_equal(
+      ["test"],
+      visit(%({% if 1 == 1 %}{% elsif 1 == 1 and 2 == test %}{% endif %}))
+    )
+  end
+
+  def test_elsif_body
+    assert_equal(
+      ["test"],
+      visit(%({% if 1 == 1 %}{% elsif 2 == 2 %}{{ test }}{% endif %}))
+    )
+  end
+
+  def test_else_body
+    assert_equal(
+      ["test"],
+      visit(%({% if 1 == 1 %}{% else %}{{ test }}{% endif %}))
+    )
+  end
+
+  def test_case_left
+    assert_equal(
+      ["test"],
+      visit(%({% case test %}{% endcase %}))
+    )
+  end
+
+  def test_case_condition
+    assert_equal(
+      ["test"],
+      visit(%({% case 1 %}{% when test %}{% endcase %}))
+    )
+  end
+
+  def test_case_when_body
+    assert_equal(
+      ["test"],
+      visit(%({% case 1 %}{% when 2 %}{{ test }}{% endcase %}))
+    )
+  end
+
+  def test_case_else_body
+    assert_equal(
+      ["test"],
+      visit(%({% case 1 %}{% else %}{{ test }}{% endcase %}))
+    )
+  end
+
+  def test_for_in
+    assert_equal(
+      ["test"],
+      visit(%({% for x in test %}{% endfor %}))
+    )
+  end
+
+  def test_for_limit
+    assert_equal(
+      ["test"],
+      visit(%({% for x in (1..5) limit: test %}{% endfor %}))
+    )
+  end
+
+  def test_for_offset
+    assert_equal(
+      ["test"],
+      visit(%({% for x in (1..5) offset: test %}{% endfor %}))
+    )
+  end
+
+  def test_for_body
+    assert_equal(
+      ["test"],
+      visit(%({% for x in (1..5) %}{{ test }}{% endfor %}))
+    )
+  end
+
+  def test_tablerow_in
+    assert_equal(
+      ["test"],
+      visit(%({% tablerow x in test %}{% endtablerow %}))
+    )
+  end
+
+  def test_tablerow_limit
+    assert_equal(
+      ["test"],
+      visit(%({% tablerow x in (1..5) limit: test %}{% endtablerow %}))
+    )
+  end
+
+  def test_tablerow_offset
+    assert_equal(
+      ["test"],
+      visit(%({% tablerow x in (1..5) offset: test %}{% endtablerow %}))
+    )
+  end
+
+  def test_tablerow_body
+    assert_equal(
+      ["test"],
+      visit(%({% tablerow x in (1..5) %}{{ test }}{% endtablerow %}))
+    )
+  end
+
+  def test_cycle
+    assert_equal(
+      ["test"],
+      visit(%({% cycle test %}))
+    )
+  end
+
+  def test_assign
+    assert_equal(
+      ["test"],
+      visit(%({% assign x = test %}))
+    )
+  end
+
+  def test_capture
+    assert_equal(
+      ["test"],
+      visit(%({% capture x %}{{ test }}{% endcapture %}))
+    )
+  end
+
+  def test_include
+    assert_equal(
+      ["test"],
+      visit(%({% include test %}))
+    )
+  end
+
+  def test_include_with
+    assert_equal(
+      ["test"],
+      visit(%({% include "hai" with test %}))
+    )
+  end
+
+  def test_include_for
+    assert_equal(
+      ["test"],
+      visit(%({% include "hai" for test %}))
+    )
+  end
+
+  def test_preserve_tree_structure
+    assert_equal(
+      [[nil, [
+        [nil, [[nil, [["other", []]]]]],
+        ["test", []],
+        ["xs", []]
+      ]]],
+      traversal(%({% for x in xs offset: test %}{{ other }}{% endfor %})).visit
+    )
+  end
+
+  private
+
+  def traversal(template)
+    ParseTreeVisitor
+      .for(Template.parse(template).root)
+      .add_callback_for(VariableLookup) { |node| node.name } # rubocop:disable Style/SymbolProc
+  end
+
+  def visit(template)
+    traversal(template).visit.flatten.compact
+  end
+end

bin/gems/liquid-4.0.4/test/integration/parsing_quirks_test.rb

@@ -0,0 +1,122 @@
+require 'test_helper'
+
+class ParsingQuirksTest < Minitest::Test
+  include Liquid
+
+  def test_parsing_css
+    text = " div { font-weight: bold; } "
+    assert_equal text, Template.parse(text).render!
+  end
+
+  def test_raise_on_single_close_bracet
+    assert_raises(SyntaxError) do
+      Template.parse("text {{method} oh nos!")
+    end
+  end
+
+  def test_raise_on_label_and_no_close_bracets
+    assert_raises(SyntaxError) do
+      Template.parse("TEST {{ ")
+    end
+  end
+
+  def test_raise_on_label_and_no_close_bracets_percent
+    assert_raises(SyntaxError) do
+      Template.parse("TEST {% ")
+    end
+  end
+
+  def test_error_on_empty_filter
+    assert Template.parse("{{test}}")
+
+    with_error_mode(:lax) do
+      assert Template.parse("{{|test}}")
+    end
+
+    with_error_mode(:strict) do
+      assert_raises(SyntaxError) { Template.parse("{{|test}}") }
+      assert_raises(SyntaxError) { Template.parse("{{test |a|b|}}") }
+    end
+  end
+
+  def test_meaningless_parens_error
+    with_error_mode(:strict) do
+      assert_raises(SyntaxError) do
+        markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
+        Template.parse("{% if #{markup} %} YES {% endif %}")
+      end
+    end
+  end
+
+  def test_unexpected_characters_syntax_error
+    with_error_mode(:strict) do
+      assert_raises(SyntaxError) do
+        markup = "true && false"
+        Template.parse("{% if #{markup} %} YES {% endif %}")
+      end
+      assert_raises(SyntaxError) do
+        markup = "false || true"
+        Template.parse("{% if #{markup} %} YES {% endif %}")
+      end
+    end
+  end
+
+  def test_no_error_on_lax_empty_filter
+    assert Template.parse("{{test |a|b|}}", error_mode: :lax)
+    assert Template.parse("{{test}}", error_mode: :lax)
+    assert Template.parse("{{|test|}}", error_mode: :lax)
+  end
+
+  def test_meaningless_parens_lax
+    with_error_mode(:lax) do
+      assigns = { 'b' => 'bar', 'c' => 'baz' }
+      markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
+      assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}", assigns)
+    end
+  end
+
+  def test_unexpected_characters_silently_eat_logic_lax
+    with_error_mode(:lax) do
+      markup = "true && false"
+      assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}")
+      markup = "false || true"
+      assert_template_result('', "{% if #{markup} %} YES {% endif %}")
+    end
+  end
+
+  def test_raise_on_invalid_tag_delimiter
+    assert_raises(Liquid::SyntaxError) do
+      Template.new.parse('{% end %}')
+    end
+  end
+
+  def test_unanchored_filter_arguments
+    with_error_mode(:lax) do
+      assert_template_result('hi', "{{ 'hi there' | split$$$:' ' | first }}")
+
+      assert_template_result('x', "{{ 'X' | downcase) }}")
+
+      # After the messed up quotes a filter without parameters (reverse) should work
+      # but one with parameters (remove) shouldn't be detected.
+      assert_template_result('here',  "{{ 'hi there' | split:\"t\"\" | reverse | first}}")
+      assert_template_result('hi ', "{{ 'hi there' | split:\"t\"\" | remove:\"i\" | first}}")
+    end
+  end
+
+  def test_invalid_variables_work
+    with_error_mode(:lax) do
+      assert_template_result('bar', "{% assign 123foo = 'bar' %}{{ 123foo }}")
+      assert_template_result('123', "{% assign 123 = 'bar' %}{{ 123 }}")
+    end
+  end
+
+  def test_extra_dots_in_ranges
+    with_error_mode(:lax) do
+      assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
+    end
+  end
+
+  def test_contains_in_id
+    assert_template_result(' YES ', '{% if containsallshipments == true %} YES {% endif %}', 'containsallshipments' => true)
+  end
+end # ParsingQuirksTest

bin/gems/liquid-4.0.4/test/integration/render_profiling_test.rb

@@ -0,0 +1,154 @@
+require 'test_helper'
+
+class RenderProfilingTest < Minitest::Test
+  include Liquid
+
+  class ProfilingFileSystem
+    def read_template_file(template_path)
+      "Rendering template {% assign template_name = '#{template_path}'%}\n{{ template_name }}"
+    end
+  end
+
+  def setup
+    Liquid::Template.file_system = ProfilingFileSystem.new
+  end
+
+  def test_template_allows_flagging_profiling
+    t = Template.parse("{{ 'a string' | upcase }}")
+    t.render!
+
+    assert_nil t.profiler
+  end
+
+  def test_parse_makes_available_simple_profiling
+    t = Template.parse("{{ 'a string' | upcase }}", profile: true)
+    t.render!
+
+    assert_equal 1, t.profiler.length
+
+    node = t.profiler[0]
+    assert_equal " 'a string' | upcase ", node.code
+  end
+
+  def test_render_ignores_raw_strings_when_profiling
+    t = Template.parse("This is raw string\nstuff\nNewline", profile: true)
+    t.render!
+
+    assert_equal 0, t.profiler.length
+  end
+
+  def test_profiling_includes_line_numbers_of_liquid_nodes
+    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", profile: true)
+    t.render!
+    assert_equal 2, t.profiler.length
+
+    # {{ 'a string' | upcase }}
+    assert_equal 1, t.profiler[0].line_number
+    # {{ increment test }}
+    assert_equal 2, t.profiler[1].line_number
+  end
+
+  def test_profiling_includes_line_numbers_of_included_partials
+    t = Template.parse("{% include 'a_template' %}", profile: true)
+    t.render!
+
+    included_children = t.profiler[0].children
+
+    # {% assign template_name = 'a_template' %}
+    assert_equal 1, included_children[0].line_number
+    # {{ template_name }}
+    assert_equal 2, included_children[1].line_number
+  end
+
+  def test_profiling_times_the_rendering_of_tokens
+    t = Template.parse("{% include 'a_template' %}", profile: true)
+    t.render!
+
+    node = t.profiler[0]
+    refute_nil node.render_time
+  end
+
+  def test_profiling_times_the_entire_render
+    t = Template.parse("{% include 'a_template' %}", profile: true)
+    t.render!
+
+    assert t.profiler.total_render_time >= 0, "Total render time was not calculated"
+  end
+
+  def test_profiling_uses_include_to_mark_children
+    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", profile: true)
+    t.render!
+
+    include_node = t.profiler[1]
+    assert_equal 2, include_node.children.length
+  end
+
+  def test_profiling_marks_children_with_the_name_of_included_partial
+    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", profile: true)
+    t.render!
+
+    include_node = t.profiler[1]
+    include_node.children.each do |child|
+      assert_equal "a_template", child.partial
+    end
+  end
+
+  def test_profiling_supports_multiple_templates
+    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'b_template' %}", profile: true)
+    t.render!
+
+    a_template = t.profiler[1]
+    a_template.children.each do |child|
+      assert_equal "a_template", child.partial
+    end
+
+    b_template = t.profiler[2]
+    b_template.children.each do |child|
+      assert_equal "b_template", child.partial
+    end
+  end
+
+  def test_profiling_supports_rendering_the_same_partial_multiple_times
+    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'a_template' %}", profile: true)
+    t.render!
+
+    a_template1 = t.profiler[1]
+    a_template1.children.each do |child|
+      assert_equal "a_template", child.partial
+    end
+
+    a_template2 = t.profiler[2]
+    a_template2.children.each do |child|
+      assert_equal "a_template", child.partial
+    end
+  end
+
+  def test_can_iterate_over_each_profiling_entry
+    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", profile: true)
+    t.render!
+
+    timing_count = 0
+    t.profiler.each do |timing|
+      timing_count += 1
+    end
+
+    assert_equal 2, timing_count
+  end
+
+  def test_profiling_marks_children_of_if_blocks
+    t = Template.parse("{% if true %} {% increment test %} {{ test }} {% endif %}", profile: true)
+    t.render!
+
+    assert_equal 1, t.profiler.length
+    assert_equal 2, t.profiler[0].children.length
+  end
+
+  def test_profiling_marks_children_of_for_blocks
+    t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", profile: true)
+    t.render!({ "collection" => ["one", "two"] })
+
+    assert_equal 1, t.profiler.length
+    # Will profile each invocation of the for block
+    assert_equal 2, t.profiler[0].children.length
+  end
+end

bin/gems/liquid-4.0.4/test/integration/security_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+module SecurityFilter
+  def add_one(input)
+    "#{input} + 1"
+  end
+end
+
+class SecurityTest < Minitest::Test
+  include Liquid
+
+  def setup
+    @assigns = {}
+  end
+
+  def test_no_instance_eval
+    text = %( {{ '1+1' | instance_eval }} )
+    expected = %( 1+1 )
+
+    assert_equal expected, Template.parse(text).render!(@assigns)
+  end
+
+  def test_no_existing_instance_eval
+    text = %( {{ '1+1' | __instance_eval__ }} )
+    expected = %( 1+1 )
+
+    assert_equal expected, Template.parse(text).render!(@assigns)
+  end
+
+  def test_no_instance_eval_after_mixing_in_new_filter
+    text = %( {{ '1+1' | instance_eval }} )
+    expected = %( 1+1 )
+
+    assert_equal expected, Template.parse(text).render!(@assigns)
+  end
+
+  def test_no_instance_eval_later_in_chain
+    text = %( {{ '1+1' | add_one | instance_eval }} )
+    expected = %( 1+1 + 1 )
+
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: SecurityFilter)
+  end
+
+  def test_does_not_add_filters_to_symbol_table
+    current_symbols = Symbol.all_symbols
+
+    test = %( {{ "some_string" | a_bad_filter }} )
+
+    template = Template.parse(test)
+    assert_equal [], (Symbol.all_symbols - current_symbols)
+
+    template.render!
+    assert_equal [], (Symbol.all_symbols - current_symbols)
+  end
+
+  def test_does_not_add_drop_methods_to_symbol_table
+    current_symbols = Symbol.all_symbols
+
+    assigns = { 'drop' => Drop.new }
+    assert_equal "", Template.parse("{{ drop.custom_method_1 }}", assigns).render!
+    assert_equal "", Template.parse("{{ drop.custom_method_2 }}", assigns).render!
+    assert_equal "", Template.parse("{{ drop.custom_method_3 }}", assigns).render!
+
+    assert_equal [], (Symbol.all_symbols - current_symbols)
+  end
+
+  def test_max_depth_nested_blocks_does_not_raise_exception
+    depth = Liquid::Block::MAX_DEPTH
+    code = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth
+    assert_equal "rendered", Template.parse(code).render!
+  end
+
+  def test_more_than_max_depth_nested_blocks_raises_exception
+    depth = Liquid::Block::MAX_DEPTH + 1
+    code = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth
+    assert_raises(Liquid::StackLevelError) do
+      Template.parse(code).render!
+    end
+  end
+end # SecurityTest

bin/gems/liquid-4.0.4/test/integration/standard_filter_test.rb

@@ -0,0 +1,776 @@
+# encoding: utf-8
+
+require 'test_helper'
+
+class Filters
+  include Liquid::StandardFilters
+end
+
+class TestThing
+  attr_reader :foo
+
+  def initialize
+    @foo = 0
+  end
+
+  def to_s
+    "woot: #{@foo}"
+  end
+
+  def [](whatever)
+    to_s
+  end
+
+  def to_liquid
+    @foo += 1
+    self
+  end
+end
+
+class TestDrop < Liquid::Drop
+  def test
+    "testfoo"
+  end
+end
+
+class TestEnumerable < Liquid::Drop
+  include Enumerable
+
+  def each(&block)
+    [ { "foo" => 1, "bar" => 2 }, { "foo" => 2, "bar" => 1 }, { "foo" => 3, "bar" => 3 } ].each(&block)
+  end
+end
+
+class NumberLikeThing < Liquid::Drop
+  def initialize(amount)
+    @amount = amount
+  end
+
+  def to_number
+    @amount
+  end
+end
+
+class StandardFiltersTest < Minitest::Test
+  include Liquid
+
+  def setup
+    @filters = Filters.new
+  end
+
+  def test_size
+    assert_equal 3, @filters.size([1, 2, 3])
+    assert_equal 0, @filters.size([])
+    assert_equal 0, @filters.size(nil)
+  end
+
+  def test_downcase
+    assert_equal 'testing', @filters.downcase("Testing")
+    assert_equal '', @filters.downcase(nil)
+  end
+
+  def test_upcase
+    assert_equal 'TESTING', @filters.upcase("Testing")
+    assert_equal '', @filters.upcase(nil)
+  end
+
+  def test_slice
+    assert_equal 'oob', @filters.slice('foobar', 1, 3)
+    assert_equal 'oobar', @filters.slice('foobar', 1, 1000)
+    assert_equal '', @filters.slice('foobar', 1, 0)
+    assert_equal 'o', @filters.slice('foobar', 1, 1)
+    assert_equal 'bar', @filters.slice('foobar', 3, 3)
+    assert_equal 'ar', @filters.slice('foobar', -2, 2)
+    assert_equal 'ar', @filters.slice('foobar', -2, 1000)
+    assert_equal 'r', @filters.slice('foobar', -1)
+    assert_equal '', @filters.slice(nil, 0)
+    assert_equal '', @filters.slice('foobar', 100, 10)
+    assert_equal '', @filters.slice('foobar', -100, 10)
+    assert_equal 'oob', @filters.slice('foobar', '1', '3')
+    assert_raises(Liquid::ArgumentError) do
+      @filters.slice('foobar', nil)
+    end
+    assert_raises(Liquid::ArgumentError) do
+      @filters.slice('foobar', 0, "")
+    end
+  end
+
+  def test_slice_on_arrays
+    input = 'foobar'.split(//)
+    assert_equal %w(o o b), @filters.slice(input, 1, 3)
+    assert_equal %w(o o b a r), @filters.slice(input, 1, 1000)
+    assert_equal %w(), @filters.slice(input, 1, 0)
+    assert_equal %w(o), @filters.slice(input, 1, 1)
+    assert_equal %w(b a r), @filters.slice(input, 3, 3)
+    assert_equal %w(a r), @filters.slice(input, -2, 2)
+    assert_equal %w(a r), @filters.slice(input, -2, 1000)
+    assert_equal %w(r), @filters.slice(input, -1)
+    assert_equal %w(), @filters.slice(input, 100, 10)
+    assert_equal %w(), @filters.slice(input, -100, 10)
+  end
+
+  def test_truncate
+    assert_equal '1234...', @filters.truncate('1234567890', 7)
+    assert_equal '1234567890', @filters.truncate('1234567890', 20)
+    assert_equal '...', @filters.truncate('1234567890', 0)
+    assert_equal '1234567890', @filters.truncate('1234567890')
+    assert_equal "测试...", @filters.truncate("测试测试测试测试", 5)
+    assert_equal '12341', @filters.truncate("1234567890", 5, 1)
+  end
+
+  def test_split
+    assert_equal ['12', '34'], @filters.split('12~34', '~')
+    assert_equal ['A? ', ' ,Z'], @filters.split('A? ~ ~ ~ ,Z', '~ ~ ~')
+    assert_equal ['A?Z'], @filters.split('A?Z', '~')
+    assert_equal [], @filters.split(nil, ' ')
+    assert_equal ['A', 'Z'], @filters.split('A1Z', 1)
+  end
+
+  def test_escape
+    assert_equal '&lt;strong&gt;', @filters.escape('<strong>')
+    assert_equal '1', @filters.escape(1)
+    assert_equal '2001-02-03', @filters.escape(Date.new(2001, 2, 3))
+    assert_nil @filters.escape(nil)
+  end
+
+  def test_h
+    assert_equal '&lt;strong&gt;', @filters.h('<strong>')
+    assert_equal '1', @filters.h(1)
+    assert_equal '2001-02-03', @filters.h(Date.new(2001, 2, 3))
+    assert_nil @filters.h(nil)
+  end
+
+  def test_escape_once
+    assert_equal '&lt;strong&gt;Hulk&lt;/strong&gt;', @filters.escape_once('&lt;strong&gt;Hulk</strong>')
+  end
+
+  def test_url_encode
+    assert_equal 'foo%2B1%40example.com', @filters.url_encode('foo+1@example.com')
+    assert_equal '1', @filters.url_encode(1)
+    assert_equal '2001-02-03', @filters.url_encode(Date.new(2001, 2, 3))
+    assert_nil @filters.url_encode(nil)
+  end
+
+  def test_url_decode
+    assert_equal 'foo bar', @filters.url_decode('foo+bar')
+    assert_equal 'foo bar', @filters.url_decode('foo%20bar')
+    assert_equal 'foo+1@example.com', @filters.url_decode('foo%2B1%40example.com')
+    assert_equal '1', @filters.url_decode(1)
+    assert_equal '2001-02-03', @filters.url_decode(Date.new(2001, 2, 3))
+    assert_nil @filters.url_decode(nil)
+    exception = assert_raises Liquid::ArgumentError do
+      @filters.url_decode('%ff')
+    end
+    assert_equal 'Liquid error: invalid byte sequence in UTF-8', exception.message
+  end
+
+  def test_truncatewords
+    assert_equal 'one two three', @filters.truncatewords('one two three', 4)
+    assert_equal 'one two...', @filters.truncatewords('one two three', 2)
+    assert_equal 'one two three', @filters.truncatewords('one two three')
+    assert_equal 'Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221;...', @filters.truncatewords('Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221; x 16&#8221; x 10.5&#8221; high) with cover.', 15)
+    assert_equal "测试测试测试测试", @filters.truncatewords('测试测试测试测试', 5)
+    assert_equal 'one two1', @filters.truncatewords("one two three", 2, 1)
+  end
+
+  def test_strip_html
+    assert_equal 'test', @filters.strip_html("<div>test</div>")
+    assert_equal 'test', @filters.strip_html("<div id='test'>test</div>")
+    assert_equal '', @filters.strip_html("<script type='text/javascript'>document.write('some stuff');</script>")
+    assert_equal '', @filters.strip_html("<style type='text/css'>foo bar</style>")
+    assert_equal 'test', @filters.strip_html("<div\nclass='multiline'>test</div>")
+    assert_equal 'test', @filters.strip_html("<!-- foo bar \n test -->test")
+    assert_equal '', @filters.strip_html(nil)
+
+    # Quirk of the existing implementation
+    assert_equal 'foo;', @filters.strip_html("<<<script </script>script>foo;</script>")
+  end
+
+  def test_join
+    assert_equal '1 2 3 4', @filters.join([1, 2, 3, 4])
+    assert_equal '1 - 2 - 3 - 4', @filters.join([1, 2, 3, 4], ' - ')
+    assert_equal '1121314', @filters.join([1, 2, 3, 4], 1)
+  end
+
+  def test_sort
+    assert_equal [1, 2, 3, 4], @filters.sort([4, 3, 2, 1])
+    assert_equal [{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }], @filters.sort([{ "a" => 4 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a")
+  end
+
+  def test_sort_with_nils
+    assert_equal [1, 2, 3, 4, nil], @filters.sort([nil, 4, 3, 2, 1])
+    assert_equal [{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }, {}], @filters.sort([{ "a" => 4 }, { "a" => 3 }, {}, { "a" => 1 }, { "a" => 2 }], "a")
+  end
+
+  def test_sort_when_property_is_sometimes_missing_puts_nils_last
+    input = [
+      { "price" => 4, "handle" => "alpha" },
+      { "handle" => "beta" },
+      { "price" => 1, "handle" => "gamma" },
+      { "handle" => "delta" },
+      { "price" => 2, "handle" => "epsilon" }
+    ]
+    expectation = [
+      { "price" => 1, "handle" => "gamma" },
+      { "price" => 2, "handle" => "epsilon" },
+      { "price" => 4, "handle" => "alpha" },
+      { "handle" => "delta" },
+      { "handle" => "beta" }
+    ]
+    assert_equal expectation, @filters.sort(input, "price")
+  end
+
+  def test_sort_natural
+    assert_equal ["a", "B", "c", "D"], @filters.sort_natural(["c", "D", "a", "B"])
+    assert_equal [{ "a" => "a" }, { "a" => "B" }, { "a" => "c" }, { "a" => "D" }], @filters.sort_natural([{ "a" => "D" }, { "a" => "c" }, { "a" => "a" }, { "a" => "B" }], "a")
+  end
+
+  def test_sort_natural_with_nils
+    assert_equal ["a", "B", "c", "D", nil], @filters.sort_natural([nil, "c", "D", "a", "B"])
+    assert_equal [{ "a" => "a" }, { "a" => "B" }, { "a" => "c" }, { "a" => "D" }, {}], @filters.sort_natural([{ "a" => "D" }, { "a" => "c" }, {}, { "a" => "a" }, { "a" => "B" }], "a")
+  end
+
+  def test_sort_natural_when_property_is_sometimes_missing_puts_nils_last
+    input = [
+      { "price" => "4", "handle" => "alpha" },
+      { "handle" => "beta" },
+      { "price" => "1", "handle" => "gamma" },
+      { "handle" => "delta" },
+      { "price" => 2, "handle" => "epsilon" }
+    ]
+    expectation = [
+      { "price" => "1", "handle" => "gamma" },
+      { "price" => 2, "handle" => "epsilon" },
+      { "price" => "4", "handle" => "alpha" },
+      { "handle" => "delta" },
+      { "handle" => "beta" }
+    ]
+    assert_equal expectation, @filters.sort_natural(input, "price")
+  end
+
+  def test_sort_natural_case_check
+    input = [
+      { "key" => "X" },
+      { "key" => "Y" },
+      { "key" => "Z" },
+      { "fake" => "t" },
+      { "key" => "a" },
+      { "key" => "b" },
+      { "key" => "c" }
+    ]
+    expectation = [
+      { "key" => "a" },
+      { "key" => "b" },
+      { "key" => "c" },
+      { "key" => "X" },
+      { "key" => "Y" },
+      { "key" => "Z" },
+      { "fake" => "t" }
+    ]
+    assert_equal expectation, @filters.sort_natural(input, "key")
+    assert_equal ["a", "b", "c", "X", "Y", "Z"], @filters.sort_natural(["X", "Y", "Z", "a", "b", "c"])
+  end
+
+  def test_sort_empty_array
+    assert_equal [], @filters.sort([], "a")
+  end
+
+  def test_sort_invalid_property
+    foo = [
+      [1],
+      [2],
+      [3]
+    ]
+
+    assert_raises Liquid::ArgumentError do
+      @filters.sort(foo, "bar")
+    end
+  end
+
+  def test_sort_natural_empty_array
+    assert_equal [], @filters.sort_natural([], "a")
+  end
+
+  def test_sort_natural_invalid_property
+    foo = [
+      [1],
+      [2],
+      [3]
+    ]
+
+    assert_raises Liquid::ArgumentError do
+      @filters.sort_natural(foo, "bar")
+    end
+  end
+
+  def test_legacy_sort_hash
+    assert_equal [{ a: 1, b: 2 }], @filters.sort({ a: 1, b: 2 })
+  end
+
+  def test_numerical_vs_lexicographical_sort
+    assert_equal [2, 10], @filters.sort([10, 2])
+    assert_equal [{ "a" => 2 }, { "a" => 10 }], @filters.sort([{ "a" => 10 }, { "a" => 2 }], "a")
+    assert_equal ["10", "2"], @filters.sort(["10", "2"])
+    assert_equal [{ "a" => "10" }, { "a" => "2" }], @filters.sort([{ "a" => "10" }, { "a" => "2" }], "a")
+  end
+
+  def test_uniq
+    assert_equal ["foo"], @filters.uniq("foo")
+    assert_equal [1, 3, 2, 4], @filters.uniq([1, 1, 3, 2, 3, 1, 4, 3, 2, 1])
+    assert_equal [{ "a" => 1 }, { "a" => 3 }, { "a" => 2 }], @filters.uniq([{ "a" => 1 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a")
+    testdrop = TestDrop.new
+    assert_equal [testdrop], @filters.uniq([testdrop, TestDrop.new], 'test')
+  end
+
+  def test_uniq_empty_array
+    assert_equal [], @filters.uniq([], "a")
+  end
+
+  def test_uniq_invalid_property
+    foo = [
+      [1],
+      [2],
+      [3]
+    ]
+
+    assert_raises Liquid::ArgumentError do
+      @filters.uniq(foo, "bar")
+    end
+  end
+
+  def test_compact_empty_array
+    assert_equal [], @filters.compact([], "a")
+  end
+
+  def test_compact_invalid_property
+    foo = [
+      [1],
+      [2],
+      [3]
+    ]
+
+    assert_raises Liquid::ArgumentError do
+      @filters.compact(foo, "bar")
+    end
+  end
+
+  def test_reverse
+    assert_equal [4, 3, 2, 1], @filters.reverse([1, 2, 3, 4])
+  end
+
+  def test_legacy_reverse_hash
+    assert_equal [{ a: 1, b: 2 }], @filters.reverse(a: 1, b: 2)
+  end
+
+  def test_map
+    assert_equal [1, 2, 3, 4], @filters.map([{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }], 'a')
+    assert_template_result 'abc', "{{ ary | map:'foo' | map:'bar' }}",
+      'ary' => [{ 'foo' => { 'bar' => 'a' } }, { 'foo' => { 'bar' => 'b' } }, { 'foo' => { 'bar' => 'c' } }]
+  end
+
+  def test_map_doesnt_call_arbitrary_stuff
+    assert_template_result "", '{{ "foo" | map: "__id__" }}'
+    assert_template_result "", '{{ "foo" | map: "inspect" }}'
+  end
+
+  def test_map_calls_to_liquid
+    t = TestThing.new
+    assert_template_result "woot: 1", '{{ foo | map: "whatever" }}', "foo" => [t]
+  end
+
+  def test_map_on_hashes
+    assert_template_result "4217", '{{ thing | map: "foo" | map: "bar" }}',
+      "thing" => { "foo" => [ { "bar" => 42 }, { "bar" => 17 } ] }
+  end
+
+  def test_legacy_map_on_hashes_with_dynamic_key
+    template = "{% assign key = 'foo' %}{{ thing | map: key | map: 'bar' }}"
+    hash = { "foo" => { "bar" => 42 } }
+    assert_template_result "42", template, "thing" => hash
+  end
+
+  def test_sort_calls_to_liquid
+    t = TestThing.new
+    Liquid::Template.parse('{{ foo | sort: "whatever" }}').render("foo" => [t])
+    assert t.foo > 0
+  end
+
+  def test_map_over_proc
+    drop = TestDrop.new
+    p = proc{ drop }
+    templ = '{{ procs | map: "test" }}'
+    assert_template_result "testfoo", templ, "procs" => [p]
+  end
+
+  def test_map_over_drops_returning_procs
+    drops = [
+      {
+        "proc" => ->{ "foo" },
+      },
+      {
+        "proc" => ->{ "bar" },
+      },
+    ]
+    templ = '{{ drops | map: "proc" }}'
+    assert_template_result "foobar", templ, "drops" => drops
+  end
+
+  def test_map_works_on_enumerables
+    assert_template_result "123", '{{ foo | map: "foo" }}', "foo" => TestEnumerable.new
+  end
+
+  def test_map_returns_empty_on_2d_input_array
+    foo = [
+      [1],
+      [2],
+      [3]
+    ]
+
+    assert_raises Liquid::ArgumentError do
+      @filters.map(foo, "bar")
+    end
+  end
+
+  def test_map_returns_empty_with_no_property
+    foo = [
+      [1],
+      [2],
+      [3]
+    ]
+    assert_raises Liquid::ArgumentError do
+      @filters.map(foo, nil)
+    end
+  end
+
+  def test_sort_works_on_enumerables
+    assert_template_result "213", '{{ foo | sort: "bar" | map: "foo" }}', "foo" => TestEnumerable.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]
+  end
+
+  def test_truncate_calls_to_liquid
+    assert_template_result "wo...", '{{ foo | truncate: 5 }}', "foo" => TestThing.new
+  end
+
+  def test_date
+    assert_equal 'May', @filters.date(Time.parse("2006-05-05 10:00:00"), "%B")
+    assert_equal 'June', @filters.date(Time.parse("2006-06-05 10:00:00"), "%B")
+    assert_equal 'July', @filters.date(Time.parse("2006-07-05 10:00:00"), "%B")
+
+    assert_equal 'May', @filters.date("2006-05-05 10:00:00", "%B")
+    assert_equal 'June', @filters.date("2006-06-05 10:00:00", "%B")
+    assert_equal 'July', @filters.date("2006-07-05 10:00:00", "%B")
+
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", nil)
+
+    assert_equal '07/05/2006', @filters.date("2006-07-05 10:00:00", "%m/%d/%Y")
+
+    assert_equal "07/16/2004", @filters.date("Fri Jul 16 01:00:00 2004", "%m/%d/%Y")
+    assert_equal Date.today.year.to_s, @filters.date('now', '%Y')
+    assert_equal Date.today.year.to_s, @filters.date('today', '%Y')
+    assert_equal Date.today.year.to_s, @filters.date('Today', '%Y')
+
+    assert_nil @filters.date(nil, "%B")
+
+    assert_equal '', @filters.date('', "%B")
+
+    with_timezone("UTC") do
+      assert_equal "07/05/2006", @filters.date(1152098955, "%m/%d/%Y")
+      assert_equal "07/05/2006", @filters.date("1152098955", "%m/%d/%Y")
+    end
+  end
+
+  def test_first_last
+    assert_equal 1, @filters.first([1, 2, 3])
+    assert_equal 3, @filters.last([1, 2, 3])
+    assert_nil @filters.first([])
+    assert_nil @filters.last([])
+  end
+
+  def test_replace
+    assert_equal '2 2 2 2', @filters.replace('1 1 1 1', '1', 2)
+    assert_equal '2 2 2 2', @filters.replace('1 1 1 1', 1, 2)
+    assert_equal '2 1 1 1', @filters.replace_first('1 1 1 1', '1', 2)
+    assert_equal '2 1 1 1', @filters.replace_first('1 1 1 1', 1, 2)
+    assert_template_result '2 1 1 1', "{{ '1 1 1 1' | replace_first: '1', 2 }}"
+  end
+
+  def test_remove
+    assert_equal '   ', @filters.remove("a a a a", 'a')
+    assert_equal '   ', @filters.remove("1 1 1 1", 1)
+    assert_equal 'a a a', @filters.remove_first("a a a a", 'a ')
+    assert_equal ' 1 1 1', @filters.remove_first("1 1 1 1", 1)
+    assert_template_result 'a a a', "{{ 'a a a a' | remove_first: 'a ' }}"
+  end
+
+  def test_pipes_in_string_arguments
+    assert_template_result 'foobar', "{{ 'foo|bar' | remove: '|' }}"
+  end
+
+  def test_strip
+    assert_template_result 'ab c', "{{ source | strip }}", 'source' => " ab c  "
+    assert_template_result 'ab c', "{{ source | strip }}", 'source' => " \tab c  \n \t"
+  end
+
+  def test_lstrip
+    assert_template_result 'ab c  ', "{{ source | lstrip }}", 'source' => " ab c  "
+    assert_template_result "ab c  \n \t", "{{ source | lstrip }}", 'source' => " \tab c  \n \t"
+  end
+
+  def test_rstrip
+    assert_template_result " ab c", "{{ source | rstrip }}", 'source' => " ab c  "
+    assert_template_result " \tab c", "{{ source | rstrip }}", 'source' => " \tab c  \n \t"
+  end
+
+  def test_strip_newlines
+    assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\nb\nc"
+    assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\r\nb\nc"
+  end
+
+  def test_newlines_to_br
+    assert_template_result "a<br />\nb<br />\nc", "{{ source | newline_to_br }}", 'source' => "a\nb\nc"
+  end
+
+  def test_plus
+    assert_template_result "2", "{{ 1 | plus:1 }}"
+    assert_template_result "2.0", "{{ '1' | plus:'1.0' }}"
+
+    assert_template_result "5", "{{ price | plus:'2' }}", 'price' => NumberLikeThing.new(3)
+  end
+
+  def test_minus
+    assert_template_result "4", "{{ input | minus:operand }}", 'input' => 5, 'operand' => 1
+    assert_template_result "2.3", "{{ '4.3' | minus:'2' }}"
+
+    assert_template_result "5", "{{ price | minus:'2' }}", 'price' => NumberLikeThing.new(7)
+  end
+
+  def test_abs
+    assert_template_result "17", "{{ 17 | abs }}"
+    assert_template_result "17", "{{ -17 | abs }}"
+    assert_template_result "17", "{{ '17' | abs }}"
+    assert_template_result "17", "{{ '-17' | abs }}"
+    assert_template_result "0", "{{ 0 | abs }}"
+    assert_template_result "0", "{{ '0' | abs }}"
+    assert_template_result "17.42", "{{ 17.42 | abs }}"
+    assert_template_result "17.42", "{{ -17.42 | abs }}"
+    assert_template_result "17.42", "{{ '17.42' | abs }}"
+    assert_template_result "17.42", "{{ '-17.42' | abs }}"
+  end
+
+  def test_times
+    assert_template_result "12", "{{ 3 | times:4 }}"
+    assert_template_result "0", "{{ 'foo' | times:4 }}"
+    assert_template_result "6", "{{ '2.1' | times:3 | replace: '.','-' | plus:0}}"
+    assert_template_result "7.25", "{{ 0.0725 | times:100 }}"
+    assert_template_result "-7.25", '{{ "-0.0725" | times:100 }}'
+    assert_template_result "7.25", '{{ "-0.0725" | times: -100 }}'
+    assert_template_result "4", "{{ price | times:2 }}", 'price' => NumberLikeThing.new(2)
+  end
+
+  def test_divided_by
+    assert_template_result "4", "{{ 12 | divided_by:3 }}"
+    assert_template_result "4", "{{ 14 | divided_by:3 }}"
+
+    assert_template_result "5", "{{ 15 | divided_by:3 }}"
+    assert_equal "Liquid error: divided by 0", Template.parse("{{ 5 | divided_by:0 }}").render
+
+    assert_template_result "0.5", "{{ 2.0 | divided_by:4 }}"
+    assert_raises(Liquid::ZeroDivisionError) do
+      assert_template_result "4", "{{ 1 | modulo: 0 }}"
+    end
+
+    assert_template_result "5", "{{ price | divided_by:2 }}", 'price' => NumberLikeThing.new(10)
+  end
+
+  def test_modulo
+    assert_template_result "1", "{{ 3 | modulo:2 }}"
+    assert_raises(Liquid::ZeroDivisionError) do
+      assert_template_result "4", "{{ 1 | modulo: 0 }}"
+    end
+
+    assert_template_result "1", "{{ price | modulo:2 }}", 'price' => NumberLikeThing.new(3)
+  end
+
+  def test_round
+    assert_template_result "5", "{{ input | round }}", 'input' => 4.6
+    assert_template_result "4", "{{ '4.3' | round }}"
+    assert_template_result "4.56", "{{ input | round: 2 }}", 'input' => 4.5612
+    assert_raises(Liquid::FloatDomainError) do
+      assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | round }}"
+    end
+
+    assert_template_result "5", "{{ price | round }}", 'price' => NumberLikeThing.new(4.6)
+    assert_template_result "4", "{{ price | round }}", 'price' => NumberLikeThing.new(4.3)
+  end
+
+  def test_ceil
+    assert_template_result "5", "{{ input | ceil }}", 'input' => 4.6
+    assert_template_result "5", "{{ '4.3' | ceil }}"
+    assert_raises(Liquid::FloatDomainError) do
+      assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | ceil }}"
+    end
+
+    assert_template_result "5", "{{ price | ceil }}", 'price' => NumberLikeThing.new(4.6)
+  end
+
+  def test_floor
+    assert_template_result "4", "{{ input | floor }}", 'input' => 4.6
+    assert_template_result "4", "{{ '4.3' | floor }}"
+    assert_raises(Liquid::FloatDomainError) do
+      assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | floor }}"
+    end
+
+    assert_template_result "5", "{{ price | floor }}", 'price' => NumberLikeThing.new(5.4)
+  end
+
+  def test_at_most
+    assert_template_result "4", "{{ 5 | at_most:4 }}"
+    assert_template_result "5", "{{ 5 | at_most:5 }}"
+    assert_template_result "5", "{{ 5 | at_most:6 }}"
+
+    assert_template_result "4.5", "{{ 4.5 | at_most:5 }}"
+    assert_template_result "5", "{{ width | at_most:5 }}", 'width' => NumberLikeThing.new(6)
+    assert_template_result "4", "{{ width | at_most:5 }}", 'width' => NumberLikeThing.new(4)
+    assert_template_result "4", "{{ 5 | at_most: width }}", 'width' => NumberLikeThing.new(4)
+  end
+
+  def test_at_least
+    assert_template_result "5", "{{ 5 | at_least:4 }}"
+    assert_template_result "5", "{{ 5 | at_least:5 }}"
+    assert_template_result "6", "{{ 5 | at_least:6 }}"
+
+    assert_template_result "5", "{{ 4.5 | at_least:5 }}"
+    assert_template_result "6", "{{ width | at_least:5 }}", 'width' => NumberLikeThing.new(6)
+    assert_template_result "5", "{{ width | at_least:5 }}", 'width' => NumberLikeThing.new(4)
+    assert_template_result "6", "{{ 5 | at_least: width }}", 'width' => NumberLikeThing.new(6)
+  end
+
+  def test_append
+    assigns = { 'a' => 'bc', 'b' => 'd' }
+    assert_template_result('bcd', "{{ a | append: 'd'}}", assigns)
+    assert_template_result('bcd', "{{ a | append: b}}", assigns)
+  end
+
+  def test_concat
+    assert_equal [1, 2, 3, 4], @filters.concat([1, 2], [3, 4])
+    assert_equal [1, 2, 'a'],  @filters.concat([1, 2], ['a'])
+    assert_equal [1, 2, 10],   @filters.concat([1, 2], [10])
+
+    assert_raises(Liquid::ArgumentError, "concat filter requires an array argument") do
+      @filters.concat([1, 2], 10)
+    end
+  end
+
+  def test_prepend
+    assigns = { 'a' => 'bc', 'b' => 'a' }
+    assert_template_result('abc', "{{ a | prepend: 'a'}}", assigns)
+    assert_template_result('abc', "{{ a | prepend: b}}", assigns)
+  end
+
+  def test_default
+    assert_equal "foo", @filters.default("foo", "bar")
+    assert_equal "bar", @filters.default(nil, "bar")
+    assert_equal "bar", @filters.default("", "bar")
+    assert_equal "bar", @filters.default(false, "bar")
+    assert_equal "bar", @filters.default([], "bar")
+    assert_equal "bar", @filters.default({}, "bar")
+  end
+
+  def test_cannot_access_private_methods
+    assert_template_result('a', "{{ 'a' | to_number }}")
+  end
+
+  def test_date_raises_nothing
+    assert_template_result('', "{{ '' | date: '%D' }}")
+    assert_template_result('abc', "{{ 'abc' | date: '%D' }}")
+  end
+
+  def test_where
+    input = [
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "beta", "ok" => false },
+      { "handle" => "gamma", "ok" => false },
+      { "handle" => "delta", "ok" => true }
+    ]
+
+    expectation = [
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "delta", "ok" => true }
+    ]
+
+    assert_equal expectation, @filters.where(input, "ok", true)
+    assert_equal expectation, @filters.where(input, "ok")
+  end
+
+  def test_where_no_key_set
+    input = [
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "beta" },
+      { "handle" => "gamma" },
+      { "handle" => "delta", "ok" => true }
+    ]
+
+    expectation = [
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "delta", "ok" => true }
+    ]
+
+    assert_equal expectation, @filters.where(input, "ok", true)
+    assert_equal expectation, @filters.where(input, "ok")
+  end
+
+  def test_where_non_array_map_input
+    assert_equal [{ "a" => "ok" }], @filters.where({ "a" => "ok" }, "a", "ok")
+    assert_equal [], @filters.where({ "a" => "not ok" }, "a", "ok")
+  end
+
+  def test_where_indexable_but_non_map_value
+    assert_raises(Liquid::ArgumentError) { @filters.where(1, "ok", true) }
+    assert_raises(Liquid::ArgumentError) { @filters.where(1, "ok") }
+  end
+
+  def test_where_non_boolean_value
+    input = [
+      { "message" => "Bonjour!", "language" => "French" },
+      { "message" => "Hello!", "language" => "English" },
+      { "message" => "Hallo!", "language" => "German" }
+    ]
+
+    assert_equal [{ "message" => "Bonjour!", "language" => "French" }], @filters.where(input, "language", "French")
+    assert_equal [{ "message" => "Hallo!", "language" => "German" }], @filters.where(input, "language", "German")
+    assert_equal [{ "message" => "Hello!", "language" => "English" }], @filters.where(input, "language", "English")
+  end
+
+  def test_where_array_of_only_unindexable_values
+    assert_nil @filters.where([nil], "ok", true)
+    assert_nil @filters.where([nil], "ok")
+  end
+
+  def test_where_no_target_value
+    input = [
+      { "foo" => false },
+      { "foo" => true },
+      { "foo" => "for sure" },
+      { "bar" => true }
+    ]
+
+    assert_equal [{ "foo" => true }, { "foo" => "for sure" }], @filters.where(input, "foo")
+  end
+
+  private
+
+  def with_timezone(tz)
+    old_tz = ENV['TZ']
+    ENV['TZ'] = tz
+    yield
+  ensure
+    ENV['TZ'] = old_tz
+  end
+end # StandardFiltersTest

bin/gems/liquid-4.0.4/test/integration/tags/break_tag_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class BreakTagTest < Minitest::Test
+  include Liquid
+
+  # tests that no weird errors are raised if break is called outside of a
+  # block
+  def test_break_with_no_block
+    assigns = { 'i' => 1 }
+    markup = '{% break %}'
+    expected = ''
+
+    assert_template_result(expected, markup, assigns)
+  end
+end

bin/gems/liquid-4.0.4/test/integration/tags/continue_tag_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class ContinueTagTest < Minitest::Test
+  include Liquid
+
+  # tests that no weird errors are raised if continue is called outside of a
+  # block
+  def test_continue_with_no_block
+    assigns = {}
+    markup = '{% continue %}'
+    expected = ''
+
+    assert_template_result(expected, markup, assigns)
+  end
+end

bin/gems/liquid-4.0.4/test/integration/tags/for_tag_test.rb

@@ -0,0 +1,410 @@
+require 'test_helper'
+
+class ThingWithValue < Liquid::Drop
+  def value
+    3
+  end
+end
+
+class ForTagTest < Minitest::Test
+  include Liquid
+
+  def test_for
+    assert_template_result(' yo  yo  yo  yo ', '{%for item in array%} yo {%endfor%}', 'array' => [1, 2, 3, 4])
+    assert_template_result('yoyo', '{%for item in array%}yo{%endfor%}', 'array' => [1, 2])
+    assert_template_result(' yo ', '{%for item in array%} yo {%endfor%}', 'array' => [1])
+    assert_template_result('', '{%for item in array%}{%endfor%}', 'array' => [1, 2])
+    expected = <<HERE
+
+  yo
+
+  yo
+
+  yo
+
+HERE
+    template = <<HERE
+{%for item in array%}
+  yo
+{%endfor%}
+HERE
+    assert_template_result(expected, template, 'array' => [1, 2, 3])
+  end
+
+  def test_for_reversed
+    assigns = { 'array' => [ 1, 2, 3] }
+    assert_template_result('321', '{%for item in array reversed %}{{item}}{%endfor%}', assigns)
+  end
+
+  def test_for_with_range
+    assert_template_result(' 1  2  3 ', '{%for item in (1..3) %} {{item}} {%endfor%}')
+
+    assert_raises(Liquid::ArgumentError) do
+      Template.parse('{% for i in (a..2) %}{% endfor %}').render!("a" => [1, 2])
+    end
+
+    assert_template_result(' 0  1  2  3 ', '{% for item in (a..3) %} {{item}} {% endfor %}', "a" => "invalid integer")
+  end
+
+  def test_for_with_variable_range
+    assert_template_result(' 1  2  3 ', '{%for item in (1..foobar) %} {{item}} {%endfor%}', "foobar" => 3)
+  end
+
+  def test_for_with_hash_value_range
+    foobar = { "value" => 3 }
+    assert_template_result(' 1  2  3 ', '{%for item in (1..foobar.value) %} {{item}} {%endfor%}', "foobar" => foobar)
+  end
+
+  def test_for_with_drop_value_range
+    foobar = ThingWithValue.new
+    assert_template_result(' 1  2  3 ', '{%for item in (1..foobar.value) %} {{item}} {%endfor%}', "foobar" => foobar)
+  end
+
+  def test_for_with_variable
+    assert_template_result(' 1  2  3 ', '{%for item in array%} {{item}} {%endfor%}', 'array' => [1, 2, 3])
+    assert_template_result('123', '{%for item in array%}{{item}}{%endfor%}', 'array' => [1, 2, 3])
+    assert_template_result('123', '{% for item in array %}{{item}}{% endfor %}', 'array' => [1, 2, 3])
+    assert_template_result('abcd', '{%for item in array%}{{item}}{%endfor%}', 'array' => ['a', 'b', 'c', 'd'])
+    assert_template_result('a b c', '{%for item in array%}{{item}}{%endfor%}', 'array' => ['a', ' ', 'b', ' ', 'c'])
+    assert_template_result('abc', '{%for item in array%}{{item}}{%endfor%}', 'array' => ['a', '', 'b', '', 'c'])
+  end
+
+  def test_for_helpers
+    assigns = { 'array' => [1, 2, 3] }
+    assert_template_result(' 1/3  2/3  3/3 ',
+      '{%for item in array%} {{forloop.index}}/{{forloop.length}} {%endfor%}',
+      assigns)
+    assert_template_result(' 1  2  3 ', '{%for item in array%} {{forloop.index}} {%endfor%}', assigns)
+    assert_template_result(' 0  1  2 ', '{%for item in array%} {{forloop.index0}} {%endfor%}', assigns)
+    assert_template_result(' 2  1  0 ', '{%for item in array%} {{forloop.rindex0}} {%endfor%}', assigns)
+    assert_template_result(' 3  2  1 ', '{%for item in array%} {{forloop.rindex}} {%endfor%}', assigns)
+    assert_template_result(' true  false  false ', '{%for item in array%} {{forloop.first}} {%endfor%}', assigns)
+    assert_template_result(' false  false  true ', '{%for item in array%} {{forloop.last}} {%endfor%}', assigns)
+  end
+
+  def test_for_and_if
+    assigns = { 'array' => [1, 2, 3] }
+    assert_template_result('+--',
+      '{%for item in array%}{% if forloop.first %}+{% else %}-{% endif %}{%endfor%}',
+      assigns)
+  end
+
+  def test_for_else
+    assert_template_result('+++', '{%for item in array%}+{%else%}-{%endfor%}', 'array' => [1, 2, 3])
+    assert_template_result('-',   '{%for item in array%}+{%else%}-{%endfor%}', 'array' => [])
+    assert_template_result('-',   '{%for item in array%}+{%else%}-{%endfor%}', 'array' => nil)
+  end
+
+  def test_limiting
+    assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
+    assert_template_result('12', '{%for i in array limit:2 %}{{ i }}{%endfor%}', assigns)
+    assert_template_result('1234', '{%for i in array limit:4 %}{{ i }}{%endfor%}', assigns)
+    assert_template_result('3456', '{%for i in array limit:4 offset:2 %}{{ i }}{%endfor%}', assigns)
+    assert_template_result('3456', '{%for i in array limit: 4 offset: 2 %}{{ i }}{%endfor%}', assigns)
+  end
+
+  def test_dynamic_variable_limiting
+    assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
+    assigns['limit'] = 2
+    assigns['offset'] = 2
+
+    assert_template_result('34', '{%for i in array limit: limit offset: offset %}{{ i }}{%endfor%}', assigns)
+  end
+
+  def test_nested_for
+    assigns = { 'array' => [[1, 2], [3, 4], [5, 6]] }
+    assert_template_result('123456', '{%for item in array%}{%for i in item%}{{ i }}{%endfor%}{%endfor%}', assigns)
+  end
+
+  def test_offset_only
+    assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
+    assert_template_result('890', '{%for i in array offset:7 %}{{ i }}{%endfor%}', assigns)
+  end
+
+  def test_pause_resume
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
+    markup = <<-MKUP
+      {%for i in array.items limit: 3 %}{{i}}{%endfor%}
+      next
+      {%for i in array.items offset:continue limit: 3 %}{{i}}{%endfor%}
+      next
+      {%for i in array.items offset:continue limit: 3 %}{{i}}{%endfor%}
+      MKUP
+    expected = <<-XPCTD
+      123
+      next
+      456
+      next
+      789
+      XPCTD
+    assert_template_result(expected, markup, assigns)
+  end
+
+  def test_pause_resume_limit
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
+    markup = <<-MKUP
+      {%for i in array.items limit:3 %}{{i}}{%endfor%}
+      next
+      {%for i in array.items offset:continue limit:3 %}{{i}}{%endfor%}
+      next
+      {%for i in array.items offset:continue limit:1 %}{{i}}{%endfor%}
+      MKUP
+    expected = <<-XPCTD
+      123
+      next
+      456
+      next
+      7
+      XPCTD
+    assert_template_result(expected, markup, assigns)
+  end
+
+  def test_pause_resume_big_limit
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
+    markup = <<-MKUP
+      {%for i in array.items limit:3 %}{{i}}{%endfor%}
+      next
+      {%for i in array.items offset:continue limit:3 %}{{i}}{%endfor%}
+      next
+      {%for i in array.items offset:continue limit:1000 %}{{i}}{%endfor%}
+      MKUP
+    expected = <<-XPCTD
+      123
+      next
+      456
+      next
+      7890
+      XPCTD
+    assert_template_result(expected, markup, assigns)
+  end
+
+  def test_pause_resume_big_offset
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
+    markup = '{%for i in array.items limit:3 %}{{i}}{%endfor%}
+      next
+      {%for i in array.items offset:continue limit:3 %}{{i}}{%endfor%}
+      next
+      {%for i in array.items offset:continue limit:3 offset:1000 %}{{i}}{%endfor%}'
+    expected = '123
+      next
+      456
+      next
+      '
+    assert_template_result(expected, markup, assigns)
+  end
+
+  def test_for_with_break
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] } }
+
+    markup = '{% for i in array.items %}{% break %}{% endfor %}'
+    expected = ""
+    assert_template_result(expected, markup, assigns)
+
+    markup = '{% for i in array.items %}{{ i }}{% break %}{% endfor %}'
+    expected = "1"
+    assert_template_result(expected, markup, assigns)
+
+    markup = '{% for i in array.items %}{% break %}{{ i }}{% endfor %}'
+    expected = ""
+    assert_template_result(expected, markup, assigns)
+
+    markup = '{% for i in array.items %}{{ i }}{% if i > 3 %}{% break %}{% endif %}{% endfor %}'
+    expected = "1234"
+    assert_template_result(expected, markup, assigns)
+
+    # tests to ensure it only breaks out of the local for loop
+    # and not all of them.
+    assigns = { 'array' => [[1, 2], [3, 4], [5, 6]] }
+    markup = '{% for item in array %}' \
+               '{% for i in item %}' \
+                 '{% if i == 1 %}' \
+                   '{% break %}' \
+                 '{% endif %}' \
+                 '{{ i }}' \
+               '{% endfor %}' \
+             '{% endfor %}'
+    expected = '3456'
+    assert_template_result(expected, markup, assigns)
+
+    # test break does nothing when unreached
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }
+    markup = '{% for i in array.items %}{% if i == 9999 %}{% break %}{% endif %}{{ i }}{% endfor %}'
+    expected = '12345'
+    assert_template_result(expected, markup, assigns)
+  end
+
+  def test_for_with_continue
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }
+
+    markup = '{% for i in array.items %}{% continue %}{% endfor %}'
+    expected = ""
+    assert_template_result(expected, markup, assigns)
+
+    markup = '{% for i in array.items %}{{ i }}{% continue %}{% endfor %}'
+    expected = "12345"
+    assert_template_result(expected, markup, assigns)
+
+    markup = '{% for i in array.items %}{% continue %}{{ i }}{% endfor %}'
+    expected = ""
+    assert_template_result(expected, markup, assigns)
+
+    markup = '{% for i in array.items %}{% if i > 3 %}{% continue %}{% endif %}{{ i }}{% endfor %}'
+    expected = "123"
+    assert_template_result(expected, markup, assigns)
+
+    markup = '{% for i in array.items %}{% if i == 3 %}{% continue %}{% else %}{{ i }}{% endif %}{% endfor %}'
+    expected = "1245"
+    assert_template_result(expected, markup, assigns)
+
+    # tests to ensure it only continues the local for loop and not all of them.
+    assigns = { 'array' => [[1, 2], [3, 4], [5, 6]] }
+    markup = '{% for item in array %}' \
+               '{% for i in item %}' \
+                 '{% if i == 1 %}' \
+                   '{% continue %}' \
+                 '{% endif %}' \
+                 '{{ i }}' \
+               '{% endfor %}' \
+             '{% endfor %}'
+    expected = '23456'
+    assert_template_result(expected, markup, assigns)
+
+    # test continue does nothing when unreached
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }
+    markup = '{% for i in array.items %}{% if i == 9999 %}{% continue %}{% endif %}{{ i }}{% endfor %}'
+    expected = '12345'
+    assert_template_result(expected, markup, assigns)
+  end
+
+  def test_for_tag_string
+    # ruby 1.8.7 "String".each => Enumerator with single "String" element.
+    # ruby 1.9.3 no longer supports .each on String though we mimic
+    # the functionality for backwards compatibility
+
+    assert_template_result('test string',
+      '{%for val in string%}{{val}}{%endfor%}',
+      'string' => "test string")
+
+    assert_template_result('test string',
+      '{%for val in string limit:1%}{{val}}{%endfor%}',
+      'string' => "test string")
+
+    assert_template_result('val-string-1-1-0-1-0-true-true-test string',
+      '{%for val in string%}' \
+      '{{forloop.name}}-' \
+      '{{forloop.index}}-' \
+      '{{forloop.length}}-' \
+      '{{forloop.index0}}-' \
+      '{{forloop.rindex}}-' \
+      '{{forloop.rindex0}}-' \
+      '{{forloop.first}}-' \
+      '{{forloop.last}}-' \
+      '{{val}}{%endfor%}',
+      'string' => "test string")
+  end
+
+  def test_for_parentloop_references_parent_loop
+    assert_template_result('1.1 1.2 1.3 2.1 2.2 2.3 ',
+      '{% for inner in outer %}{% for k in inner %}' \
+      '{{ forloop.parentloop.index }}.{{ forloop.index }} ' \
+      '{% endfor %}{% endfor %}',
+      'outer' => [[1, 1, 1], [1, 1, 1]])
+  end
+
+  def test_for_parentloop_nil_when_not_present
+    assert_template_result('.1 .2 ',
+      '{% for inner in outer %}' \
+      '{{ forloop.parentloop.index }}.{{ forloop.index }} ' \
+      '{% endfor %}',
+      'outer' => [[1, 1, 1], [1, 1, 1]])
+  end
+
+  def test_inner_for_over_empty_input
+    assert_template_result 'oo', '{% for a in (1..2) %}o{% for b in empty %}{% endfor %}{% endfor %}'
+  end
+
+  def test_blank_string_not_iterable
+    assert_template_result('', "{% for char in characters %}I WILL NOT BE OUTPUT{% endfor %}", 'characters' => '')
+  end
+
+  def test_bad_variable_naming_in_for_loop
+    assert_raises(Liquid::SyntaxError) do
+      Liquid::Template.parse('{% for a/b in x %}{% endfor %}')
+    end
+  end
+
+  def test_spacing_with_variable_naming_in_for_loop
+    expected = '12345'
+    template = '{% for       item   in   items %}{{item}}{% endfor %}'
+    assigns  = { 'items' => [1, 2, 3, 4, 5] }
+    assert_template_result(expected, template, assigns)
+  end
+
+  class LoaderDrop < Liquid::Drop
+    attr_accessor :each_called, :load_slice_called
+
+    def initialize(data)
+      @data = data
+    end
+
+    def each
+      @each_called = true
+      @data.each { |el| yield el }
+    end
+
+    def load_slice(from, to)
+      @load_slice_called = true
+      @data[(from..to - 1)]
+    end
+  end
+
+  def test_iterate_with_each_when_no_limit_applied
+    loader = LoaderDrop.new([1, 2, 3, 4, 5])
+    assigns = { 'items' => loader }
+    expected = '12345'
+    template = '{% for item in items %}{{item}}{% endfor %}'
+    assert_template_result(expected, template, assigns)
+    assert loader.each_called
+    assert !loader.load_slice_called
+  end
+
+  def test_iterate_with_load_slice_when_limit_applied
+    loader = LoaderDrop.new([1, 2, 3, 4, 5])
+    assigns = { 'items' => loader }
+    expected = '1'
+    template = '{% for item in items limit:1 %}{{item}}{% endfor %}'
+    assert_template_result(expected, template, assigns)
+    assert !loader.each_called
+    assert loader.load_slice_called
+  end
+
+  def test_iterate_with_load_slice_when_limit_and_offset_applied
+    loader = LoaderDrop.new([1, 2, 3, 4, 5])
+    assigns = { 'items' => loader }
+    expected = '34'
+    template = '{% for item in items offset:2 limit:2 %}{{item}}{% endfor %}'
+    assert_template_result(expected, template, assigns)
+    assert !loader.each_called
+    assert loader.load_slice_called
+  end
+
+  def test_iterate_with_load_slice_returns_same_results_as_without
+    loader = LoaderDrop.new([1, 2, 3, 4, 5])
+    loader_assigns = { 'items' => loader }
+    array_assigns = { 'items' => [1, 2, 3, 4, 5] }
+    expected = '34'
+    template = '{% for item in items offset:2 limit:2 %}{{item}}{% endfor %}'
+    assert_template_result(expected, template, loader_assigns)
+    assert_template_result(expected, template, array_assigns)
+  end
+
+  def test_for_cleans_up_registers
+    context = Context.new(ErrorDrop.new)
+
+    assert_raises(StandardError) do
+      Liquid::Template.parse('{% for i in (1..2) %}{{ standard_error }}{% endfor %}').render!(context)
+    end
+
+    assert context.registers[:for_stack].empty?
+  end
+end

bin/gems/liquid-4.0.4/test/integration/tags/if_else_tag_test.rb

@@ -0,0 +1,188 @@
+require 'test_helper'
+
+class IfElseTagTest < Minitest::Test
+  include Liquid
+
+  def test_if
+    assert_template_result('  ', ' {% if false %} this text should not go into the output {% endif %} ')
+    assert_template_result('  this text should go into the output  ',
+      ' {% if true %} this text should go into the output {% endif %} ')
+    assert_template_result('  you rock ?', '{% if false %} you suck {% endif %} {% if true %} you rock {% endif %}?')
+  end
+
+  def test_literal_comparisons
+    assert_template_result(' NO ', '{% assign v = false %}{% if v %} YES {% else %} NO {% endif %}')
+    assert_template_result(' YES ', '{% assign v = nil %}{% if v == nil %} YES {% else %} NO {% endif %}')
+  end
+
+  def test_if_else
+    assert_template_result(' YES ', '{% if false %} NO {% else %} YES {% endif %}')
+    assert_template_result(' YES ', '{% if true %} YES {% else %} NO {% endif %}')
+    assert_template_result(' YES ', '{% if "foo" %} YES {% else %} NO {% endif %}')
+  end
+
+  def test_if_boolean
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => true)
+  end
+
+  def test_if_or
+    assert_template_result(' YES ', '{% if a or b %} YES {% endif %}', 'a' => true, 'b' => true)
+    assert_template_result(' YES ', '{% if a or b %} YES {% endif %}', 'a' => true, 'b' => false)
+    assert_template_result(' YES ', '{% if a or b %} YES {% endif %}', 'a' => false, 'b' => true)
+    assert_template_result('',      '{% if a or b %} YES {% endif %}', 'a' => false, 'b' => false)
+
+    assert_template_result(' YES ', '{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => true)
+    assert_template_result('',      '{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => false)
+  end
+
+  def test_if_or_with_operators
+    assert_template_result(' YES ', '{% if a == true or b == true %} YES {% endif %}', 'a' => true, 'b' => true)
+    assert_template_result(' YES ', '{% if a == true or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
+    assert_template_result('', '{% if a == false or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
+  end
+
+  def test_comparison_of_strings_containing_and_or_or
+    awful_markup = "a == 'and' and b == 'or' and c == 'foo and bar' and d == 'bar or baz' and e == 'foo' and foo and bar"
+    assigns = { 'a' => 'and', 'b' => 'or', 'c' => 'foo and bar', 'd' => 'bar or baz', 'e' => 'foo', 'foo' => true, 'bar' => true }
+    assert_template_result(' YES ', "{% if #{awful_markup} %} YES {% endif %}", assigns)
+  end
+
+  def test_comparison_of_expressions_starting_with_and_or_or
+    assigns = { 'order' => { 'items_count' => 0 }, 'android' => { 'name' => 'Roy' } }
+    assert_template_result("YES",
+      "{% if android.name == 'Roy' %}YES{% endif %}",
+      assigns)
+    assert_template_result("YES",
+      "{% if order.items_count == 0 %}YES{% endif %}",
+      assigns)
+  end
+
+  def test_if_and
+    assert_template_result(' YES ', '{% if true and true %} YES {% endif %}')
+    assert_template_result('', '{% if false and true %} YES {% endif %}')
+    assert_template_result('', '{% if false and true %} YES {% endif %}')
+  end
+
+  def test_hash_miss_generates_false
+    assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => {})
+  end
+
+  def test_if_from_variable
+    assert_template_result('', '{% if var %} NO {% endif %}', 'var' => false)
+    assert_template_result('', '{% if var %} NO {% endif %}', 'var' => nil)
+    assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => { 'bar' => false })
+    assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => {})
+    assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => nil)
+    assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => true)
+
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => "text")
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => true)
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => 1)
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => {})
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => [])
+    assert_template_result(' YES ', '{% if "foo" %} YES {% endif %}')
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => true })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => "text" })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => 1 })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => {} })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => [] })
+
+    assert_template_result(' YES ', '{% if var %} NO {% else %} YES {% endif %}', 'var' => false)
+    assert_template_result(' YES ', '{% if var %} NO {% else %} YES {% endif %}', 'var' => nil)
+    assert_template_result(' YES ', '{% if var %} YES {% else %} NO {% endif %}', 'var' => true)
+    assert_template_result(' YES ', '{% if "foo" %} YES {% else %} NO {% endif %}', 'var' => "text")
+
+    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => { 'bar' => false })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => { 'bar' => true })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => { 'bar' => "text" })
+    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => { 'notbar' => true })
+    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => {})
+    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'notfoo' => { 'bar' => true })
+  end
+
+  def test_nested_if
+    assert_template_result('', '{% if false %}{% if false %} NO {% endif %}{% endif %}')
+    assert_template_result('', '{% if false %}{% if true %} NO {% endif %}{% endif %}')
+    assert_template_result('', '{% if true %}{% if false %} NO {% endif %}{% endif %}')
+    assert_template_result(' YES ', '{% if true %}{% if true %} YES {% endif %}{% endif %}')
+
+    assert_template_result(' YES ', '{% if true %}{% if true %} YES {% else %} NO {% endif %}{% else %} NO {% endif %}')
+    assert_template_result(' YES ', '{% if true %}{% if false %} NO {% else %} YES {% endif %}{% else %} NO {% endif %}')
+    assert_template_result(' YES ', '{% if false %}{% if true %} NO {% else %} NONO {% endif %}{% else %} YES {% endif %}')
+  end
+
+  def test_comparisons_on_null
+    assert_template_result('', '{% if null < 10 %} NO {% endif %}')
+    assert_template_result('', '{% if null <= 10 %} NO {% endif %}')
+    assert_template_result('', '{% if null >= 10 %} NO {% endif %}')
+    assert_template_result('', '{% if null > 10 %} NO {% endif %}')
+
+    assert_template_result('', '{% if 10 < null %} NO {% endif %}')
+    assert_template_result('', '{% if 10 <= null %} NO {% endif %}')
+    assert_template_result('', '{% if 10 >= null %} NO {% endif %}')
+    assert_template_result('', '{% if 10 > null %} NO {% endif %}')
+  end
+
+  def test_else_if
+    assert_template_result('0', '{% if 0 == 0 %}0{% elsif 1 == 1%}1{% else %}2{% endif %}')
+    assert_template_result('1', '{% if 0 != 0 %}0{% elsif 1 == 1%}1{% else %}2{% endif %}')
+    assert_template_result('2', '{% if 0 != 0 %}0{% elsif 1 != 1%}1{% else %}2{% endif %}')
+
+    assert_template_result('elsif', '{% if false %}if{% elsif true %}elsif{% endif %}')
+  end
+
+  def test_syntax_error_no_variable
+    assert_raises(SyntaxError){ assert_template_result('', '{% if jerry == 1 %}') }
+  end
+
+  def test_syntax_error_no_expression
+    assert_raises(SyntaxError) { assert_template_result('', '{% if %}') }
+  end
+
+  def test_if_with_custom_condition
+    original_op = Condition.operators['contains']
+    Condition.operators['contains'] = :[]
+
+    assert_template_result('yes', %({% if 'bob' contains 'o' %}yes{% endif %}))
+    assert_template_result('no', %({% if 'bob' contains 'f' %}yes{% else %}no{% endif %}))
+  ensure
+    Condition.operators['contains'] = original_op
+  end
+
+  def test_operators_are_ignored_unless_isolated
+    original_op = Condition.operators['contains']
+    Condition.operators['contains'] = :[]
+
+    assert_template_result('yes',
+      %({% if 'gnomeslab-and-or-liquid' contains 'gnomeslab-and-or-liquid' %}yes{% endif %}))
+  ensure
+    Condition.operators['contains'] = original_op
+  end
+
+  def test_operators_are_whitelisted
+    assert_raises(SyntaxError) do
+      assert_template_result('', %({% if 1 or throw or or 1 %}yes{% endif %}))
+    end
+  end
+
+  def test_multiple_conditions
+    tpl = "{% if a or b and c %}true{% else %}false{% endif %}"
+
+    tests = {
+      [true, true, true] => true,
+      [true, true, false] => true,
+      [true, false, true] => true,
+      [true, false, false] => true,
+      [false, true, true] => true,
+      [false, true, false] => false,
+      [false, false, true] => false,
+      [false, false, false] => false,
+    }
+
+    tests.each do |vals, expected|
+      a, b, c = vals
+      assigns = { 'a' => a, 'b' => b, 'c' => c }
+      assert_template_result expected.to_s, tpl, assigns, assigns.to_s
+    end
+  end
+end

bin/gems/liquid-4.0.4/test/integration/tags/include_tag_test.rb

@@ -0,0 +1,253 @@
+require 'test_helper'
+
+class TestFileSystem
+  def read_template_file(template_path)
+    case template_path
+    when "product"
+      "Product: {{ product.title }} "
+
+    when "locale_variables"
+      "Locale: {{echo1}} {{echo2}}"
+
+    when "variant"
+      "Variant: {{ variant.title }}"
+
+    when "nested_template"
+      "{% include 'header' %} {% include 'body' %} {% include 'footer' %}"
+
+    when "body"
+      "body {% include 'body_detail' %}"
+
+    when "nested_product_template"
+      "Product: {{ nested_product_template.title }} {%include 'details'%} "
+
+    when "recursively_nested_template"
+      "-{% include 'recursively_nested_template' %}"
+
+    when "pick_a_source"
+      "from TestFileSystem"
+
+    when 'assignments'
+      "{% assign foo = 'bar' %}"
+
+    when 'break'
+      "{% break %}"
+
+    else
+      template_path
+    end
+  end
+end
+
+class OtherFileSystem
+  def read_template_file(template_path)
+    'from OtherFileSystem'
+  end
+end
+
+class CountingFileSystem
+  attr_reader :count
+  def read_template_file(template_path)
+    @count ||= 0
+    @count += 1
+    'from CountingFileSystem'
+  end
+end
+
+class CustomInclude < Liquid::Tag
+  Syntax = /(#{Liquid::QuotedFragment}+)(\s+(?:with|for)\s+(#{Liquid::QuotedFragment}+))?/o
+
+  def initialize(tag_name, markup, tokens)
+    markup =~ Syntax
+    @template_name = $1
+    super
+  end
+
+  def parse(tokens)
+  end
+
+  def render(context)
+    @template_name[1..-2]
+  end
+end
+
+class IncludeTagTest < Minitest::Test
+  include Liquid
+
+  def setup
+    Liquid::Template.file_system = TestFileSystem.new
+  end
+
+  def test_include_tag_looks_for_file_system_in_registers_first
+    assert_equal 'from OtherFileSystem',
+      Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: OtherFileSystem.new })
+  end
+
+  def test_include_tag_with
+    assert_template_result "Product: Draft 151cm ",
+      "{% include 'product' with products[0] %}", "products" => [ { 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' } ]
+  end
+
+  def test_include_tag_with_default_name
+    assert_template_result "Product: Draft 151cm ",
+      "{% include 'product' %}", "product" => { 'title' => 'Draft 151cm' }
+  end
+
+  def test_include_tag_for
+    assert_template_result "Product: Draft 151cm Product: Element 155cm ",
+      "{% include 'product' for products %}", "products" => [ { 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' } ]
+  end
+
+  def test_include_tag_with_local_variables
+    assert_template_result "Locale: test123 ", "{% include 'locale_variables' echo1: 'test123' %}"
+  end
+
+  def test_include_tag_with_multiple_local_variables
+    assert_template_result "Locale: test123 test321",
+      "{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}"
+  end
+
+  def test_include_tag_with_multiple_local_variables_from_context
+    assert_template_result "Locale: test123 test321",
+      "{% include 'locale_variables' echo1: echo1, echo2: more_echos.echo2 %}",
+      'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321' }
+  end
+
+  def test_included_templates_assigns_variables
+    assert_template_result "bar", "{% include 'assignments' %}{{ foo }}"
+  end
+
+  def test_nested_include_tag
+    assert_template_result "body body_detail", "{% include 'body' %}"
+
+    assert_template_result "header body body_detail footer", "{% include 'nested_template' %}"
+  end
+
+  def test_nested_include_with_variable
+    assert_template_result "Product: Draft 151cm details ",
+      "{% include 'nested_product_template' with product %}", "product" => { "title" => 'Draft 151cm' }
+
+    assert_template_result "Product: Draft 151cm details Product: Element 155cm details ",
+      "{% include 'nested_product_template' for products %}", "products" => [{ "title" => 'Draft 151cm' }, { "title" => 'Element 155cm' }]
+  end
+
+  def test_recursively_included_template_does_not_produce_endless_loop
+    infinite_file_system = Class.new do
+      def read_template_file(template_path)
+        "-{% include 'loop' %}"
+      end
+    end
+
+    Liquid::Template.file_system = infinite_file_system.new
+
+    assert_raises(Liquid::StackLevelError) do
+      Template.parse("{% include 'loop' %}").render!
+    end
+  end
+
+  def test_dynamically_choosen_template
+    assert_template_result "Test123", "{% include template %}", "template" => 'Test123'
+    assert_template_result "Test321", "{% include template %}", "template" => 'Test321'
+
+    assert_template_result "Product: Draft 151cm ", "{% include template for product %}",
+      "template" => 'product', 'product' => { 'title' => 'Draft 151cm' }
+  end
+
+  def test_include_tag_caches_second_read_of_same_partial
+    file_system = CountingFileSystem.new
+    assert_equal 'from CountingFileSystemfrom CountingFileSystem',
+      Template.parse("{% include 'pick_a_source' %}{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system })
+    assert_equal 1, file_system.count
+  end
+
+  def test_include_tag_doesnt_cache_partials_across_renders
+    file_system = CountingFileSystem.new
+    assert_equal 'from CountingFileSystem',
+      Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system })
+    assert_equal 1, file_system.count
+
+    assert_equal 'from CountingFileSystem',
+      Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system })
+    assert_equal 2, file_system.count
+  end
+
+  def test_include_tag_within_if_statement
+    assert_template_result "foo_if_true", "{% if true %}{% include 'foo_if_true' %}{% endif %}"
+  end
+
+  def test_custom_include_tag
+    original_tag = Liquid::Template.tags['include']
+    Liquid::Template.tags['include'] = CustomInclude
+    begin
+      assert_equal "custom_foo",
+        Template.parse("{% include 'custom_foo' %}").render!
+    ensure
+      Liquid::Template.tags['include'] = original_tag
+    end
+  end
+
+  def test_custom_include_tag_within_if_statement
+    original_tag = Liquid::Template.tags['include']
+    Liquid::Template.tags['include'] = CustomInclude
+    begin
+      assert_equal "custom_foo_if_true",
+        Template.parse("{% if true %}{% include 'custom_foo_if_true' %}{% endif %}").render!
+    ensure
+      Liquid::Template.tags['include'] = original_tag
+    end
+  end
+
+  def test_does_not_add_error_in_strict_mode_for_missing_variable
+    Liquid::Template.file_system = TestFileSystem.new
+
+    a = Liquid::Template.parse(' {% include "nested_template" %}')
+    a.render!
+    assert_empty a.errors
+  end
+
+  def test_passing_options_to_included_templates
+    assert_raises(Liquid::SyntaxError) do
+      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).render!("template" => '{{ "X" || downcase }}')
+    end
+    assert_raises(Liquid::SyntaxError) do
+      Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:locale]).render!("template" => '{{ "X" || downcase }}')
+    end
+    with_error_mode(:lax) do
+      assert_equal 'x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:error_mode]).render!("template" => '{{ "X" || downcase }}')
+    end
+  end
+
+  def test_render_raise_argument_error_when_template_is_undefined
+    assert_raises(Liquid::ArgumentError) do
+      template = Liquid::Template.parse('{% include undefined_variable %}')
+      template.render!
+    end
+    assert_raises(Liquid::ArgumentError) do
+      template = Liquid::Template.parse('{% include nil %}')
+      template.render!
+    end
+  end
+
+  def test_including_via_variable_value
+    assert_template_result "from TestFileSystem", "{% assign page = 'pick_a_source' %}{% include page %}"
+
+    assert_template_result "Product: Draft 151cm ", "{% assign page = 'product' %}{% include page %}", "product" => { 'title' => 'Draft 151cm' }
+
+    assert_template_result "Product: Draft 151cm ", "{% assign page = 'product' %}{% include page for foo %}", "foo" => { 'title' => 'Draft 151cm' }
+  end
+
+  def test_including_with_strict_variables
+    template = Liquid::Template.parse("{% include 'simple' %}", error_mode: :warn)
+    template.render(nil, strict_variables: true)
+
+    assert_equal [], template.errors
+  end
+
+  def test_break_through_include
+    assert_template_result "1", "{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}"
+    assert_template_result "1", "{% for i in (1..3) %}{{ i }}{% include 'break' %}{{ i }}{% endfor %}"
+  end
+end # IncludeTagTest

bin/gems/liquid-4.0.4/test/integration/tags/increment_tag_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class IncrementTagTest < Minitest::Test
+  include Liquid
+
+  def test_inc
+    assert_template_result('0', '{%increment port %}', {})
+    assert_template_result('0 1', '{%increment port %} {%increment port%}', {})
+    assert_template_result('0 0 1 2 1',
+      '{%increment port %} {%increment starboard%} ' \
+      '{%increment port %} {%increment port%} ' \
+      '{%increment starboard %}', {})
+  end
+
+  def test_dec
+    assert_template_result('9', '{%decrement port %}', { 'port' => 10 })
+    assert_template_result('-1 -2', '{%decrement port %} {%decrement port%}', {})
+    assert_template_result('1 5 2 2 5',
+      '{%increment port %} {%increment starboard%} ' \
+      '{%increment port %} {%decrement port%} ' \
+      '{%decrement starboard %}', { 'port' => 1, 'starboard' => 5 })
+  end
+end

bin/gems/liquid-4.0.4/test/integration/tags/raw_tag_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class RawTagTest < Minitest::Test
+  include Liquid
+
+  def test_tag_in_raw
+    assert_template_result '{% comment %} test {% endcomment %}',
+      '{% raw %}{% comment %} test {% endcomment %}{% endraw %}'
+  end
+
+  def test_output_in_raw
+    assert_template_result '{{ test }}', '{% raw %}{{ test }}{% endraw %}'
+  end
+
+  def test_open_tag_in_raw
+    assert_template_result ' Foobar {% invalid ', '{% raw %} Foobar {% invalid {% endraw %}'
+    assert_template_result ' Foobar invalid %} ', '{% raw %} Foobar invalid %} {% endraw %}'
+    assert_template_result ' Foobar {{ invalid ', '{% raw %} Foobar {{ invalid {% endraw %}'
+    assert_template_result ' Foobar invalid }} ', '{% raw %} Foobar invalid }} {% endraw %}'
+    assert_template_result ' Foobar {% invalid {% {% endraw ', '{% raw %} Foobar {% invalid {% {% endraw {% endraw %}'
+    assert_template_result ' Foobar {% {% {% ', '{% raw %} Foobar {% {% {% {% endraw %}'
+    assert_template_result ' test {% raw %} {% endraw %}', '{% raw %} test {% raw %} {% {% endraw %}endraw %}'
+    assert_template_result ' Foobar {{ invalid 1', '{% raw %} Foobar {{ invalid {% endraw %}{{ 1 }}'
+  end
+
+  def test_invalid_raw
+    assert_match_syntax_error(/tag was never closed/, '{% raw %} foo')
+    assert_match_syntax_error(/Valid syntax/, '{% raw } foo {% endraw %}')
+    assert_match_syntax_error(/Valid syntax/, '{% raw } foo %}{% endraw %}')
+  end
+end

bin/gems/liquid-4.0.4/test/integration/tags/standard_tag_test.rb

@@ -0,0 +1,296 @@
+require 'test_helper'
+
+class StandardTagTest < Minitest::Test
+  include Liquid
+
+  def test_no_transform
+    assert_template_result('this text should come out of the template without change...',
+      'this text should come out of the template without change...')
+
+    assert_template_result('blah', 'blah')
+    assert_template_result('<blah>', '<blah>')
+    assert_template_result('|,.:', '|,.:')
+    assert_template_result('', '')
+
+    text = %(this shouldnt see any transformation either but has multiple lines
+              as you can clearly see here ...)
+    assert_template_result(text, text)
+  end
+
+  def test_has_a_block_which_does_nothing
+    assert_template_result(%(the comment block should be removed  .. right?),
+      %(the comment block should be removed {%comment%} be gone.. {%endcomment%} .. right?))
+
+    assert_template_result('', '{%comment%}{%endcomment%}')
+    assert_template_result('', '{%comment%}{% endcomment %}')
+    assert_template_result('', '{% comment %}{%endcomment%}')
+    assert_template_result('', '{% comment %}{% endcomment %}')
+    assert_template_result('', '{%comment%}comment{%endcomment%}')
+    assert_template_result('', '{% comment %}comment{% endcomment %}')
+    assert_template_result('', '{% comment %} 1 {% comment %} 2 {% endcomment %} 3 {% endcomment %}')
+
+    assert_template_result('', '{%comment%}{%blabla%}{%endcomment%}')
+    assert_template_result('', '{% comment %}{% blabla %}{% endcomment %}')
+    assert_template_result('', '{%comment%}{% endif %}{%endcomment%}')
+    assert_template_result('', '{% comment %}{% endwhatever %}{% endcomment %}')
+    assert_template_result('', '{% comment %}{% raw %} {{%%%%}}  }} { {% endcomment %} {% comment {% endraw %} {% endcomment %}')
+
+    assert_template_result('foobar', 'foo{%comment%}comment{%endcomment%}bar')
+    assert_template_result('foobar', 'foo{% comment %}comment{% endcomment %}bar')
+    assert_template_result('foobar', 'foo{%comment%} comment {%endcomment%}bar')
+    assert_template_result('foobar', 'foo{% comment %} comment {% endcomment %}bar')
+
+    assert_template_result('foo  bar', 'foo {%comment%} {%endcomment%} bar')
+    assert_template_result('foo  bar', 'foo {%comment%}comment{%endcomment%} bar')
+    assert_template_result('foo  bar', 'foo {%comment%} comment {%endcomment%} bar')
+
+    assert_template_result('foobar', 'foo{%comment%}
+                                     {%endcomment%}bar')
+  end
+
+  def test_hyphenated_assign
+    assigns = { 'a-b' => '1' }
+    assert_template_result('a-b:1 a-b:2', 'a-b:{{a-b}} {%assign a-b = 2 %}a-b:{{a-b}}', assigns)
+  end
+
+  def test_assign_with_colon_and_spaces
+    assigns = { 'var' => { 'a:b c' => { 'paged' => '1' } } }
+    assert_template_result('var2: 1', '{%assign var2 = var["a:b c"].paged %}var2: {{var2}}', assigns)
+  end
+
+  def test_capture
+    assigns = { 'var' => 'content' }
+    assert_template_result('content foo content foo ',
+      '{{ var2 }}{% capture var2 %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
+      assigns)
+  end
+
+  def test_capture_detects_bad_syntax
+    assert_raises(SyntaxError) do
+      assert_template_result('content foo content foo ',
+        '{{ var2 }}{% capture %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
+        { 'var' => 'content' })
+    end
+  end
+
+  def test_case
+    assigns = { 'condition' => 2 }
+    assert_template_result(' its 2 ',
+      '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
+      assigns)
+
+    assigns = { 'condition' => 1 }
+    assert_template_result(' its 1 ',
+      '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
+      assigns)
+
+    assigns = { 'condition' => 3 }
+    assert_template_result('',
+      '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
+      assigns)
+
+    assigns = { 'condition' => "string here" }
+    assert_template_result(' hit ',
+      '{% case condition %}{% when "string here" %} hit {% endcase %}',
+      assigns)
+
+    assigns = { 'condition' => "bad string here" }
+    assert_template_result('',
+      '{% case condition %}{% when "string here" %} hit {% endcase %}',\
+      assigns)
+  end
+
+  def test_case_with_else
+    assigns = { 'condition' => 5 }
+    assert_template_result(' hit ',
+      '{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
+      assigns)
+
+    assigns = { 'condition' => 6 }
+    assert_template_result(' else ',
+      '{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
+      assigns)
+
+    assigns = { 'condition' => 6 }
+    assert_template_result(' else ',
+      '{% case condition %} {% when 5 %} hit {% else %} else {% endcase %}',
+      assigns)
+  end
+
+  def test_case_on_size
+    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [])
+    assert_template_result('1', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1])
+    assert_template_result('2', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1])
+    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1, 1])
+    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1, 1, 1])
+    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1, 1, 1, 1])
+  end
+
+  def test_case_on_size_with_else
+    assert_template_result('else',
+      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+      'a' => [])
+
+    assert_template_result('1',
+      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+      'a' => [1])
+
+    assert_template_result('2',
+      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+      'a' => [1, 1])
+
+    assert_template_result('else',
+      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+      'a' => [1, 1, 1])
+
+    assert_template_result('else',
+      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+      'a' => [1, 1, 1, 1])
+
+    assert_template_result('else',
+      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+      'a' => [1, 1, 1, 1, 1])
+  end
+
+  def test_case_on_length_with_else
+    assert_template_result('else',
+      '{% case a.empty? %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
+      {})
+
+    assert_template_result('false',
+      '{% case false %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
+      {})
+
+    assert_template_result('true',
+      '{% case true %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
+      {})
+
+    assert_template_result('else',
+      '{% case NULL %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
+      {})
+  end
+
+  def test_assign_from_case
+    # Example from the shopify forums
+    code = "{% case collection.handle %}{% when 'menswear-jackets' %}{% assign ptitle = 'menswear' %}{% when 'menswear-t-shirts' %}{% assign ptitle = 'menswear' %}{% else %}{% assign ptitle = 'womenswear' %}{% endcase %}{{ ptitle }}"
+    template = Liquid::Template.parse(code)
+    assert_equal "menswear",   template.render!("collection" => { 'handle' => 'menswear-jackets' })
+    assert_equal "menswear",   template.render!("collection" => { 'handle' => 'menswear-t-shirts' })
+    assert_equal "womenswear", template.render!("collection" => { 'handle' => 'x' })
+    assert_equal "womenswear", template.render!("collection" => { 'handle' => 'y' })
+    assert_equal "womenswear", template.render!("collection" => { 'handle' => 'z' })
+  end
+
+  def test_case_when_or
+    code = '{% case condition %}{% when 1 or 2 or 3 %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 2 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 3 })
+    assert_template_result(' its 4 ', code, { 'condition' => 4 })
+    assert_template_result('', code, { 'condition' => 5 })
+
+    code = '{% case condition %}{% when 1 or "string" or null %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 'string' })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => nil })
+    assert_template_result('', code, { 'condition' => 'something else' })
+  end
+
+  def test_case_when_comma
+    code = '{% case condition %}{% when 1, 2, 3 %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 2 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 3 })
+    assert_template_result(' its 4 ', code, { 'condition' => 4 })
+    assert_template_result('', code, { 'condition' => 5 })
+
+    code = '{% case condition %}{% when 1, "string", null %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 'string' })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => nil })
+    assert_template_result('', code, { 'condition' => 'something else' })
+  end
+
+  def test_assign
+    assert_template_result 'variable', '{% assign a = "variable"%}{{a}}'
+  end
+
+  def test_assign_unassigned
+    assigns = { 'var' => 'content' }
+    assert_template_result('var2:  var2:content', 'var2:{{var2}} {%assign var2 = var%} var2:{{var2}}', assigns)
+  end
+
+  def test_assign_an_empty_string
+    assert_template_result '', '{% assign a = ""%}{{a}}'
+  end
+
+  def test_assign_is_global
+    assert_template_result 'variable', '{%for i in (1..2) %}{% assign a = "variable"%}{% endfor %}{{a}}'
+  end
+
+  def test_case_detects_bad_syntax
+    assert_raises(SyntaxError) do
+      assert_template_result('',  '{% case false %}{% when %}true{% endcase %}', {})
+    end
+
+    assert_raises(SyntaxError) do
+      assert_template_result('',  '{% case false %}{% huh %}true{% endcase %}', {})
+    end
+  end
+
+  def test_cycle
+    assert_template_result('one', '{%cycle "one", "two"%}')
+    assert_template_result('one two', '{%cycle "one", "two"%} {%cycle "one", "two"%}')
+    assert_template_result(' two', '{%cycle "", "two"%} {%cycle "", "two"%}')
+
+    assert_template_result('one two one', '{%cycle "one", "two"%} {%cycle "one", "two"%} {%cycle "one", "two"%}')
+
+    assert_template_result('text-align: left text-align: right',
+      '{%cycle "text-align: left", "text-align: right" %} {%cycle "text-align: left", "text-align: right"%}')
+  end
+
+  def test_multiple_cycles
+    assert_template_result('1 2 1 1 2 3 1',
+      '{%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%}')
+  end
+
+  def test_multiple_named_cycles
+    assert_template_result('one one two two one one',
+      '{%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %}')
+  end
+
+  def test_multiple_named_cycles_with_names_from_context
+    assigns = { "var1" => 1, "var2" => 2 }
+    assert_template_result('one one two two one one',
+      '{%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %}', assigns)
+  end
+
+  def test_size_of_array
+    assigns = { "array" => [1, 2, 3, 4] }
+    assert_template_result('array has 4 elements', "array has {{ array.size }} elements", assigns)
+  end
+
+  def test_size_of_hash
+    assigns = { "hash" => { a: 1, b: 2, c: 3, d: 4 } }
+    assert_template_result('hash has 4 elements', "hash has {{ hash.size }} elements", assigns)
+  end
+
+  def test_illegal_symbols
+    assert_template_result('', '{% if true == empty %}?{% endif %}', {})
+    assert_template_result('', '{% if true == null %}?{% endif %}', {})
+    assert_template_result('', '{% if empty == true %}?{% endif %}', {})
+    assert_template_result('', '{% if null == true %}?{% endif %}', {})
+  end
+
+  def test_ifchanged
+    assigns = { 'array' => [ 1, 1, 2, 2, 3, 3] }
+    assert_template_result('123', '{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}', assigns)
+
+    assigns = { 'array' => [ 1, 1, 1, 1] }
+    assert_template_result('1', '{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}', assigns)
+  end
+
+  def test_multiline_tag
+    assert_template_result '0 1 2 3', "0{%\nfor i in (1..3)\n%} {{\ni\n}}{%\nendfor\n%}"
+  end
+end # StandardTagTest

bin/gems/liquid-4.0.4/test/integration/tags/statements_test.rb

@@ -0,0 +1,111 @@
+require 'test_helper'
+
+class StatementsTest < Minitest::Test
+  include Liquid
+
+  def test_true_eql_true
+    text = ' {% if true == true %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text
+  end
+
+  def test_true_not_eql_true
+    text = ' {% if true != true %} true {% else %} false {% endif %} '
+    assert_template_result '  false  ', text
+  end
+
+  def test_true_lq_true
+    text = ' {% if 0 > 0 %} true {% else %} false {% endif %} '
+    assert_template_result '  false  ', text
+  end
+
+  def test_one_lq_zero
+    text = ' {% if 1 > 0 %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text
+  end
+
+  def test_zero_lq_one
+    text = ' {% if 0 < 1 %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text
+  end
+
+  def test_zero_lq_or_equal_one
+    text = ' {% if 0 <= 0 %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text
+  end
+
+  def test_zero_lq_or_equal_one_involving_nil
+    text = ' {% if null <= 0 %} true {% else %} false {% endif %} '
+    assert_template_result '  false  ', text
+
+    text = ' {% if 0 <= null %} true {% else %} false {% endif %} '
+    assert_template_result '  false  ', text
+  end
+
+  def test_zero_lqq_or_equal_one
+    text = ' {% if 0 >= 0 %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text
+  end
+
+  def test_strings
+    text = " {% if 'test' == 'test' %} true {% else %} false {% endif %} "
+    assert_template_result '  true  ', text
+  end
+
+  def test_strings_not_equal
+    text = " {% if 'test' != 'test' %} true {% else %} false {% endif %} "
+    assert_template_result '  false  ', text
+  end
+
+  def test_var_strings_equal
+    text = ' {% if var == "hello there!" %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text, 'var' => 'hello there!'
+  end
+
+  def test_var_strings_are_not_equal
+    text = ' {% if "hello there!" == var %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text, 'var' => 'hello there!'
+  end
+
+  def test_var_and_long_string_are_equal
+    text = " {% if var == 'hello there!' %} true {% else %} false {% endif %} "
+    assert_template_result '  true  ', text, 'var' => 'hello there!'
+  end
+
+  def test_var_and_long_string_are_equal_backwards
+    text = " {% if 'hello there!' == var %} true {% else %} false {% endif %} "
+    assert_template_result '  true  ', text, 'var' => 'hello there!'
+  end
+
+  # def test_is_nil
+  #  text = %| {% if var != nil %} true {% else %} false {% end %} |
+  #  @template.assigns = { 'var' => 'hello there!'}
+  #  expected = %|  true  |
+  #  assert_equal expected, @template.parse(text)
+  # end
+
+  def test_is_collection_empty
+    text = ' {% if array == empty %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text, 'array' => []
+  end
+
+  def test_is_not_collection_empty
+    text = ' {% if array == empty %} true {% else %} false {% endif %} '
+    assert_template_result '  false  ', text, 'array' => [1, 2, 3]
+  end
+
+  def test_nil
+    text = ' {% if var == nil %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text, 'var' => nil
+
+    text = ' {% if var == null %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text, 'var' => nil
+  end
+
+  def test_not_nil
+    text = ' {% if var != nil %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text, 'var' => 1
+
+    text = ' {% if var != null %} true {% else %} false {% endif %} '
+    assert_template_result '  true  ', text, 'var' => 1
+  end
+end # StatementsTest

bin/gems/liquid-4.0.4/test/integration/tags/table_row_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+class TableRowTest < Minitest::Test
+  include Liquid
+
+  class ArrayDrop < Liquid::Drop
+    include Enumerable
+
+    def initialize(array)
+      @array = array
+    end
+
+    def each(&block)
+      @array.each(&block)
+    end
+  end
+
+  def test_table_row
+    assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
+      '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
+      'numbers' => [1, 2, 3, 4, 5, 6])
+
+    assert_template_result("<tr class=\"row1\">\n</tr>\n",
+      '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
+      'numbers' => [])
+  end
+
+  def test_table_row_with_different_cols
+    assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td><td class=\"col4\"> 4 </td><td class=\"col5\"> 5 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 6 </td></tr>\n",
+      '{% tablerow n in numbers cols:5%} {{n}} {% endtablerow %}',
+      'numbers' => [1, 2, 3, 4, 5, 6])
+  end
+
+  def test_table_col_counter
+    assert_template_result("<tr class=\"row1\">\n<td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row2\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row3\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n",
+      '{% tablerow n in numbers cols:2%}{{tablerowloop.col}}{% endtablerow %}',
+      'numbers' => [1, 2, 3, 4, 5, 6])
+  end
+
+  def test_quoted_fragment
+    assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
+      "{% tablerow n in collections.frontpage cols:3%} {{n}} {% endtablerow %}",
+      'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] })
+    assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
+      "{% tablerow n in collections['frontpage'] cols:3%} {{n}} {% endtablerow %}",
+      'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] })
+  end
+
+  def test_enumerable_drop
+    assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
+      '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
+      'numbers' => ArrayDrop.new([1, 2, 3, 4, 5, 6]))
+  end
+
+  def test_offset_and_limit
+    assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
+      '{% tablerow n in numbers cols:3 offset:1 limit:6%} {{n}} {% endtablerow %}',
+      'numbers' => [0, 1, 2, 3, 4, 5, 6, 7])
+  end
+
+  def test_blank_string_not_iterable
+    assert_template_result("<tr class=\"row1\">\n</tr>\n", "{% tablerow char in characters cols:3 %}I WILL NOT BE OUTPUT{% endtablerow %}", 'characters' => '')
+  end
+end

bin/gems/liquid-4.0.4/test/integration/tags/unless_else_tag_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class UnlessElseTagTest < Minitest::Test
+  include Liquid
+
+  def test_unless
+    assert_template_result('  ', ' {% unless true %} this text should not go into the output {% endunless %} ')
+    assert_template_result('  this text should go into the output  ',
+      ' {% unless false %} this text should go into the output {% endunless %} ')
+    assert_template_result('  you rock ?', '{% unless true %} you suck {% endunless %} {% unless false %} you rock {% endunless %}?')
+  end
+
+  def test_unless_else
+    assert_template_result(' YES ', '{% unless true %} NO {% else %} YES {% endunless %}')
+    assert_template_result(' YES ', '{% unless false %} YES {% else %} NO {% endunless %}')
+    assert_template_result(' YES ', '{% unless "foo" %} NO {% else %} YES {% endunless %}')
+  end
+
+  def test_unless_in_loop
+    assert_template_result '23', '{% for i in choices %}{% unless i %}{{ forloop.index }}{% endunless %}{% endfor %}', 'choices' => [1, nil, false]
+  end
+
+  def test_unless_else_in_loop
+    assert_template_result ' TRUE  2  3 ', '{% for i in choices %}{% unless i %} {{ forloop.index }} {% else %} TRUE {% endunless %}{% endfor %}', 'choices' => [1, nil, false]
+  end
+end # UnlessElseTest

bin/gems/liquid-4.0.4/test/integration/template_test.rb

@@ -0,0 +1,332 @@
+require 'test_helper'
+require 'timeout'
+
+class TemplateContextDrop < Liquid::Drop
+  def liquid_method_missing(method)
+    method
+  end
+
+  def foo
+    'fizzbuzz'
+  end
+
+  def baz
+    @context.registers['lulz']
+  end
+end
+
+class SomethingWithLength < Liquid::Drop
+  def length
+    nil
+  end
+end
+
+class ErroneousDrop < Liquid::Drop
+  def bad_method
+    raise 'ruby error in drop'
+  end
+end
+
+class DropWithUndefinedMethod < Liquid::Drop
+  def foo
+    'foo'
+  end
+end
+
+class TemplateTest < Minitest::Test
+  include Liquid
+
+  def test_instance_assigns_persist_on_same_template_object_between_parses
+    t = Template.new
+    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
+    assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
+  end
+
+  def test_warnings_is_not_exponential_time
+    str = "false"
+    100.times do
+      str = "{% if true %}true{% else %}#{str}{% endif %}"
+    end
+
+    t = Template.parse(str)
+    assert_equal [], Timeout.timeout(1) { t.warnings }
+  end
+
+  def test_instance_assigns_persist_on_same_template_parsing_between_renders
+    t = Template.new.parse("{{ foo }}{% assign foo = 'foo' %}{{ foo }}")
+    assert_equal 'foo', t.render!
+    assert_equal 'foofoo', t.render!
+  end
+
+  def test_custom_assigns_do_not_persist_on_same_template
+    t = Template.new
+    assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns')
+    assert_equal '', t.parse("{{ foo }}").render!
+  end
+
+  def test_custom_assigns_squash_instance_assigns
+    t = Template.new
+    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
+    assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns')
+  end
+
+  def test_persistent_assigns_squash_instance_assigns
+    t = Template.new
+    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
+    t.assigns['foo'] = 'from persistent assigns'
+    assert_equal 'from persistent assigns', t.parse("{{ foo }}").render!
+  end
+
+  def test_lambda_is_called_once_from_persistent_assigns_over_multiple_parses_and_renders
+    t = Template.new
+    t.assigns['number'] = -> { @global ||= 0; @global += 1 }
+    assert_equal '1', t.parse("{{number}}").render!
+    assert_equal '1', t.parse("{{number}}").render!
+    assert_equal '1', t.render!
+    @global = nil
+  end
+
+  def test_lambda_is_called_once_from_custom_assigns_over_multiple_parses_and_renders
+    t = Template.new
+    assigns = { 'number' => -> { @global ||= 0; @global += 1 } }
+    assert_equal '1', t.parse("{{number}}").render!(assigns)
+    assert_equal '1', t.parse("{{number}}").render!(assigns)
+    assert_equal '1', t.render!(assigns)
+    @global = nil
+  end
+
+  def test_resource_limits_works_with_custom_length_method
+    t = Template.parse("{% assign foo = bar %}")
+    t.resource_limits.render_length_limit = 42
+    assert_equal "", t.render!("bar" => SomethingWithLength.new)
+  end
+
+  def test_resource_limits_render_length
+    t = Template.parse("0123456789")
+    t.resource_limits.render_length_limit = 5
+    assert_equal "Liquid error: Memory limits exceeded", t.render
+    assert t.resource_limits.reached?
+
+    t.resource_limits.render_length_limit = 10
+    assert_equal "0123456789", t.render!
+    refute_nil t.resource_limits.render_length
+  end
+
+  def test_resource_limits_render_score
+    t = Template.parse("{% for a in (1..10) %} {% for a in (1..10) %} foo {% endfor %} {% endfor %}")
+    t.resource_limits.render_score_limit = 50
+    assert_equal "Liquid error: Memory limits exceeded", t.render
+    assert t.resource_limits.reached?
+
+    t = Template.parse("{% for a in (1..100) %} foo {% endfor %}")
+    t.resource_limits.render_score_limit = 50
+    assert_equal "Liquid error: Memory limits exceeded", t.render
+    assert t.resource_limits.reached?
+
+    t.resource_limits.render_score_limit = 200
+    assert_equal (" foo " * 100), t.render!
+    refute_nil t.resource_limits.render_score
+  end
+
+  def test_resource_limits_assign_score
+    t = Template.parse("{% assign foo = 42 %}{% assign bar = 23 %}")
+    t.resource_limits.assign_score_limit = 1
+    assert_equal "Liquid error: Memory limits exceeded", t.render
+    assert t.resource_limits.reached?
+
+    t.resource_limits.assign_score_limit = 2
+    assert_equal "", t.render!
+    refute_nil t.resource_limits.assign_score
+  end
+
+  def test_resource_limits_assign_score_nested
+    t = Template.parse("{% assign foo = 'aaaa' | reverse %}")
+
+    t.resource_limits.assign_score_limit = 3
+    assert_equal "Liquid error: Memory limits exceeded", t.render
+    assert t.resource_limits.reached?
+
+    t.resource_limits.assign_score_limit = 5
+    assert_equal "", t.render!
+  end
+
+  def test_resource_limits_aborts_rendering_after_first_error
+    t = Template.parse("{% for a in (1..100) %} foo1 {% endfor %} bar {% for a in (1..100) %} foo2 {% endfor %}")
+    t.resource_limits.render_score_limit = 50
+    assert_equal "Liquid error: Memory limits exceeded", t.render
+    assert t.resource_limits.reached?
+  end
+
+  def test_resource_limits_hash_in_template_gets_updated_even_if_no_limits_are_set
+    t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
+    t.render!
+    assert t.resource_limits.assign_score > 0
+    assert t.resource_limits.render_score > 0
+    assert t.resource_limits.render_length > 0
+  end
+
+  def test_render_length_persists_between_blocks
+    t = Template.parse("{% if true %}aaaa{% endif %}")
+    t.resource_limits.render_length_limit = 7
+    assert_equal "Liquid error: Memory limits exceeded", t.render
+    t.resource_limits.render_length_limit = 8
+    assert_equal "aaaa", t.render
+
+    t = Template.parse("{% if true %}aaaa{% endif %}{% if true %}bbb{% endif %}")
+    t.resource_limits.render_length_limit = 13
+    assert_equal "Liquid error: Memory limits exceeded", t.render
+    t.resource_limits.render_length_limit = 14
+    assert_equal "aaaabbb", t.render
+
+    t = Template.parse("{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}")
+    t.resource_limits.render_length_limit = 5
+    assert_equal "Liquid error: Memory limits exceeded", t.render
+    t.resource_limits.render_length_limit = 11
+    assert_equal "Liquid error: Memory limits exceeded", t.render
+    t.resource_limits.render_length_limit = 12
+    assert_equal "ababab", t.render
+  end
+
+  def test_default_resource_limits_unaffected_by_render_with_context
+    context = Context.new
+    t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
+    t.render!(context)
+    assert context.resource_limits.assign_score > 0
+    assert context.resource_limits.render_score > 0
+    assert context.resource_limits.render_length > 0
+  end
+
+  def test_can_use_drop_as_context
+    t = Template.new
+    t.registers['lulz'] = 'haha'
+    drop = TemplateContextDrop.new
+    assert_equal 'fizzbuzz', t.parse('{{foo}}').render!(drop)
+    assert_equal 'bar', t.parse('{{bar}}').render!(drop)
+    assert_equal 'haha', t.parse("{{baz}}").render!(drop)
+  end
+
+  def test_render_bang_force_rethrow_errors_on_passed_context
+    context = Context.new({ 'drop' => ErroneousDrop.new })
+    t = Template.new.parse('{{ drop.bad_method }}')
+
+    e = assert_raises RuntimeError do
+      t.render!(context)
+    end
+    assert_equal 'ruby error in drop', e.message
+  end
+
+  def test_exception_renderer_that_returns_string
+    exception = nil
+    handler = ->(e) { exception = e; '<!-- error -->' }
+
+    output = Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_renderer: handler)
+
+    assert exception.is_a?(Liquid::ZeroDivisionError)
+    assert_equal '<!-- error -->', output
+  end
+
+  def test_exception_renderer_that_raises
+    exception = nil
+    assert_raises(Liquid::ZeroDivisionError) do
+      Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_renderer: ->(e) { exception = e; raise })
+    end
+    assert exception.is_a?(Liquid::ZeroDivisionError)
+  end
+
+  def test_global_filter_option_on_render
+    global_filter_proc = ->(output) { "#{output} filtered" }
+    rendered_template = Template.parse("{{name}}").render({ "name" => "bob" }, global_filter: global_filter_proc)
+
+    assert_equal 'bob filtered', rendered_template
+  end
+
+  def test_global_filter_option_when_native_filters_exist
+    global_filter_proc = ->(output) { "#{output} filtered" }
+    rendered_template = Template.parse("{{name | upcase}}").render({ "name" => "bob" }, global_filter: global_filter_proc)
+
+    assert_equal 'BOB filtered', rendered_template
+  end
+
+  def test_undefined_variables
+    t = Template.parse("{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}")
+    result = t.render({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, { strict_variables: true })
+
+    assert_equal '33  32  ', result
+    assert_equal 3, t.errors.count
+    assert_instance_of Liquid::UndefinedVariable, t.errors[0]
+    assert_equal 'Liquid error: undefined variable y', t.errors[0].message
+    assert_instance_of Liquid::UndefinedVariable, t.errors[1]
+    assert_equal 'Liquid error: undefined variable b', t.errors[1].message
+    assert_instance_of Liquid::UndefinedVariable, t.errors[2]
+    assert_equal 'Liquid error: undefined variable d', t.errors[2].message
+  end
+
+  def test_nil_value_does_not_raise
+    Liquid::Template.error_mode = :strict
+    t = Template.parse("some{{x}}thing")
+    result = t.render!({ 'x' => nil }, strict_variables: true)
+
+    assert_equal 0, t.errors.count
+    assert_equal 'something', result
+  end
+
+  def test_undefined_variables_raise
+    t = Template.parse("{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}")
+
+    assert_raises UndefinedVariable do
+      t.render!({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, { strict_variables: true })
+    end
+  end
+
+  def test_undefined_drop_methods
+    d = DropWithUndefinedMethod.new
+    t = Template.new.parse('{{ foo }} {{ woot }}')
+    result = t.render(d, { strict_variables: true })
+
+    assert_equal 'foo ', result
+    assert_equal 1, t.errors.count
+    assert_instance_of Liquid::UndefinedDropMethod, t.errors[0]
+  end
+
+  def test_undefined_drop_methods_raise
+    d = DropWithUndefinedMethod.new
+    t = Template.new.parse('{{ foo }} {{ woot }}')
+
+    assert_raises UndefinedDropMethod do
+      t.render!(d, { strict_variables: true })
+    end
+  end
+
+  def test_undefined_filters
+    t = Template.parse("{{a}} {{x | upcase | somefilter1 | somefilter2 | somefilter3}}")
+    filters = Module.new do
+      def somefilter3(v)
+        "-#{v}-"
+      end
+    end
+    result = t.render({ 'a' => 123, 'x' => 'foo' }, { filters: [filters], strict_filters: true })
+
+    assert_equal '123 ', result
+    assert_equal 1, t.errors.count
+    assert_instance_of Liquid::UndefinedFilter, t.errors[0]
+    assert_equal 'Liquid error: undefined filter somefilter1', t.errors[0].message
+  end
+
+  def test_undefined_filters_raise
+    t = Template.parse("{{x | somefilter1 | upcase | somefilter2}}")
+
+    assert_raises UndefinedFilter do
+      t.render!({ 'x' => 'foo' }, { strict_filters: true })
+    end
+  end
+
+  def test_using_range_literal_works_as_expected
+    t = Template.parse("{% assign foo = (x..y) %}{{ foo }}")
+    result = t.render({ 'x' => 1, 'y' => 5 })
+    assert_equal '1..5', result
+
+    t = Template.parse("{% assign nums = (x..y) %}{% for num in nums %}{{ num }}{% endfor %}")
+    result = t.render({ 'x' => 1, 'y' => 5 })
+    assert_equal '12345', result
+  end
+end

bin/gems/liquid-4.0.4/test/integration/trim_mode_test.rb

@@ -0,0 +1,529 @@
+require 'test_helper'
+
+class TrimModeTest < Minitest::Test
+  include Liquid
+
+  # Make sure the trim isn't applied to standard output
+  def test_standard_output
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {{ 'John' }}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>
+          John
+        </p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  def test_variable_output_with_multiple_blank_lines
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+
+
+          {{- 'John' -}}
+
+
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>John</p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  def test_tag_output_with_multiple_blank_lines
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+
+
+          {%- if true -%}
+          yes
+          {%- endif -%}
+
+
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>yes</p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  # Make sure the trim isn't applied to standard tags
+  def test_standard_tags
+    whitespace = '          '
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {% if true %}
+          yes
+          {% endif %}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>
+#{whitespace}
+          yes
+#{whitespace}
+        </p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {% if false %}
+          no
+          {% endif %}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>
+#{whitespace}
+        </p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  # Make sure the trim isn't too agressive
+  def test_no_trim_output
+    text = '<p>{{- \'John\' -}}</p>'
+    expected = '<p>John</p>'
+    assert_template_result(expected, text)
+  end
+
+  # Make sure the trim isn't too agressive
+  def test_no_trim_tags
+    text = '<p>{%- if true -%}yes{%- endif -%}</p>'
+    expected = '<p>yes</p>'
+    assert_template_result(expected, text)
+
+    text = '<p>{%- if false -%}no{%- endif -%}</p>'
+    expected = '<p></p>'
+    assert_template_result(expected, text)
+  end
+
+  def test_single_line_outer_tag
+    text = '<p> {%- if true %} yes {% endif -%} </p>'
+    expected = '<p> yes </p>'
+    assert_template_result(expected, text)
+
+    text = '<p> {%- if false %} no {% endif -%} </p>'
+    expected = '<p></p>'
+    assert_template_result(expected, text)
+  end
+
+  def test_single_line_inner_tag
+    text = '<p> {% if true -%} yes {%- endif %} </p>'
+    expected = '<p> yes </p>'
+    assert_template_result(expected, text)
+
+    text = '<p> {% if false -%} no {%- endif %} </p>'
+    expected = '<p>  </p>'
+    assert_template_result(expected, text)
+  end
+
+  def test_single_line_post_tag
+    text = '<p> {% if true -%} yes {% endif -%} </p>'
+    expected = '<p> yes </p>'
+    assert_template_result(expected, text)
+
+    text = '<p> {% if false -%} no {% endif -%} </p>'
+    expected = '<p> </p>'
+    assert_template_result(expected, text)
+  end
+
+  def test_single_line_pre_tag
+    text = '<p> {%- if true %} yes {%- endif %} </p>'
+    expected = '<p> yes </p>'
+    assert_template_result(expected, text)
+
+    text = '<p> {%- if false %} no {%- endif %} </p>'
+    expected = '<p> </p>'
+    assert_template_result(expected, text)
+  end
+
+  def test_pre_trim_output
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {{- 'John' }}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>John
+        </p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  def test_pre_trim_tags
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {%- if true %}
+          yes
+          {%- endif %}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>
+          yes
+        </p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {%- if false %}
+          no
+          {%- endif %}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>
+        </p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  def test_post_trim_output
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {{ 'John' -}}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>
+          John</p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  def test_post_trim_tags
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {% if true -%}
+          yes
+          {% endif -%}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>
+          yes
+          </p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {% if false -%}
+          no
+          {% endif -%}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>
+          </p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  def test_pre_and_post_trim_tags
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {%- if true %}
+          yes
+          {% endif -%}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>
+          yes
+          </p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {%- if false %}
+          no
+          {% endif -%}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p></p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  def test_post_and_pre_trim_tags
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {% if true -%}
+          yes
+          {%- endif %}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>
+          yes
+        </p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+
+    whitespace = '          '
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {% if false -%}
+          no
+          {%- endif %}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>
+#{whitespace}
+        </p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  def test_trim_output
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {{- 'John' -}}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>John</p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  def test_trim_tags
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {%- if true -%}
+          yes
+          {%- endif -%}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>yes</p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {%- if false -%}
+          no
+          {%- endif -%}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p></p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  def test_whitespace_trim_output
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {{- 'John' -}},
+          {{- '30' -}}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>John,30</p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  def test_whitespace_trim_tags
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {%- if true -%}
+          yes
+          {%- endif -%}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>yes</p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {%- if false -%}
+          no
+          {%- endif -%}
+        </p>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p></p>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  def test_complex_trim_output
+    text = <<-END_TEMPLATE
+      <div>
+        <p>
+          {{- 'John' -}}
+          {{- '30' -}}
+        </p>
+        <b>
+          {{ 'John' -}}
+          {{- '30' }}
+        </b>
+        <i>
+          {{- 'John' }}
+          {{ '30' -}}
+        </i>
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+        <p>John30</p>
+        <b>
+          John30
+        </b>
+        <i>John
+          30</i>
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  def test_complex_trim
+    text = <<-END_TEMPLATE
+      <div>
+        {%- if true -%}
+          {%- if true -%}
+            <p>
+              {{- 'John' -}}
+            </p>
+          {%- endif -%}
+        {%- endif -%}
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div><p>John</p></div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+
+  def test_right_trim_followed_by_tag
+    assert_template_result('ab c', '{{ "a" -}}{{ "b" }} c')
+  end
+
+  def test_raw_output
+    whitespace = '        '
+    text = <<-END_TEMPLATE
+      <div>
+        {% raw %}
+          {%- if true -%}
+            <p>
+              {{- 'John' -}}
+            </p>
+          {%- endif -%}
+        {% endraw %}
+      </div>
+    END_TEMPLATE
+    expected = <<-END_EXPECTED
+      <div>
+#{whitespace}
+          {%- if true -%}
+            <p>
+              {{- 'John' -}}
+            </p>
+          {%- endif -%}
+#{whitespace}
+      </div>
+    END_EXPECTED
+    assert_template_result(expected, text)
+  end
+end # TrimModeTest

bin/gems/liquid-4.0.4/test/integration/variable_test.rb

@@ -0,0 +1,96 @@
+require 'test_helper'
+
+class VariableTest < Minitest::Test
+  include Liquid
+
+  def test_simple_variable
+    template = Template.parse(%({{test}}))
+    assert_equal 'worked', template.render!('test' => 'worked')
+    assert_equal 'worked wonderfully', template.render!('test' => 'worked wonderfully')
+  end
+
+  def test_variable_render_calls_to_liquid
+    assert_template_result 'foobar', '{{ foo }}', 'foo' => ThingWithToLiquid.new
+  end
+
+  def test_simple_with_whitespaces
+    template = Template.parse(%(  {{ test }}  ))
+    assert_equal '  worked  ', template.render!('test' => 'worked')
+    assert_equal '  worked wonderfully  ', template.render!('test' => 'worked wonderfully')
+  end
+
+  def test_ignore_unknown
+    template = Template.parse(%({{ test }}))
+    assert_equal '', template.render!
+  end
+
+  def test_using_blank_as_variable_name
+    template = Template.parse("{% assign foo = blank %}{{ foo }}")
+    assert_equal '', template.render!
+  end
+
+  def test_using_empty_as_variable_name
+    template = Template.parse("{% assign foo = empty %}{{ foo }}")
+    assert_equal '', template.render!
+  end
+
+  def test_hash_scoping
+    template = Template.parse(%({{ test.test }}))
+    assert_equal 'worked', template.render!('test' => { 'test' => 'worked' })
+  end
+
+  def test_false_renders_as_false
+    assert_equal 'false', Template.parse("{{ foo }}").render!('foo' => false)
+    assert_equal 'false', Template.parse("{{ false }}").render!
+  end
+
+  def test_nil_renders_as_empty_string
+    assert_equal '', Template.parse("{{ nil }}").render!
+    assert_equal 'cat', Template.parse("{{ nil | append: 'cat' }}").render!
+  end
+
+  def test_preset_assigns
+    template = Template.parse(%({{ test }}))
+    template.assigns['test'] = 'worked'
+    assert_equal 'worked', template.render!
+  end
+
+  def test_reuse_parsed_template
+    template = Template.parse(%({{ greeting }} {{ name }}))
+    template.assigns['greeting'] = 'Goodbye'
+    assert_equal 'Hello Tobi', template.render!('greeting' => 'Hello', 'name' => 'Tobi')
+    assert_equal 'Hello ', template.render!('greeting' => 'Hello', 'unknown' => 'Tobi')
+    assert_equal 'Hello Brian', template.render!('greeting' => 'Hello', 'name' => 'Brian')
+    assert_equal 'Goodbye Brian', template.render!('name' => 'Brian')
+    assert_equal({ 'greeting' => 'Goodbye' }, template.assigns)
+  end
+
+  def test_assigns_not_polluted_from_template
+    template = Template.parse(%({{ test }}{% assign test = 'bar' %}{{ test }}))
+    template.assigns['test'] = 'baz'
+    assert_equal 'bazbar', template.render!
+    assert_equal 'bazbar', template.render!
+    assert_equal 'foobar', template.render!('test' => 'foo')
+    assert_equal 'bazbar', template.render!
+  end
+
+  def test_hash_with_default_proc
+    template = Template.parse(%(Hello {{ test }}))
+    assigns = Hash.new { |h, k| raise "Unknown variable '#{k}'" }
+    assigns['test'] = 'Tobi'
+    assert_equal 'Hello Tobi', template.render!(assigns)
+    assigns.delete('test')
+    e = assert_raises(RuntimeError) do
+      template.render!(assigns)
+    end
+    assert_equal "Unknown variable 'test'", e.message
+  end
+
+  def test_multiline_variable
+    assert_equal 'worked', Template.parse("{{\ntest\n}}").render!('test' => 'worked')
+  end
+
+  def test_render_symbol
+    assert_template_result 'bar', '{{ foo }}', 'foo' => :bar
+  end
+end

bin/gems/liquid-4.0.4/test/test_helper.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+
+ENV["MT_NO_EXPECTATIONS"] = "1"
+require 'minitest/autorun'
+
+$LOAD_PATH.unshift(File.join(File.expand_path(__dir__), '..', 'lib'))
+require 'liquid.rb'
+require 'liquid/profiler'
+
+mode = :strict
+if env_mode = ENV['LIQUID_PARSER_MODE']
+  puts "-- #{env_mode.upcase} ERROR MODE"
+  mode = env_mode.to_sym
+end
+Liquid::Template.error_mode = mode
+
+if ENV['LIQUID-C'] == '1'
+  puts "-- LIQUID C"
+  require 'liquid/c'
+end
+
+if Minitest.const_defined?('Test')
+  # We're on Minitest 5+. Nothing to do here.
+else
+  # Minitest 4 doesn't have Minitest::Test yet.
+  Minitest::Test = MiniTest::Unit::TestCase
+end
+
+module Minitest
+  class Test
+    def fixture(name)
+      File.join(File.expand_path(__dir__), "fixtures", name)
+    end
+  end
+
+  module Assertions
+    include Liquid
+
+    def assert_template_result(expected, template, assigns = {}, message = nil)
+      assert_equal expected, Template.parse(template).render!(assigns), message
+    end
+
+    def assert_template_result_matches(expected, template, assigns = {}, message = nil)
+      return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp
+
+      assert_match expected, Template.parse(template).render!(assigns), message
+    end
+
+    def assert_match_syntax_error(match, template, assigns = {})
+      exception = assert_raises(Liquid::SyntaxError) do
+        Template.parse(template).render(assigns)
+      end
+      assert_match match, exception.message
+    end
+
+    def with_global_filter(*globals)
+      original_global_strainer = Liquid::Strainer.class_variable_get(:@@global_strainer)
+      Liquid::Strainer.class_variable_set(:@@global_strainer, Class.new(Liquid::Strainer) do
+        @filter_methods = Set.new
+      end)
+      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
+
+      globals.each do |global|
+        Liquid::Template.register_filter(global)
+      end
+      yield
+    ensure
+      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
+      Liquid::Strainer.class_variable_set(:@@global_strainer, original_global_strainer)
+    end
+
+    def with_error_mode(mode)
+      old_mode = Liquid::Template.error_mode
+      Liquid::Template.error_mode = mode
+      yield
+    ensure
+      Liquid::Template.error_mode = old_mode
+    end
+  end
+end
+
+class ThingWithToLiquid
+  def to_liquid
+    'foobar'
+  end
+end
+
+class ErrorDrop < Liquid::Drop
+  def standard_error
+    raise Liquid::StandardError, 'standard error'
+  end
+
+  def argument_error
+    raise Liquid::ArgumentError, 'argument error'
+  end
+
+  def syntax_error
+    raise Liquid::SyntaxError, 'syntax error'
+  end
+
+  def runtime_error
+    raise 'runtime error'
+  end
+
+  def exception
+    raise Exception, 'exception'
+  end
+end

bin/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

bin/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

bin/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

bin/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

bin/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

bin/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

bin/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

bin/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

bin/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

bin/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

bin/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

bin/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

bin/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

bin/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

bin/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

bin/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