liquid 5.1.0 → 5.4.0

data/test/unit/parse_tree_visitor_test.rb

@@ -1,261 +0,0 @@
-# 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_echo
-    assert_equal(
-      ["test"],
-      visit(%({% echo test %}))
-    )
-  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_for_range
-    assert_equal(
-      ["test"],
-      visit(%({% for x in (1..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

data/test/unit/parser_unit_test.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-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

data/test/unit/partial_cache_unit_test.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class PartialCacheUnitTest < Minitest::Test
-  def test_uses_the_file_system_register_if_present
-    context = Liquid::Context.build(
-      registers: {
-        file_system: StubFileSystem.new('my_partial' => 'my partial body'),
-      }
-    )
-
-    partial = Liquid::PartialCache.load(
-      'my_partial',
-      context: context,
-      parse_context: Liquid::ParseContext.new
-    )
-
-    assert_equal('my partial body', partial.render)
-  end
-
-  def test_reads_from_the_file_system_only_once_per_file
-    file_system = StubFileSystem.new('my_partial' => 'some partial body')
-    context     = Liquid::Context.build(
-      registers: { file_system: file_system }
-    )
-
-    2.times do
-      Liquid::PartialCache.load(
-        'my_partial',
-        context: context,
-        parse_context: Liquid::ParseContext.new
-      )
-    end
-
-    assert_equal(1, file_system.file_read_count)
-  end
-
-  def test_cache_state_is_stored_per_context
-    parse_context      = Liquid::ParseContext.new
-    shared_file_system = StubFileSystem.new(
-      'my_partial' => 'my shared value'
-    )
-    context_one = Liquid::Context.build(
-      registers: {
-        file_system: shared_file_system,
-      }
-    )
-    context_two = Liquid::Context.build(
-      registers: {
-        file_system: shared_file_system,
-      }
-    )
-
-    2.times do
-      Liquid::PartialCache.load(
-        'my_partial',
-        context: context_one,
-        parse_context: parse_context
-      )
-    end
-
-    Liquid::PartialCache.load(
-      'my_partial',
-      context: context_two,
-      parse_context: parse_context
-    )
-
-    assert_equal(2, shared_file_system.file_read_count)
-  end
-
-  def test_cache_is_not_broken_when_a_different_parse_context_is_used
-    file_system = StubFileSystem.new('my_partial' => 'some partial body')
-    context     = Liquid::Context.build(
-      registers: { file_system: file_system }
-    )
-
-    Liquid::PartialCache.load(
-      'my_partial',
-      context: context,
-      parse_context: Liquid::ParseContext.new(my_key: 'value one')
-    )
-    Liquid::PartialCache.load(
-      'my_partial',
-      context: context,
-      parse_context: Liquid::ParseContext.new(my_key: 'value two')
-    )
-
-    # Technically what we care about is that the file was parsed twice,
-    # but measuring file reads is an OK proxy for this.
-    assert_equal(1, file_system.file_read_count)
-  end
-
-  def test_uses_default_template_factory_when_no_template_factory_found_in_register
-    context = Liquid::Context.build(
-      registers: {
-        file_system: StubFileSystem.new('my_partial' => 'my partial body'),
-      }
-    )
-
-    partial = Liquid::PartialCache.load(
-      'my_partial',
-      context: context,
-      parse_context: Liquid::ParseContext.new
-    )
-
-    assert_equal('my partial body', partial.render)
-  end
-
-  def test_uses_template_factory_register_if_present
-    template_factory = StubTemplateFactory.new
-    context = Liquid::Context.build(
-      registers: {
-        file_system: StubFileSystem.new('my_partial' => 'my partial body'),
-        template_factory: template_factory,
-      }
-    )
-
-    partial = Liquid::PartialCache.load(
-      'my_partial',
-      context: context,
-      parse_context: Liquid::ParseContext.new
-    )
-
-    assert_equal('my partial body', partial.render)
-    assert_equal(1, template_factory.count)
-  end
-end

data/test/unit/regexp_unit_test.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-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

data/test/unit/static_registers_unit_test.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class StaticRegistersUnitTest < Minitest::Test
-  include Liquid
-
-  def test_set
-    static_register = StaticRegisters.new(a: 1, b: 2)
-    static_register[:b] = 22
-    static_register[:c] = 33
-
-    assert_equal(1, static_register[:a])
-    assert_equal(22, static_register[:b])
-    assert_equal(33, static_register[:c])
-  end
-
-  def test_get_missing_key
-    static_register = StaticRegisters.new
-
-    assert_nil(static_register[:missing])
-  end
-
-  def test_delete
-    static_register = StaticRegisters.new(a: 1, b: 2)
-    static_register[:b] = 22
-    static_register[:c] = 33
-
-    assert_nil(static_register.delete(:a))
-
-    assert_equal(22, static_register.delete(:b))
-
-    assert_equal(33, static_register.delete(:c))
-    assert_nil(static_register[:c])
-
-    assert_nil(static_register.delete(:d))
-  end
-
-  def test_fetch
-    static_register = StaticRegisters.new(a: 1, b: 2)
-    static_register[:b] = 22
-    static_register[:c] = 33
-
-    assert_equal(1, static_register.fetch(:a))
-    assert_equal(1, static_register.fetch(:a, "default"))
-    assert_equal(22, static_register.fetch(:b))
-    assert_equal(22, static_register.fetch(:b, "default"))
-    assert_equal(33, static_register.fetch(:c))
-    assert_equal(33, static_register.fetch(:c, "default"))
-
-    assert_raises(KeyError) do
-      static_register.fetch(:d)
-    end
-    assert_equal("default", static_register.fetch(:d, "default"))
-
-    result = static_register.fetch(:d) { "default" }
-    assert_equal("default", result)
-
-    result = static_register.fetch(:d, "default 1") { "default 2" }
-    assert_equal("default 2", result)
-  end
-
-  def test_key
-    static_register = StaticRegisters.new(a: 1, b: 2)
-    static_register[:b] = 22
-    static_register[:c] = 33
-
-    assert_equal(true, static_register.key?(:a))
-    assert_equal(true, static_register.key?(:b))
-    assert_equal(true, static_register.key?(:c))
-    assert_equal(false, static_register.key?(:d))
-  end
-
-  def test_static_register_can_be_frozen
-    static_register = StaticRegisters.new(a: 1)
-
-    static_register.static.freeze
-
-    assert_raises(RuntimeError) do
-      static_register.static[:a] = "foo"
-    end
-
-    assert_raises(RuntimeError) do
-      static_register.static[:b] = "foo"
-    end
-
-    assert_raises(RuntimeError) do
-      static_register.static.delete(:a)
-    end
-
-    assert_raises(RuntimeError) do
-      static_register.static.delete(:c)
-    end
-  end
-
-  def test_new_static_retains_static
-    static_register = StaticRegisters.new(a: 1, b: 2)
-    static_register[:b] = 22
-    static_register[:c] = 33
-
-    new_static_register = StaticRegisters.new(static_register)
-    new_static_register[:b] = 222
-
-    newest_static_register = StaticRegisters.new(new_static_register)
-    newest_static_register[:c] = 333
-
-    assert_equal(1, static_register[:a])
-    assert_equal(22, static_register[:b])
-    assert_equal(33, static_register[:c])
-
-    assert_equal(1, new_static_register[:a])
-    assert_equal(222, new_static_register[:b])
-    assert_nil(new_static_register[:c])
-
-    assert_equal(1, newest_static_register[:a])
-    assert_equal(2, newest_static_register[:b])
-    assert_equal(333, newest_static_register[:c])
-  end
-
-  def test_multiple_instances_are_unique
-    static_register_1 = StaticRegisters.new(a: 1, b: 2)
-    static_register_1[:b] = 22
-    static_register_1[:c] = 33
-
-    static_register_2 = StaticRegisters.new(a: 10, b: 20)
-    static_register_2[:b] = 220
-    static_register_2[:c] = 330
-
-    assert_equal({ a: 1, b: 2 }, static_register_1.static)
-    assert_equal(1, static_register_1[:a])
-    assert_equal(22, static_register_1[:b])
-    assert_equal(33, static_register_1[:c])
-
-    assert_equal({ a: 10, b: 20 }, static_register_2.static)
-    assert_equal(10, static_register_2[:a])
-    assert_equal(220, static_register_2[:b])
-    assert_equal(330, static_register_2[:c])
-  end
-
-  def test_initialization_reused_static_same_memory_object
-    static_register_1 = StaticRegisters.new(a: 1, b: 2)
-    static_register_1[:b] = 22
-    static_register_1[:c] = 33
-
-    static_register_2 = StaticRegisters.new(static_register_1)
-
-    assert_equal(1, static_register_2[:a])
-    assert_equal(2, static_register_2[:b])
-    assert_nil(static_register_2[:c])
-
-    static_register_1.static[:b] = 222
-    static_register_1.static[:c] = 333
-
-    assert_same(static_register_1.static, static_register_2.static)
-  end
-end