mango 0.7.1 → 0.8.0

data/vendor/bundler/ruby/2.1.0/gems/liquid-2.6.0/test/liquid/output_test.rb

@@ -0,0 +1,116 @@
+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/vendor/bundler/ruby/2.1.0/gems/liquid-2.6.0/test/liquid/parsing_quirks_test.rb

@@ -0,0 +1,52 @@
+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/vendor/bundler/ruby/2.1.0/gems/liquid-2.6.0/test/liquid/regexp_test.rb

@@ -0,0 +1,44 @@
+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/vendor/bundler/ruby/2.1.0/gems/liquid-2.6.0/test/liquid/security_test.rb

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

data/vendor/bundler/ruby/2.1.0/gems/liquid-2.6.0/test/liquid/standard_filter_test.rb

@@ -0,0 +1,251 @@
+# encoding: utf-8
+
+require 'test_helper'
+
+class Filters
+  include Liquid::StandardFilters
+end
+
+class TestThing
+  def initialize
+    @foo = 0
+  end
+
+  def to_s
+    "woot: #{@foo}"
+  end
+
+  def to_liquid
+    @foo += 1
+    self
+  end
+end
+
+class TestDrop < Liquid::Drop
+  def test
+    "testfoo"
+  end
+end
+
+class StandardFiltersTest < Test::Unit::TestCase
+  include Liquid
+
+  def setup
+    @filters = Filters.new
+  end
+
+  def test_size
+    assert_equal 3, @filters.size([1,2,3])
+    assert_equal 0, @filters.size([])
+    assert_equal 0, @filters.size(nil)
+  end
+
+  def test_downcase
+    assert_equal 'testing', @filters.downcase("Testing")
+    assert_equal '', @filters.downcase(nil)
+  end
+
+  def test_upcase
+    assert_equal 'TESTING', @filters.upcase("Testing")
+    assert_equal '', @filters.upcase(nil)
+  end
+
+  def test_upcase
+    assert_equal 'TESTING', @filters.upcase("Testing")
+    assert_equal '', @filters.upcase(nil)
+  end
+
+  def test_truncate
+    assert_equal '1234...', @filters.truncate('1234567890', 7)
+    assert_equal '1234567890', @filters.truncate('1234567890', 20)
+    assert_equal '...', @filters.truncate('1234567890', 0)
+    assert_equal '1234567890', @filters.truncate('1234567890')
+    assert_equal "测试...", @filters.truncate("测试测试测试测试", 5)
+  end
+
+  def test_strip
+    assert_equal ['12','34'], @filters.split('12~34', '~')
+    assert_equal ['A? ',' ,Z'], @filters.split('A? ~ ~ ~ ,Z', '~ ~ ~')
+    assert_equal ['A?Z'], @filters.split('A?Z', '~')
+    # Regexp works although Liquid does not support.
+    assert_equal ['A','Z'], @filters.split('AxZ', /x/)
+  end
+
+  def test_escape
+    assert_equal '&lt;strong&gt;', @filters.escape('<strong>')
+    assert_equal '&lt;strong&gt;', @filters.h('<strong>')
+  end
+
+  def test_escape_once
+    assert_equal '&lt;strong&gt;', @filters.escape_once(@filters.escape('<strong>'))
+  end
+
+  def test_truncatewords
+    assert_equal 'one two three', @filters.truncatewords('one two three', 4)
+    assert_equal 'one two...', @filters.truncatewords('one two three', 2)
+    assert_equal 'one two three', @filters.truncatewords('one two three')
+    assert_equal 'Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221;...', @filters.truncatewords('Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221; x 16&#8221; x 10.5&#8221; high) with cover.', 15)
+    assert_equal "测试测试测试测试", @filters.truncatewords('测试测试测试测试', 5)
+  end
+
+  def test_strip_html
+    assert_equal 'test', @filters.strip_html("<div>test</div>")
+    assert_equal 'test', @filters.strip_html("<div id='test'>test</div>")
+    assert_equal '', @filters.strip_html("<script type='text/javascript'>document.write('some stuff');</script>")
+    assert_equal '', @filters.strip_html("<style type='text/css'>foo bar</style>")
+    assert_equal 'test', @filters.strip_html("<div\nclass='multiline'>test</div>")
+    assert_equal 'test', @filters.strip_html("<!-- foo bar \n test -->test")
+    assert_equal '', @filters.strip_html(nil)
+  end
+
+  def test_join
+    assert_equal '1 2 3 4', @filters.join([1,2,3,4])
+    assert_equal '1 - 2 - 3 - 4', @filters.join([1,2,3,4], ' - ')
+  end
+
+  def test_sort
+    assert_equal [1,2,3,4], @filters.sort([4,3,2,1])
+    assert_equal [{"a" => 1}, {"a" => 2}, {"a" => 3}, {"a" => 4}], @filters.sort([{"a" => 4}, {"a" => 3}, {"a" => 1}, {"a" => 2}], "a")
+  end
+
+  def test_reverse
+    assert_equal [4,3,2,1], @filters.reverse([1,2,3,4])
+  end
+
+  def test_map
+    assert_equal [1,2,3,4], @filters.map([{"a" => 1}, {"a" => 2}, {"a" => 3}, {"a" => 4}], 'a')
+    assert_template_result 'abc', "{{ ary | map:'foo' | map:'bar' }}",
+      'ary' => [{'foo' => {'bar' => 'a'}}, {'foo' => {'bar' => 'b'}}, {'foo' => {'bar' => 'c'}}]
+  end
+
+  def test_map_doesnt_call_arbitrary_stuff
+    assert_equal "", Liquid::Template.parse('{{ "foo" | map: "__id__" }}').render
+    assert_equal "", Liquid::Template.parse('{{ "foo" | map: "inspect" }}').render
+  end
+
+  def test_map_calls_to_liquid
+    t = TestThing.new
+    assert_equal "woot: 1", Liquid::Template.parse('{{ foo }}').render("foo" => t)
+  end
+
+  def test_map_over_proc
+    drop = TestDrop.new
+    p = Proc.new{ drop }
+    templ = '{{ procs | map: "test" }}'
+    assert_equal "testfoo", Liquid::Template.parse(templ).render("procs" => [p])
+  end
+
+  def test_date
+    assert_equal 'May', @filters.date(Time.parse("2006-05-05 10:00:00"), "%B")
+    assert_equal 'June', @filters.date(Time.parse("2006-06-05 10:00:00"), "%B")
+    assert_equal 'July', @filters.date(Time.parse("2006-07-05 10:00:00"), "%B")
+
+    assert_equal 'May', @filters.date("2006-05-05 10:00:00", "%B")
+    assert_equal 'June', @filters.date("2006-06-05 10:00:00", "%B")
+    assert_equal 'July', @filters.date("2006-07-05 10:00:00", "%B")
+
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", nil)
+
+    assert_equal '07/05/2006', @filters.date("2006-07-05 10:00:00", "%m/%d/%Y")
+
+    assert_equal "07/16/2004", @filters.date("Fri Jul 16 01:00:00 2004", "%m/%d/%Y")
+    assert_equal "#{Date.today.year}", @filters.date('now', '%Y')
+    assert_equal "#{Date.today.year}", @filters.date('today', '%Y')
+
+    assert_equal nil, @filters.date(nil, "%B")
+
+    assert_equal "07/05/2006", @filters.date(1152098955, "%m/%d/%Y")
+    assert_equal "07/05/2006", @filters.date("1152098955", "%m/%d/%Y")
+  end
+
+
+  def test_first_last
+    assert_equal 1, @filters.first([1,2,3])
+    assert_equal 3, @filters.last([1,2,3])
+    assert_equal nil, @filters.first([])
+    assert_equal nil, @filters.last([])
+  end
+
+  def test_replace
+    assert_equal '2 2 2 2', @filters.replace('1 1 1 1', '1', 2)
+    assert_equal '2 1 1 1', @filters.replace_first('1 1 1 1', '1', 2)
+    assert_template_result '2 1 1 1', "{{ '1 1 1 1' | replace_first: '1', 2 }}"
+  end
+
+  def test_remove
+    assert_equal '   ', @filters.remove("a a a a", 'a')
+    assert_equal 'a a a', @filters.remove_first("a a a a", 'a ')
+    assert_template_result 'a a a', "{{ 'a a a a' | remove_first: 'a ' }}"
+  end
+
+  def test_pipes_in_string_arguments
+    assert_template_result 'foobar', "{{ 'foo|bar' | remove: '|' }}"
+  end
+
+  def test_strip_newlines
+    assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\nb\nc"
+    assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\r\nb\nc"
+  end
+
+  def test_newlines_to_br
+    assert_template_result "a<br />\nb<br />\nc", "{{ source | newline_to_br }}", 'source' => "a\nb\nc"
+  end
+
+  def test_plus
+    assert_template_result "2", "{{ 1 | plus:1 }}"
+    assert_template_result "2.0", "{{ '1' | plus:'1.0' }}"
+  end
+
+  def test_minus
+    assert_template_result "4", "{{ input | minus:operand }}", 'input' => 5, 'operand' => 1
+    assert_template_result "2.3", "{{ '4.3' | minus:'2' }}"
+  end
+
+  def test_times
+    assert_template_result "12", "{{ 3 | times:4 }}"
+    assert_template_result "0", "{{ 'foo' | times:4 }}"
+
+    # Ruby v1.9.2-rc1, or higher, backwards compatible Float test
+    assert_match(/(6\.3)|(6\.(0{13})1)/, Template.parse("{{ '2.1' | times:3 }}").render)
+
+    assert_template_result "6", "{{ '2.1' | times:3 | replace: '.','-' | plus:0}}"
+
+    assert_template_result "7.25", "{{ 0.0725 | times:100 }}"
+  end
+
+  def test_divided_by
+    assert_template_result "4", "{{ 12 | divided_by:3 }}"
+    assert_template_result "4", "{{ 14 | divided_by:3 }}"
+
+    # Ruby v1.9.2-rc1, or higher, backwards compatible Float test
+    assert_match(/4\.(6{13,14})7/, Template.parse("{{ 14 | divided_by:'3.0' }}").render)
+
+    assert_template_result "5", "{{ 15 | divided_by:3 }}"
+    assert_template_result "Liquid error: divided by 0", "{{ 5 | divided_by:0 }}"
+
+    assert_template_result "0.5", "{{ 2.0 | divided_by:4 }}"
+  end
+
+  def test_modulo
+    assert_template_result "1", "{{ 3 | modulo:2 }}"
+  end
+
+  def test_append
+    assigns = {'a' => 'bc', 'b' => 'd' }
+    assert_template_result('bcd',"{{ a | append: 'd'}}",assigns)
+    assert_template_result('bcd',"{{ a | append: b}}",assigns)
+  end
+
+  def test_prepend
+    assigns = {'a' => 'bc', 'b' => 'a' }
+    assert_template_result('abc',"{{ a | prepend: 'a'}}",assigns)
+    assert_template_result('abc',"{{ a | prepend: b}}",assigns)
+  end
+
+  def test_cannot_access_private_methods
+    assert_template_result('a',"{{ 'a' | to_number }}")
+  end
+end # StandardFiltersTest