liquid 4.0.1 → 5.4.0

data/test/unit/regexp_unit_test.rb

@@ -1,44 +0,0 @@
-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/strainer_unit_test.rb

@@ -1,164 +0,0 @@
-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

data/test/unit/tag_unit_test.rb

@@ -1,21 +0,0 @@
-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

data/test/unit/tags/case_tag_unit_test.rb

@@ -1,10 +0,0 @@
-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

data/test/unit/tags/for_tag_unit_test.rb

@@ -1,13 +0,0 @@
-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

data/test/unit/tags/if_tag_unit_test.rb

@@ -1,8 +0,0 @@
-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

data/test/unit/template_unit_test.rb

@@ -1,78 +0,0 @@
-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

data/test/unit/tokenizer_unit_test.rb

@@ -1,55 +0,0 @@
-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

data/test/unit/variable_unit_test.rb

@@ -1,162 +0,0 @@
-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