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