liquid 2.6.3 → 3.0.0

data/test/unit/lexer_unit_test.rb

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

data/test/{liquid/module_ex_test.rb → unit/module_ex_unit_test.rb}

@@ -36,7 +36,7 @@ class TestClassC::LiquidDropClass
   end
 end
 
-class ModuleExTest < Test::Unit::TestCase
+class ModuleExUnitTest < Minitest::Test
   include Liquid
 
   def setup
@@ -77,11 +77,11 @@ class ModuleExTest < Test::Unit::TestCase
   end
 
   def test_should_use_regular_objects_as_drops
-    assert_equal 'allowedA', Liquid::Template.parse("{{ a.allowedA }}").render('a'=>@a)
-    assert_equal 'allowedB', Liquid::Template.parse("{{ a.chainedB.allowedB }}").render('a'=>@a)
-    assert_equal 'allowedC', Liquid::Template.parse("{{ a.chainedB.chainedC.allowedC }}").render('a'=>@a)
-    assert_equal 'another_allowedC', Liquid::Template.parse("{{ a.chainedB.chainedC.another_allowedC }}").render('a'=>@a)
-    assert_equal '', Liquid::Template.parse("{{ a.restricted }}").render('a'=>@a)
-    assert_equal '', Liquid::Template.parse("{{ a.unknown }}").render('a'=>@a)
+    assert_template_result 'allowedA', "{{ a.allowedA }}", 'a'=>@a
+    assert_template_result 'allowedB', "{{ a.chainedB.allowedB }}", 'a'=>@a
+    assert_template_result 'allowedC', "{{ a.chainedB.chainedC.allowedC }}", 'a'=>@a
+    assert_template_result 'another_allowedC', "{{ a.chainedB.chainedC.another_allowedC }}", 'a'=>@a
+    assert_template_result '', "{{ a.restricted }}", 'a'=>@a
+    assert_template_result '', "{{ a.unknown }}", 'a'=>@a
   end
 end # ModuleExTest

data/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].! hi.there.bob")
+    assert_equal 'hi.there', p.expression
+    assert_equal 'hi[5].!', p.expression
+    assert_equal 'hi.there.bob', p.expression
+
+    p = Parser.new("567 6.0 'lol' \"wut\"")
+    assert_equal '567', p.expression
+    assert_equal '6.0', p.expression
+    assert_equal "'lol'", p.expression
+    assert_equal '"wut"', p.expression
+  end
+
+  def test_ranges
+    p = Parser.new("(5..7) (1.5..9.6) (young..old) (hi[5].wat..old)")
+    assert_equal '(5..7)', p.expression
+    assert_equal '(1.5..9.6)', p.expression
+    assert_equal '(young..old)', p.expression
+    assert_equal '(hi[5].wat..old)', p.expression
+  end
+
+  def test_arguments
+    p = Parser.new("filter: hi.there[5], keyarg: 7")
+    assert_equal 'filter', p.consume(:id)
+    assert_equal ':', p.consume(:colon)
+    assert_equal 'hi.there[5]', p.argument
+    assert_equal ',', p.consume(:comma)
+    assert_equal 'keyarg: 7', p.argument
+  end
+
+  def test_invalid_expression
+    assert_raises(SyntaxError) do
+      p = Parser.new("==")
+      p.expression
+    end
+  end
+end

data/test/{liquid/regexp_test.rb → unit/regexp_unit_test.rb}

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class RegexpTest < Test::Unit::TestCase
+class RegexpUnitTest < Minitest::Test
   include Liquid
 
   def test_empty
@@ -21,11 +21,11 @@ class RegexpTest < Test::Unit::TestCase
     assert_equal ['<style', 'class="hello">', '</style>'], %|<style class="hello">' </style>|.scan(QuotedFragment)
   end
 
-  def test_quoted_words
+  def test_double_quoted_words
     assert_equal ['arg1', 'arg2', '"arg 3"'], 'arg1 arg2 "arg 3"'.scan(QuotedFragment)
   end
 
-  def test_quoted_words
+  def test_single_quoted_words
     assert_equal ['arg1', 'arg2', "'arg 3'"], 'arg1 arg2 \'arg 3\''.scan(QuotedFragment)
   end
 

data/test/{liquid/strainer_test.rb → unit/strainer_unit_test.rb}

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class StrainerTest < Test::Unit::TestCase
+class StrainerUnitTest < Minitest::Test
   include Liquid
 
   module AccessScopeFilters
@@ -22,6 +22,13 @@ class StrainerTest < Test::Unit::TestCase
     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_strainer_only_invokes_public_filter_methods
     strainer = Strainer.create(nil)
     assert_equal false, strainer.invokable?('__test__')
@@ -49,4 +56,16 @@ class StrainerTest < Test::Unit::TestCase
     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
+    Strainer.class_variable_get(:@@filters).each do |m|
+      assert_kind_of m, strainer
+    end
+  end
+
 end # StrainerTest

data/test/unit/tag_unit_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+class TagUnitTest < Minitest::Test
+  include Liquid
+
+  def test_tag
+    tag = Tag.parse('tag', [], [], {})
+    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", [], {})
+    assert_equal("long_tag param1, param2, param3", tag.raw)
+  end
+end

data/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
+  end
+end

data/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
+  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
+  end
+end

data/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
+  end
+end

data/test/unit/template_unit_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class TemplateUnitTest < Minitest::Test
+  include Liquid
+
+  def test_sets_default_localization_in_document
+    t = Template.new
+    t.parse('')
+    assert_instance_of I18n, t.root.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")))
+
+    assert_instance_of I18n, t.root.options[:locale]
+    assert_equal fixture("en_locale.yml"), t.root.options[: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
+end

data/test/unit/tokenizer_unit_test.rb

@@ -0,0 +1,38 @@
+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
+    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)
+  end
+
+  private
+
+  def tokenize(source)
+    Liquid::Template.new.send(:tokenize, source)
+  end
+end

data/test/unit/variable_unit_test.rb

@@ -0,0 +1,139 @@
+require 'test_helper'
+
+class VariableUnitTest < Minitest::Test
+  include Liquid
+
+  def test_variable
+    var = Variable.new('hello')
+    assert_equal VariableLookup.new('hello'), var.name
+  end
+
+  def test_filters
+    var = Variable.new('hello | textileze')
+    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal [['textileze',[]]], var.filters
+
+    var = Variable.new('hello | textileze | paragraph')
+    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal [['textileze',[]], ['paragraph',[]]], var.filters
+
+    var = Variable.new(%! hello | strftime: '%Y'!)
+    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal [['strftime',['%Y']]], var.filters
+
+    var = Variable.new(%! 'typo' | link_to: 'Typo', true !)
+    assert_equal 'typo', var.name
+    assert_equal [['link_to',['Typo', true]]], var.filters
+
+    var = Variable.new(%! 'typo' | link_to: 'Typo', false !)
+    assert_equal 'typo', var.name
+    assert_equal [['link_to',['Typo', false]]], var.filters
+
+    var = Variable.new(%! 'foo' | repeat: 3 !)
+    assert_equal 'foo', var.name
+    assert_equal [['repeat',[3]]], var.filters
+
+    var = Variable.new(%! 'foo' | repeat: 3, 3 !)
+    assert_equal 'foo', var.name
+    assert_equal [['repeat',[3,3]]], var.filters
+
+    var = Variable.new(%! 'foo' | repeat: 3, 3, 3 !)
+    assert_equal 'foo', var.name
+    assert_equal [['repeat',[3,3,3]]], var.filters
+
+    var = Variable.new(%! hello | strftime: '%Y, okay?'!)
+    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal [['strftime',['%Y, okay?']]], var.filters
+
+    var = Variable.new(%! 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 = Variable.new(%! '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 = Variable.new('hello | textileze | paragraph')
+    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal [['textileze',[]], ['paragraph',[]]], var.filters
+
+    var = Variable.new('hello|textileze|paragraph')
+    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal [['textileze',[]], ['paragraph',[]]], var.filters
+
+    var = Variable.new("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)
+    assert_equal VariableLookup.new('http://disney.com/logo.gif'), var.name
+    assert_equal [['image',['med']]], var.filters
+  end
+
+  def test_string_to_filter
+    var = Variable.new("'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 = Variable.new(%| "hello" |)
+    assert_equal 'hello', var.name
+  end
+
+  def test_string_double_quoted
+    var = Variable.new(%| 'hello' |)
+    assert_equal 'hello', var.name
+  end
+
+  def test_integer
+    var = Variable.new(%| 1000 |)
+    assert_equal 1000, var.name
+  end
+
+  def test_float
+    var = Variable.new(%| 1000.01 |)
+    assert_equal 1000.01, var.name
+  end
+
+  def test_string_with_special_chars
+    var = Variable.new(%| 'hello! $!@.;"ddasd" ' |)
+    assert_equal 'hello! $!@.;"ddasd" ', var.name
+  end
+
+  def test_string_dot
+    var = Variable.new(%| 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'!)
+    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)
+    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
+        Variable.new(%! number_of_comments | pluralize: 'comment': 'comments' !)
+      end
+    end
+  end
+
+  def test_output_raw_source_of_variable
+    var = Variable.new(%! name_of_variable | upcase !)
+    assert_equal " name_of_variable | upcase ", var.raw
+  end
+end