liquid 2.6.1 → 4.0.3

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

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

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

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].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

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
@@ -18,14 +18,14 @@ class RegexpTest < Test::Unit::TestCase
   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_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/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

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

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.map(&:nodelist).flatten
+  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.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