liquid 5.3.0 → 5.4.0

data/test/unit/strainer_factory_unit_test.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class StrainerFactoryUnitTest < Minitest::Test
-  include Liquid
-
-  module AccessScopeFilters
-    def public_filter
-      "public"
-    end
-
-    def private_filter
-      "private"
-    end
-    private :private_filter
-  end
-
-  StrainerFactory.add_global_filter(AccessScopeFilters)
-
-  module LateAddedFilter
-    def late_added_filter(_input)
-      "filtered"
-    end
-  end
-
-  def setup
-    @context = Context.build
-  end
-
-  def test_strainer
-    strainer = StrainerFactory.create(@context)
-    assert_equal(5, strainer.invoke('size', 'input'))
-    assert_equal("public", strainer.invoke("public_filter"))
-  end
-
-  def test_stainer_raises_argument_error
-    strainer = StrainerFactory.create(@context)
-    assert_raises(Liquid::ArgumentError) do
-      strainer.invoke("public_filter", 1)
-    end
-  end
-
-  def test_stainer_argument_error_contains_backtrace
-    strainer = StrainerFactory.create(@context)
-
-    exception = assert_raises(Liquid::ArgumentError) do
-      strainer.invoke("public_filter", 1)
-    end
-
-    assert_match(
-      /\ALiquid error: wrong number of arguments \((1 for 0|given 1, expected 0)\)\z/,
-      exception.message
-    )
-    source = AccessScopeFilters.instance_method(:public_filter).source_location
-    assert_equal(source.map(&:to_s), exception.backtrace[0].split(':')[0..1])
-  end
-
-  def test_strainer_only_invokes_public_filter_methods
-    strainer = StrainerFactory.create(@context)
-    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 = StrainerFactory.create(@context)
-    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 = StrainerFactory.create(@context)
-    assert_equal("password", strainer.invoke("undef_the_method", "password"))
-  end
-
-  def test_strainer_only_allows_methods_defined_in_filters
-    strainer = StrainerFactory.create(@context)
-    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 = StrainerFactory.create(@context, [a, b])
-    assert_kind_of(StrainerTemplate, strainer)
-    assert_kind_of(a, strainer)
-    assert_kind_of(b, strainer)
-    assert_kind_of(Liquid::StandardFilters, strainer)
-  end
-
-  def test_add_global_filter_clears_cache
-    assert_equal('input', StrainerFactory.create(@context).invoke('late_added_filter', 'input'))
-    StrainerFactory.add_global_filter(LateAddedFilter)
-    assert_equal('filtered', StrainerFactory.create(nil).invoke('late_added_filter', 'input'))
-  end
-end

data/test/unit/strainer_template_unit_test.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class StrainerTemplateUnitTest < Minitest::Test
-  include Liquid
-
-  def test_add_filter_when_wrong_filter_class
-    c = Context.new
-    s = c.strainer
-    wrong_filter = ->(v) { v.reverse }
-
-    exception = assert_raises(TypeError) do
-      s.class.add_filter(wrong_filter)
-    end
-    assert_equal(exception.message, "wrong argument type Proc (expected Module)")
-  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
-    with_global_filter do
-      strainer = Context.new.strainer
-      strainer.class.add_filter(PublicMethodOverrideFilter)
-      assert(strainer.class.send(:filter_methods).include?('public_filter'))
-    end
-  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

data/test/unit/tag_unit_test.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-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,12 +0,0 @@
-# frozen_string_literal: true
-
-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,15 +0,0 @@
-# frozen_string_literal: true
-
-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,10 +0,0 @@
-# frozen_string_literal: true
-
-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_factory_unit_test.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TemplateFactoryUnitTest < Minitest::Test
-  include Liquid
-
-  def test_for_returns_liquid_template_instance
-    template = TemplateFactory.new.for("anything")
-    assert_instance_of(Liquid::Template, template)
-  end
-end

data/test/unit/template_unit_test.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-  class TemplateSubclass < Liquid::Template
-  end
-
-  def test_template_inheritance
-    assert_equal("foo", TemplateSubclass.parse("foo").render)
-  end
-end

data/test/unit/tokenizer_unit_test.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-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 new_tokenizer(source, parse_context: Liquid::ParseContext.new, start_line_number: nil)
-    parse_context.new_tokenizer(source, start_line_number: start_line_number)
-  end
-
-  def tokenize(source)
-    tokenizer = new_tokenizer(source)
-    tokens    = []
-    # shift is private in Liquid::C::Tokenizer, since it is only for unit testing
-    while (t = tokenizer.send(:shift))
-      tokens << t
-    end
-    tokens
-  end
-
-  def tokenize_line_numbers(source)
-    tokenizer    = new_tokenizer(source, start_line_number: 1)
-    line_numbers = []
-    loop do
-      line_number = tokenizer.line_number
-      if tokenizer.send(:shift)
-        line_numbers << line_number
-      else
-        break
-      end
-    end
-    line_numbers
-  end
-end

data/test/unit/variable_unit_test.rb

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