liquid 2.6.3 → 5.4.0

data/test/liquid/error_handling_test.rb

@@ -1,81 +0,0 @@
-require 'test_helper'
-
-class ErrorDrop < Liquid::Drop
-  def standard_error
-    raise Liquid::StandardError, 'standard error'
-  end
-
-  def argument_error
-    raise Liquid::ArgumentError, 'argument error'
-  end
-
-  def syntax_error
-    raise Liquid::SyntaxError, 'syntax error'
-  end
-
-  def exception
-    raise Exception, 'exception'
-  end
-
-end
-
-class ErrorHandlingTest < Test::Unit::TestCase
-  include Liquid
-
-  def test_standard_error
-    assert_nothing_raised do
-      template = Liquid::Template.parse( ' {{ errors.standard_error }} '  )
-      assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
-
-      assert_equal 1, template.errors.size
-      assert_equal StandardError, template.errors.first.class
-    end
-  end
-
-  def test_syntax
-
-    assert_nothing_raised do
-
-      template = Liquid::Template.parse( ' {{ errors.syntax_error }} '  )
-      assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
-
-      assert_equal 1, template.errors.size
-      assert_equal SyntaxError, template.errors.first.class
-
-    end
-  end
-
-  def test_argument
-    assert_nothing_raised do
-
-      template = Liquid::Template.parse( ' {{ errors.argument_error }} '  )
-      assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
-
-      assert_equal 1, template.errors.size
-      assert_equal ArgumentError, template.errors.first.class
-    end
-  end
-
-  def test_missing_endtag_parse_time_error
-    assert_raise(Liquid::SyntaxError) do
-      template = Liquid::Template.parse(' {% for a in b %} ... ')
-    end
-  end
-
-  def test_unrecognized_operator
-    assert_nothing_raised do
-      template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
-      assert_equal ' Liquid error: Unknown operator =! ', template.render
-      assert_equal 1, template.errors.size
-      assert_equal Liquid::ArgumentError, template.errors.first.class
-    end
-  end
-
-  # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
-  def test_exceptions_propagate
-    assert_raise Exception do
-      template = Liquid::Template.parse( ' {{ errors.exception }} '  )
-      template.render('errors' => ErrorDrop.new)
-    end
-  end
-end # ErrorHandlingTest

data/test/liquid/file_system_test.rb

@@ -1,29 +0,0 @@
-require 'test_helper'
-
-class FileSystemTest < Test::Unit::TestCase
-  include Liquid
-
-  def test_default
-    assert_raise(FileSystemError) do
-      BlankFileSystem.new.read_template_file("dummy", {'dummy'=>'smarty'})
-    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_raise(FileSystemError) do
-      file_system.full_path("../dir/mypartial")
-    end
-
-    assert_raise(FileSystemError) do
-      file_system.full_path("/dir/../../dir/mypartial")
-    end
-
-    assert_raise(FileSystemError) do
-      file_system.full_path("/etc/passwd")
-    end
-  end
-end # FileSystemTest

data/test/liquid/filter_test.rb

@@ -1,125 +0,0 @@
-require 'test_helper'
-
-module MoneyFilter
-  def money(input)
-    sprintf(' %d$ ', input)
-  end
-
-  def money_with_underscore(input)
-    sprintf(' %d$ ', input)
-  end
-end
-
-module CanadianMoneyFilter
-  def money(input)
-    sprintf(' %d$ CAD ', input)
-  end
-end
-
-module SubstituteFilter
-  def substitute(input, params={})
-    input.gsub(/%\{(\w+)\}/) { |match| params[$1] }
-  end
-end
-
-class FiltersTest < Test::Unit::TestCase
-  include Liquid
-
-  def setup
-    @context = Context.new
-  end
-
-  def test_local_filter
-    @context['var'] = 1000
-    @context.add_filters(MoneyFilter)
-
-    assert_equal ' 1000$ ', Variable.new("var | money").render(@context)
-  end
-
-  def test_underscore_in_filter_name
-    @context['var'] = 1000
-    @context.add_filters(MoneyFilter)
-    assert_equal ' 1000$ ', Variable.new("var | money_with_underscore").render(@context)
-  end
-
-  def test_second_filter_overwrites_first
-    @context['var'] = 1000
-    @context.add_filters(MoneyFilter)
-    @context.add_filters(CanadianMoneyFilter)
-
-    assert_equal ' 1000$ CAD ', Variable.new("var | money").render(@context)
-  end
-
-  def test_size
-    @context['var'] = 'abcd'
-    @context.add_filters(MoneyFilter)
-
-    assert_equal 4, Variable.new("var | size").render(@context)
-  end
-
-  def test_join
-    @context['var'] = [1,2,3,4]
-
-    assert_equal "1 2 3 4", Variable.new("var | join").render(@context)
-  end
-
-  def test_sort
-    @context['value'] = 3
-    @context['numbers'] = [2,1,4,3]
-    @context['words'] = ['expected', 'as', 'alphabetic']
-    @context['arrays'] = [['flattened'], ['are']]
-
-    assert_equal [1,2,3,4], Variable.new("numbers | sort").render(@context)
-    assert_equal ['alphabetic', 'as', 'expected'], Variable.new("words | sort").render(@context)
-    assert_equal [3], Variable.new("value | sort").render(@context)
-    assert_equal ['are', 'flattened'], Variable.new("arrays | sort").render(@context)
-  end
-
-  def test_strip_html
-    @context['var'] = "<b>bla blub</a>"
-
-    assert_equal "bla blub", Variable.new("var | strip_html").render(@context)
-  end
-
-  def test_strip_html_ignore_comments_with_html
-    @context['var'] = "<!-- split and some <ul> tag --><b>bla blub</a>"
-
-    assert_equal "bla blub", Variable.new("var | strip_html").render(@context)
-  end
-
-  def test_capitalize
-    @context['var'] = "blub"
-
-    assert_equal "Blub", Variable.new("var | capitalize").render(@context)
-  end
-
-  def test_nonexistent_filter_is_ignored
-    @context['var'] = 1000
-
-    assert_equal 1000, Variable.new("var | xyzzy").render(@context)
-  end
-
-  def test_filter_with_keyword_arguments
-    @context['surname'] = 'john'
-    @context.add_filters(SubstituteFilter)
-    output = Variable.new(%! 'hello %{first_name}, %{last_name}' | substitute: first_name: surname, last_name: 'doe' !).render(@context)
-    assert_equal 'hello john, doe', output
-  end
-end
-
-class FiltersInTemplate < Test::Unit::TestCase
-  include Liquid
-
-  def test_local_global
-    Template.register_filter(MoneyFilter)
-
-    assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render(nil, nil)
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, :filters => CanadianMoneyFilter)
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, :filters => [CanadianMoneyFilter])
-  end
-
-  def test_local_filter_with_deprecated_syntax
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, CanadianMoneyFilter)
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, [CanadianMoneyFilter])
-  end
-end # FiltersTest

data/test/liquid/hash_ordering_test.rb

@@ -1,25 +0,0 @@
-require 'test_helper'
-
-module MoneyFilter
-  def money(input)
-    sprintf(' %d$ ', input)
-  end
-end
-
-module CanadianMoneyFilter
-  def money(input)
-    sprintf(' %d$ CAD ', input)
-  end
-end
-
-class HashOrderingTest < Test::Unit::TestCase
-  include Liquid
-
- def test_global_register_order
-    Template.register_filter(MoneyFilter)
-    Template.register_filter(CanadianMoneyFilter)
-
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, nil)
- end
-
-end

data/test/liquid/module_ex_test.rb

@@ -1,87 +0,0 @@
-require 'test_helper'
-
-class TestClassA
-  liquid_methods :allowedA, :chainedB
-  def allowedA
-    'allowedA'
-  end
-  def restrictedA
-    'restrictedA'
-  end
-  def chainedB
-    TestClassB.new
-  end
-end
-
-class TestClassB
-  liquid_methods :allowedB, :chainedC
-  def allowedB
-    'allowedB'
-  end
-  def chainedC
-    TestClassC.new
-  end
-end
-
-class TestClassC
-  liquid_methods :allowedC
-  def allowedC
-    'allowedC'
-  end
-end
-
-class TestClassC::LiquidDropClass
-  def another_allowedC
-    'another_allowedC'
-  end
-end
-
-class ModuleExTest < Test::Unit::TestCase
-  include Liquid
-
-  def setup
-    @a = TestClassA.new
-    @b = TestClassB.new
-    @c = TestClassC.new
-  end
-
-  def test_should_create_LiquidDropClass
-    assert TestClassA::LiquidDropClass
-    assert TestClassB::LiquidDropClass
-    assert TestClassC::LiquidDropClass
-  end
-
-  def test_should_respond_to_liquid
-    assert @a.respond_to?(:to_liquid)
-    assert @b.respond_to?(:to_liquid)
-    assert @c.respond_to?(:to_liquid)
-  end
-
-  def test_should_return_LiquidDropClass_object
-    assert @a.to_liquid.is_a?(TestClassA::LiquidDropClass)
-    assert @b.to_liquid.is_a?(TestClassB::LiquidDropClass)
-    assert @c.to_liquid.is_a?(TestClassC::LiquidDropClass)
-  end
-
-  def test_should_respond_to_liquid_methods
-    assert @a.to_liquid.respond_to?(:allowedA)
-    assert @a.to_liquid.respond_to?(:chainedB)
-    assert @b.to_liquid.respond_to?(:allowedB)
-    assert @b.to_liquid.respond_to?(:chainedC)
-    assert @c.to_liquid.respond_to?(:allowedC)
-    assert @c.to_liquid.respond_to?(:another_allowedC)
-  end
-
-  def test_should_not_respond_to_restricted_methods
-    assert ! @a.to_liquid.respond_to?(:restricted)
-  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)
-  end
-end # ModuleExTest

data/test/liquid/output_test.rb

@@ -1,116 +0,0 @@
-require 'test_helper'
-
-module FunnyFilter
-  def make_funny(input)
-    'LOL'
-  end
-
-  def cite_funny(input)
-    "LOL: #{input}"
-  end
-
-  def add_smiley(input, smiley = ":-)")
-    "#{input} #{smiley}"
-  end
-
-  def add_tag(input, tag = "p", id = "foo")
-    %|<#{tag} id="#{id}">#{input}</#{tag}>|
-  end
-
-  def paragraph(input)
-    "<p>#{input}</p>"
-  end
-
-  def link_to(name, url)
-    %|<a href="#{url}">#{name}</a>|
-  end
-
-end
-
-class OutputTest < Test::Unit::TestCase
-  include Liquid
-
-  def setup
-    @assigns = {
-      'best_cars' => 'bmw',
-      'car' => {'bmw' => 'good', 'gm' => 'bad'}
-      }
-  end
-
-  def test_variable
-    text = %| {{best_cars}} |
-
-    expected = %| bmw |
-    assert_equal expected, Template.parse(text).render(@assigns)
-  end
-
-  def test_variable_traversing
-    text = %| {{car.bmw}} {{car.gm}} {{car.bmw}} |
-
-    expected = %| good bad good |
-    assert_equal expected, Template.parse(text).render(@assigns)
-  end
-
-  def test_variable_piping
-    text = %( {{ car.gm | make_funny }} )
-    expected = %| LOL |
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-
-  def test_variable_piping_with_input
-    text = %( {{ car.gm | cite_funny }} )
-    expected = %| LOL: bad |
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-
-  def test_variable_piping_with_args
-    text = %! {{ car.gm | add_smiley : ':-(' }} !
-    expected = %| bad :-( |
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-
-  def test_variable_piping_with_no_args
-    text = %! {{ car.gm | add_smiley }} !
-    expected = %| bad :-) |
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-
-  def test_multiple_variable_piping_with_args
-    text = %! {{ car.gm | add_smiley : ':-(' | add_smiley : ':-('}} !
-    expected = %| bad :-( :-( |
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-
-  def test_variable_piping_with_args
-    text = %! {{ car.gm | add_tag : 'span', 'bar'}} !
-    expected = %| <span id="bar">bad</span> |
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-
-  def test_variable_piping_with_variable_args
-    text = %! {{ car.gm | add_tag : 'span', car.bmw}} !
-    expected = %| <span id="good">bad</span> |
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-
-  def test_multiple_pipings
-    text = %( {{ best_cars | cite_funny | paragraph }} )
-    expected = %| <p>LOL: bmw</p> |
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-
-  def test_link_to
-    text = %( {{ 'Typo' | link_to: 'http://typo.leetsoft.com' }} )
-    expected = %| <a href="http://typo.leetsoft.com">Typo</a> |
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
-  end
-end # OutputTest

data/test/liquid/parsing_quirks_test.rb

@@ -1,52 +0,0 @@
-require 'test_helper'
-
-class ParsingQuirksTest < Test::Unit::TestCase
-  include Liquid
-
-  def test_error_with_css
-    text = %| div { font-weight: bold; } |
-    template = Template.parse(text)
-
-    assert_equal text, template.render
-    assert_equal [String], template.root.nodelist.collect {|i| i.class}
-  end
-
-  def test_raise_on_single_close_bracet
-    assert_raise(SyntaxError) do
-      Template.parse("text {{method} oh nos!")
-    end
-  end
-
-  def test_raise_on_label_and_no_close_bracets
-    assert_raise(SyntaxError) do
-      Template.parse("TEST {{ ")
-    end
-  end
-
-  def test_raise_on_label_and_no_close_bracets_percent
-    assert_raise(SyntaxError) do
-      Template.parse("TEST {% ")
-    end
-  end
-
-  def test_error_on_empty_filter
-    assert_nothing_raised do
-      Template.parse("{{test |a|b|}}")
-      Template.parse("{{test}}")
-      Template.parse("{{|test|}}")
-    end
-  end
-
-  def test_meaningless_parens
-    assigns = {'b' => 'bar', 'c' => 'baz'}
-    markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
-    assert_template_result(' YES ',"{% if #{markup} %} YES {% endif %}", assigns)
-  end
-
-  def test_unexpected_characters_silently_eat_logic
-    markup = "true && false"
-    assert_template_result(' YES ',"{% if #{markup} %} YES {% endif %}")
-    markup = "false || true"
-    assert_template_result('',"{% if #{markup} %} YES {% endif %}")
-  end
-end # ParsingQuirksTest

data/test/liquid/regexp_test.rb

@@ -1,44 +0,0 @@
-require 'test_helper'
-
-class RegexpTest < Test::Unit::TestCase
-  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_quoted_words
-    assert_equal ['arg1', 'arg2', '"arg 3"'], 'arg1 arg2 "arg 3"'.scan(QuotedFragment)
-  end
-
-  def test_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/liquid/security_test.rb

@@ -1,64 +0,0 @@
-require 'test_helper'
-
-module SecurityFilter
-  def add_one(input)
-    "#{input} + 1"
-  end
-end
-
-class SecurityTest < Test::Unit::TestCase
-  include Liquid
-
-  def test_no_instance_eval
-    text = %( {{ '1+1' | instance_eval }} )
-    expected = %| 1+1 |
-
-    assert_equal expected, Template.parse(text).render(@assigns)
-  end
-
-  def test_no_existing_instance_eval
-    text = %( {{ '1+1' | __instance_eval__ }} )
-    expected = %| 1+1 |
-
-    assert_equal expected, Template.parse(text).render(@assigns)
-  end
-
-
-  def test_no_instance_eval_after_mixing_in_new_filter
-    text = %( {{ '1+1' | instance_eval }} )
-    expected = %| 1+1 |
-
-    assert_equal expected, Template.parse(text).render(@assigns)
-  end
-
-
-  def test_no_instance_eval_later_in_chain
-    text = %( {{ '1+1' | add_one | instance_eval }} )
-    expected = %| 1+1 + 1 |
-
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => SecurityFilter)
-  end
-
-  def test_does_not_add_filters_to_symbol_table
-    current_symbols = Symbol.all_symbols
-
-    test = %( {{ "some_string" | a_bad_filter }} )
-
-    template = Template.parse(test)
-    assert_equal [], (Symbol.all_symbols - current_symbols)
-
-    template.render
-    assert_equal [], (Symbol.all_symbols - current_symbols)
-  end
-
-  def test_does_not_add_drop_methods_to_symbol_table
-    current_symbols = Symbol.all_symbols
-
-    drop = Drop.new
-    drop.invoke_drop("custom_method_1")
-    drop.invoke_drop("custom_method_2")
-    drop.invoke_drop("custom_method_3")
-
-    assert_equal [], (Symbol.all_symbols - current_symbols)
-  end
-end # SecurityTest