liquid 2.6.1 → 4.0.3

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