liquid 3.0.6 → 4.0.3

data/test/unit/lexer_unit_test.rb

@@ -4,23 +4,23 @@ 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
+    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
+    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
+    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
+    tokens = Lexer.new('== <> contains ').tokenize
+    assert_equal [[:comparison, '=='], [:comparison, '<>'], [:comparison, 'contains'], [:end_of_string]], tokens
   end
 
   def test_specials
@@ -31,13 +31,16 @@ class LexerUnitTest < Minitest::Test
   end
 
   def test_fancy_identifiers
-    tokens = Lexer.new('hi! five?').tokenize
-    assert_equal [[:id,'hi!'], [:id, 'five?'], [:end_of_string]], tokens
+    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
+    assert_equal [[:id, 'five'], [:pipe, '|'], [:comparison, '=='], [:end_of_string]], tokens
   end
 
   def test_unexpected_character

data/test/unit/parser_unit_test.rb

@@ -44,9 +44,9 @@ class ParserUnitTest < Minitest::Test
   end
 
   def test_expressions
-    p = Parser.new("hi.there hi[5].! hi.there.bob")
+    p = Parser.new("hi.there hi?[5].there? hi.there.bob")
     assert_equal 'hi.there', p.expression
-    assert_equal 'hi[5].!', p.expression
+    assert_equal 'hi?[5].there?', p.expression
     assert_equal 'hi.there.bob', p.expression
 
     p = Parser.new("567 6.0 'lol' \"wut\"")

data/test/unit/regexp_unit_test.rb

@@ -18,7 +18,7 @@ class RegexpUnitTest < Minitest::Test
   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)
+    assert_equal ['<style', 'class="hello">', '</style>'], %(<style class="hello">' </style>).scan(QuotedFragment)
   end
 
   def test_double_quoted_words

data/test/unit/strainer_unit_test.rb

@@ -29,6 +29,18 @@ class StrainerUnitTest < Minitest::Test
     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__')
@@ -59,11 +71,94 @@ class StrainerUnitTest < Minitest::Test
   def test_strainer_uses_a_class_cache_to_avoid_method_cache_invalidation
     a = Module.new
     b = Module.new
-    strainer = Strainer.create(nil, [a,b])
+    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

@@ -4,13 +4,18 @@ class TagUnitTest < Minitest::Test
   include Liquid
 
   def test_tag
-    tag = Tag.parse('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", [], {})
+    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

@@ -5,6 +5,6 @@ class CaseTagUnitTest < Minitest::Test
 
   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
+    assert_equal ['WHEN', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten
   end
 end

data/test/unit/tags/for_tag_unit_test.rb

@@ -3,11 +3,11 @@ 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
+    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
+    assert_equal ['FOR', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten
   end
 end

data/test/unit/tags/if_tag_unit_test.rb

@@ -3,6 +3,6 @@ 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
+    assert_equal ['IF', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten
   end
 end

data/test/unit/template_unit_test.rb

@@ -5,16 +5,17 @@ class TemplateUnitTest < Minitest::Test
 
   def test_sets_default_localization_in_document
     t = Template.new
-    t.parse('')
-    assert_instance_of I18n, t.root.options[:locale]
+    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('{{foo}}', :locale => I18n.new(fixture("en_locale.yml")))
+    t.parse('{%comment%}{%endcomment%}', locale: I18n.new(fixture("en_locale.yml")))
 
-    assert_instance_of I18n, t.root.options[:locale]
-    assert_equal fixture("en_locale.yml"), t.root.options[:locale].path
+    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
@@ -66,4 +67,12 @@ class TemplateUnitTest < Minitest::Test
     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

@@ -22,17 +22,34 @@ class TokenizerTest < Minitest::Test
   end
 
   def test_calculate_line_numbers_per_token_with_profiling
-    template = Liquid::Template.parse("", :profile => true)
-
-    assert_equal [1],       template.send(:tokenize, "{{funk}}").map(&:line_number)
-    assert_equal [1, 1, 1], template.send(:tokenize, " {{funk}} ").map(&:line_number)
-    assert_equal [1, 2, 2], template.send(:tokenize, "\n{{funk}}\n").map(&:line_number)
-    assert_equal [1, 1, 3], template.send(:tokenize, " {{\n funk \n}} ").map(&:line_number)
+    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)
-    Liquid::Template.new.send(: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

@@ -4,136 +4,147 @@ class VariableUnitTest < Minitest::Test
   include Liquid
 
   def test_variable
-    var = Variable.new('hello')
+    var = create_variable('hello')
     assert_equal VariableLookup.new('hello'), var.name
   end
 
   def test_filters
-    var = Variable.new('hello | textileze')
+    var = create_variable('hello | textileze')
     assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['textileze',[]]], var.filters
+    assert_equal [['textileze', []]], var.filters
 
-    var = Variable.new('hello | textileze | paragraph')
+    var = create_variable('hello | textileze | paragraph')
     assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['textileze',[]], ['paragraph',[]]], var.filters
+    assert_equal [['textileze', []], ['paragraph', []]], var.filters
 
-    var = Variable.new(%! hello | strftime: '%Y'!)
+    var = create_variable(%( hello | strftime: '%Y'))
     assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['strftime',['%Y']]], var.filters
+    assert_equal [['strftime', ['%Y']]], var.filters
 
-    var = Variable.new(%! 'typo' | link_to: 'Typo', true !)
+    var = create_variable(%( 'typo' | link_to: 'Typo', true ))
     assert_equal 'typo', var.name
-    assert_equal [['link_to',['Typo', true]]], var.filters
+    assert_equal [['link_to', ['Typo', true]]], var.filters
 
-    var = Variable.new(%! 'typo' | link_to: 'Typo', false !)
+    var = create_variable(%( 'typo' | link_to: 'Typo', false ))
     assert_equal 'typo', var.name
-    assert_equal [['link_to',['Typo', false]]], var.filters
+    assert_equal [['link_to', ['Typo', false]]], var.filters
 
-    var = Variable.new(%! 'foo' | repeat: 3 !)
+    var = create_variable(%( 'foo' | repeat: 3 ))
     assert_equal 'foo', var.name
-    assert_equal [['repeat',[3]]], var.filters
+    assert_equal [['repeat', [3]]], var.filters
 
-    var = Variable.new(%! 'foo' | repeat: 3, 3 !)
+    var = create_variable(%( 'foo' | repeat: 3, 3 ))
     assert_equal 'foo', var.name
-    assert_equal [['repeat',[3,3]]], var.filters
+    assert_equal [['repeat', [3, 3]]], var.filters
 
-    var = Variable.new(%! 'foo' | repeat: 3, 3, 3 !)
+    var = create_variable(%( 'foo' | repeat: 3, 3, 3 ))
     assert_equal 'foo', var.name
-    assert_equal [['repeat',[3,3,3]]], var.filters
+    assert_equal [['repeat', [3, 3, 3]]], var.filters
 
-    var = Variable.new(%! hello | strftime: '%Y, okay?'!)
+    var = create_variable(%( hello | strftime: '%Y, okay?'))
     assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['strftime',['%Y, okay?']]], var.filters
+    assert_equal [['strftime', ['%Y, okay?']]], var.filters
 
-    var = Variable.new(%! hello | things: "%Y, okay?", 'the other one'!)
+    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
+    assert_equal [['things', ['%Y, okay?', 'the other one']]], var.filters
   end
 
   def test_filter_with_date_parameter
-    var = Variable.new(%! '2006-06-06' | date: "%m/%d/%Y"!)
+    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
+    assert_equal [['date', ['%m/%d/%Y']]], var.filters
   end
 
   def test_filters_without_whitespace
-    var = Variable.new('hello | textileze | paragraph')
+    var = create_variable('hello | textileze | paragraph')
     assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['textileze',[]], ['paragraph',[]]], var.filters
+    assert_equal [['textileze', []], ['paragraph', []]], var.filters
 
-    var = Variable.new('hello|textileze|paragraph')
+    var = create_variable('hello|textileze|paragraph')
     assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['textileze',[]], ['paragraph',[]]], var.filters
+    assert_equal [['textileze', []], ['paragraph', []]], var.filters
 
-    var = Variable.new("hello|replace:'foo','bar'|textileze")
+    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 = Variable.new("http://disney.com/logo.gif | image: 'med' ", :error_mode => :lax)
+    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
+    assert_equal [['image', ['med']]], var.filters
   end
 
   def test_string_to_filter
-    var = Variable.new("'http://disney.com/logo.gif' | image: 'med' ")
+    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
+    assert_equal [['image', ['med']]], var.filters
   end
 
   def test_string_single_quoted
-    var = Variable.new(%| "hello" |)
+    var = create_variable(%( "hello" ))
     assert_equal 'hello', var.name
   end
 
   def test_string_double_quoted
-    var = Variable.new(%| 'hello' |)
+    var = create_variable(%( 'hello' ))
     assert_equal 'hello', var.name
   end
 
   def test_integer
-    var = Variable.new(%| 1000 |)
+    var = create_variable(%( 1000 ))
     assert_equal 1000, var.name
   end
 
   def test_float
-    var = Variable.new(%| 1000.01 |)
+    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 = Variable.new(%| 'hello! $!@.;"ddasd" ' |)
+    var = create_variable(%( 'hello! $!@.;"ddasd" ' ))
     assert_equal 'hello! $!@.;"ddasd" ', var.name
   end
 
   def test_string_dot
-    var = Variable.new(%| test.test |)
+    var = create_variable(%( test.test ))
     assert_equal VariableLookup.new('test.test'), var.name
   end
 
   def test_filter_with_keyword_arguments
-    var = Variable.new(%! hello | things: greeting: "world", farewell: 'goodbye'!)
+    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 = Variable.new(%! number_of_comments | pluralize: 'comment': 'comments' !, :error_mode => :lax)
+    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
+    assert_equal [['pluralize', ['comment', 'comments']]], var.filters
   end
 
   def test_strict_filter_argument_parsing
     with_error_mode(:strict) do
       assert_raises(SyntaxError) do
-        Variable.new(%! number_of_comments | pluralize: 'comment': 'comments' !)
+        create_variable(%( number_of_comments | pluralize: 'comment': 'comments' ))
       end
     end
   end
 
   def test_output_raw_source_of_variable
-    var = Variable.new(%! name_of_variable | upcase !)
+    var = create_variable(%( name_of_variable | upcase ))
     assert_equal " name_of_variable | upcase ", var.raw
   end
 
@@ -142,4 +153,10 @@ class VariableUnitTest < Minitest::Test
     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