padrino-helpers 0.12.0 → 0.12.1

data/test/test_format_helpers.rb

@@ -12,80 +12,80 @@ describe "FormatHelpers" do
     Time.stubs(:now).returns(Time.utc(1983, 11, 9, 5))
   end
 
-  context 'for #simple_format method' do
-    should "format simple text into html format" do
+  describe 'for #simple_format method' do
+    it 'should format simple text into html format' do
       actual_text = simple_format("Here is some basic text...\n...with a line break.")
       assert_equal true, actual_text.html_safe?
       assert_equal "<p>Here is some basic text...\n<br />...with a line break.</p>", actual_text
     end
 
-    should "format more text into html format" do
+    it 'should format more text into html format' do
       actual_text = simple_format("We want to put a paragraph...\n\n...right there.")
       assert_equal "<p>We want to put a paragraph...</p>\n\n<p>...right there.</p>", actual_text
     end
 
-    should "support defining a class for the paragraphs" do
+    it 'should support defining a class for the paragraphs' do
       actual_text = simple_format("Look me! A class!", :class => 'description')
       assert_equal "<p class=\"description\">Look me! A class!</p>", actual_text
     end
 
-    should "escape html tags" do
+    it 'should escape html tags' do
       actual_text = simple_format("Will you escape <b>that</b>?")
       assert_equal "<p>Will you escape &lt;b&gt;that&lt;&#x2F;b&gt;?</p>", actual_text
     end
 
-    should "support already sanitized text" do
+    it 'should support already sanitized text' do
       actual_text = simple_format("Don't try to escape <b>me</b>!".html_safe)
       assert_equal "<p>Don't try to escape <b>me</b>!</p>", actual_text
     end
 
-    context 'wrapped in a custom tag' do
-      should "format simple text into html format" do
+    describe 'wrapped in a custom tag' do
+      it 'should format simple text into html format' do
         actual_text = simple_format("Here is some basic text...\n...with a line break.", :tag => :div)
         assert_equal "<div>Here is some basic text...\n<br />...with a line break.</div>", actual_text
       end
 
-      should "format more text into html format" do
+      it 'should format more text into html format' do
         actual_text = simple_format("We want to put a paragraph...\n\n...right there.", :tag => :div)
         assert_equal "<div>We want to put a paragraph...</div>\n\n<div>...right there.</div>", actual_text
       end
 
-      should "support defining a class for the paragraphs" do
+      it 'should support defining a class for the paragraphs' do
         actual_text = simple_format("Look me! A class!", :class => 'description', :tag => :div)
         assert_equal "<div class=\"description\">Look me! A class!</div>", actual_text
       end
     end
   end
 
-  context 'for #pluralize method' do
-    should "return singular count for 1 item collections" do
+  describe 'for #pluralize method' do
+    it 'should return singular count for 1 item collections' do
       actual_text = pluralize(1, 'person')
       assert_equal '1 person', actual_text
     end
-    should "return plural count for empty collections" do
+    it 'should return plural count for empty collections' do
       actual_text = pluralize(0, 'person')
       assert_equal '0 people', actual_text
     end
-    should "return plural count for many collections" do
+    it 'should return plural count for many collections' do
       actual_text =  pluralize(2, 'person')
       assert_equal '2 people', actual_text
     end
-    should "return pluralized word specified as argument" do
+    it 'should return pluralized word specified as argument' do
       actual_text =  pluralize(3, 'person', 'users')
       assert_equal '3 users', actual_text
     end
   end
 
-  context 'for #word_wrap method' do
-    should "return proper formatting for 8 max width" do
+  describe 'for #word_wrap method' do
+    it 'should return proper formatting for 8 max width' do
       actual_text = word_wrap('Once upon a time', :line_width => 8)
       assert_equal "Once\nupon a\ntime", actual_text
     end
-    should "return proper formatting for 1 max width" do
+    it 'should return proper formatting for 1 max width' do
       actual_text = word_wrap('Once upon a time', :line_width => 1)
       assert_equal "Once\nupon\na\ntime", actual_text
     end
-    should "return proper formatting for default width" do
+    it 'should return proper formatting for default width' do
       actual_text = word_wrap((1..50).to_a.join(" "))
       assert_equal (1..30).to_a.join(" ") + "\n" + (31..50).to_a.join(" "), actual_text
       actual_text = word_wrap((1..50).to_a.join(" "), 80)
@@ -93,157 +93,157 @@ describe "FormatHelpers" do
     end
   end
 
-  context 'for #highlight method' do
-    should 'highligth with defaults' do
+  describe 'for #highlight method' do
+    it 'should highligth with defaults' do
       actual_text = highlight('Lorem ipsum dolor sit amet', 'dolor')
       assert_equal 'Lorem ipsum <strong class="highlight">dolor</strong> sit amet', actual_text
     end
 
-    should 'highlight with highlighter' do
+    it 'should highlight with highlighter' do
       actual_text = highlight('Lorem ipsum dolor sit amet', 'dolor', :highlighter => '<span class="custom">\1</span>')
       assert_equal 'Lorem ipsum <span class="custom">dolor</span> sit amet', actual_text
     end
   end
 
-  context 'for #truncate method' do
-    should "support default truncation" do
+  describe 'for #truncate method' do
+    it 'should support default truncation' do
       actual_text = truncate("Once upon a time in a world far far away")
       assert_equal "Once upon a time in a world...", actual_text
     end
-    should "support specifying length" do
+    it 'should support specifying length' do
       actual_text = truncate("Once upon a time in a world far far away", :length => 14)
       assert_equal "Once upon a...", actual_text
     end
-    should "support specifying omission text" do
+    it 'should support specifying omission text' do
       actual_text = truncate("And they found that many people were sleeping better.", :length => 25, :omission => "(clipped)")
       assert_equal "And they found t(clipped)", actual_text
     end
   end
 
-  context 'for #truncate_words method' do
-    should "support default truncation" do
+  describe 'for #truncate_words method' do
+    it 'should support default truncation' do
       actual_text = truncate_words("Long before books were made, people told stories. They told them to one another and to the children as they sat before the fire. Many of these stories were about interesting people, but most of them were about the ways of fairies and giants.")
       assert_equal "Long before books were made, people told stories. They told them to one another and to the children as they sat before the fire. Many of these stories were about...", actual_text
     end
-    should "support specifying length" do
+    it 'should support specifying length' do
       actual_text = truncate_words("Once upon a time in a world far far away", :length => 8)
       assert_equal "Once upon a time in a world far...", actual_text
     end
-    should "support specifying omission text" do
+    it 'should support specifying omission text' do
       actual_text = truncate_words("And they found that many people were sleeping better.", :length => 4, :omission => "(clipped)")
       assert_equal "And they found that(clipped)", actual_text
     end
   end
 
-  context 'for #h and #h! method' do
-    should "escape the simple html" do
+  describe 'for #h and #h! method' do
+    it 'should escape the simple html' do
       assert_equal '&lt;h1&gt;hello&lt;&#x2F;h1&gt;', h('<h1>hello</h1>')
       assert_equal '&lt;h1&gt;hello&lt;&#x2F;h1&gt;', escape_html('<h1>hello</h1>')
     end
-    should "escape all brackets, quotes and ampersands" do
+    it 'should escape all brackets, quotes and ampersands' do
       assert_equal '&lt;h1&gt;&lt;&gt;&quot;&amp;demo&amp;&quot;&lt;&gt;&lt;&#x2F;h1&gt;', h('<h1><>"&demo&"<></h1>')
     end
-    should "return default text if text is empty" do
+    it 'should return default text if text is empty' do
       assert_equal 'default', h!("", "default")
       assert_equal '&nbsp;', h!("")
     end
-    should "return text escaped if not empty" do
+    it 'should return text escaped if not empty' do
       assert_equal '&lt;h1&gt;hello&lt;&#x2F;h1&gt;', h!('<h1>hello</h1>')
     end
-    should "mark escaped text as safe" do
+    it 'should mark escaped text as safe' do
       assert_equal false, '<h1>hello</h1>'.html_safe?
       assert_equal true, h('<h1>hello</h1>').html_safe?
       assert_equal true, h!("", "default").html_safe?
     end
   end
 
-  context 'for #time_ago_in_words method' do
-    should "less than 5 seconds" do
+  describe 'for #time_ago_in_words method' do
+    it 'should less than 5 seconds' do
       assert_equal 'less than 5 seconds', time_ago_in_words(Time.now, true)
     end
-    should "less than 10 seconds" do
+    it 'should less than 10 seconds' do
       assert_equal 'less than 10 seconds', time_ago_in_words(Time.now-5, true)
     end
-    should "less than 20 seconds" do
+    it 'should less than 20 seconds' do
       assert_equal 'less than 20 seconds', time_ago_in_words(Time.now-10, true)
     end
-    should "less than a minute" do
+    it 'should less than a minute' do
       assert_equal 'less than a minute', time_ago_in_words(Time.now-40, true)
     end
-    should "2 minutes" do
+    it 'should 2 minutes' do
       assert_equal '2 minutes', time_ago_in_words(Time.now-120, true)
     end
-    should "display today" do
+    it 'should display today' do
       assert_equal 'less than a minute', time_ago_in_words(Time.now)
     end
-    should "display yesterday" do
+    it 'should display yesterday' do
       assert_equal '1 day', time_ago_in_words(1.day.ago)
     end
-    should "display tomorrow" do
+    it 'should display tomorrow' do
       assert_equal '1 day', time_ago_in_words(1.day.from_now)
     end
-    should "return future number of days" do
+    it 'should return future number of days' do
       assert_equal '4 days', time_ago_in_words(4.days.from_now)
     end
-    should "return past days ago" do
+    it 'should return past days ago' do
       assert_equal '4 days', time_ago_in_words(4.days.ago)
     end
-    should "return formatted archived date" do
+    it 'should return formatted archived date' do
       assert_equal '3 months', time_ago_in_words(100.days.ago)
     end
-    should "return formatted archived year date" do
+    it 'should return formatted archived year date' do
       assert_equal 'over 1 year', time_ago_in_words(500.days.ago)
     end
-    should 'display now as a minute ago' do
+    it 'should display now as a minute ago' do
       assert_equal '1 minute', time_ago_in_words(1.minute.ago)
     end
-    should "display a few minutes ago" do
+    it 'should display a few minutes ago' do
       assert_equal '4 minutes', time_ago_in_words(4.minute.ago)
     end
-    should "display an hour ago" do
+    it 'should display an hour ago' do
       assert_equal 'about 1 hour', time_ago_in_words(1.hour.ago + 5.minutes.ago.sec)
     end
-    should "display a few hours ago" do
+    it 'should display a few hours ago' do
       assert_equal 'about 3 hours', time_ago_in_words(3.hour.ago + 5.minutes.ago.sec)
     end
-    should "display a day ago" do
+    it 'should display a day ago' do
       assert_equal '1 day', time_ago_in_words(1.day.ago)
     end
-    should "display a few days ago" do
+    it 'should display a few days ago' do
       assert_equal '5 days', time_ago_in_words(5.days.ago - 5.minutes.ago.sec)
     end
-    should "display a month ago" do
+    it 'should display a month ago' do
       assert_equal 'about 1 month', time_ago_in_words(32.days.ago + 5.minutes.ago.sec)
     end
-    should "display a few months ago" do
+    it 'should display a few months ago' do
       assert_equal '6 months', time_ago_in_words(180.days.ago - 5.minutes.ago.sec)
     end
-    should "display a year ago" do
+    it 'should display a year ago' do
       assert_equal 'about 1 year', time_ago_in_words(365.days.ago - 5.minutes.ago.sec)
     end
-    should "display a few years ago" do
+    it 'should display a few years ago' do
       assert_equal 'over 7 years', time_ago_in_words(2800.days.ago - 5.minutes.ago.sec)
     end
   end
 
-  context 'for #js_escape_html method' do
-    should "escape double quotes" do
+  describe 'for #js_escape_html method' do
+    it 'should escape double quotes' do
       assert_equal "\\\"hello\\\"", js_escape_html('"hello"')
       assert_equal "\\\"hello\\\"", js_escape_html(ActiveSupport::SafeBuffer.new('"hello"'))
     end
-    should "escape single quotes" do
+    it 'should escape single quotes' do
       assert_equal "\\'hello\\'", js_escape_html("'hello'")
       assert_equal "\\'hello\\'", js_escape_html(ActiveSupport::SafeBuffer.new("'hello'"))
     end
-    should "escape html tags and breaks" do
+    it 'should escape html tags and breaks' do
       assert_equal "\\n\\n<p>hello<\\/p>\\n", js_escape_html("\n\r<p>hello</p>\r\n")
       assert_equal "\\n\\n<p>hello<\\/p>\\n", js_escape_html(ActiveSupport::SafeBuffer.new("\n\r<p>hello</p>\r\n"))
     end
-    should "escape data-confirm attribute" do
+    it 'should escape data-confirm attribute' do
       assert_equal "<data-confirm=\\\"are you sure\\\">", js_escape_html("<data-confirm=\"are you sure\">")
       assert_equal "<data-confirm=\\\"are you sure\\\">", js_escape_html(ActiveSupport::SafeBuffer.new("<data-confirm=\"are you sure\">"))
     end
-    should "keep html_safe content html_safe" do
+    it 'should keep html_safe content html_safe' do
       assert_equal false, js_escape_html('"hello"').html_safe?
       assert_equal true, js_escape_html(ActiveSupport::SafeBuffer.new('"hello"')).html_safe?
     end

data/test/test_locale.rb

@@ -4,7 +4,7 @@ describe "Locale Helpers" do
   Dir[File.expand_path("../../lib/padrino-helpers/locale/*.yml", __FILE__)].each do |file|
     base_original = YAML.load_file(file)
     name = File.basename(file, '.yml')
-    should "should have correct locale for #{name}" do
+    it "should should have correct locale for #{name}" do
       base = base_original[name]['number']['format']
       assert !base['separator'].nil?
       assert !base['delimiter'].nil?

data/test/test_number_helpers.rb

@@ -24,9 +24,8 @@ describe "NumberHelpers" do
     gigabytes(number) * 1024
   end
 
-  context 'for number helpers functionality' do
-
-    should 'display number_to_currency' do
+  describe 'for number helpers functionality' do
+    it 'should display number_to_currency' do
       assert_equal "$1,234,567,890.50",        number_to_currency(1234567890.50)
       assert_equal "$1,234,567,890.51",        number_to_currency(1234567890.506)
       assert_equal "$1,234,567,892",           number_to_currency(1234567891.50, {:precision => 0})
@@ -39,7 +38,7 @@ describe "NumberHelpers" do
       assert_nil number_to_currency(nil)
     end
 
-    should 'display  number_to_percentage' do
+    it 'should display  number_to_percentage' do
       assert_equal "100.000%",   number_to_percentage(100)
       assert_equal "100%",       number_to_percentage(100, {:precision => 0})
       assert_equal "302.06%",    number_to_percentage(302.0574, {:precision => 2})
@@ -51,7 +50,7 @@ describe "NumberHelpers" do
       assert_nil number_to_percentage(nil)
     end
 
-    should 'display  number_with_delimiter' do
+    it 'should display  number_with_delimiter' do
       assert_equal "12,345,678",        number_with_delimiter(12345678)
       assert_equal "0",                 number_with_delimiter(0)
       assert_equal "123",               number_with_delimiter(123)
@@ -67,14 +66,14 @@ describe "NumberHelpers" do
       assert_nil number_with_delimiter(nil)
     end
 
-    should 'display number_with_delimiter with options' do
+    it 'should display number_with_delimiter with options' do
       assert_equal '12 345 678',    number_with_delimiter(12345678, :delimiter => ' ')
       assert_equal '12,345,678-05', number_with_delimiter(12345678.05, :separator => '-')
       assert_equal '12.345.678,05', number_with_delimiter(12345678.05, :separator => ',', :delimiter => '.')
       assert_equal '12.345.678,05', number_with_delimiter(12345678.05, :delimiter => '.', :separator => ',')
     end
 
-    should 'display number_with_precision' do
+    it 'should display number_with_precision' do
       assert_equal "111.235",    number_with_precision(111.2346)
       assert_equal "31.83",      number_with_precision(31.825, :precision => 2)
       assert_equal "111.23",     number_with_precision(111.2346, :precision => 2)
@@ -90,12 +89,12 @@ describe "NumberHelpers" do
       assert_nil number_with_precision(nil)
     end
 
-    should 'display number_with_precision with custom delimiter and separator' do
+    it 'should display number_with_precision with custom delimiter and separator' do
       assert_equal '31,83',     number_with_precision(31.825, :precision => 2, :separator => ',')
       assert_equal '1.231,83',  number_with_precision(1231.825, :precision => 2, :separator => ',', :delimiter => '.')
     end
 
-    should 'display number_to_human_size' do
+    it 'should display number_to_human_size' do
       assert_equal '0 Bytes',   number_to_human_size(0)
       assert_equal '1 Byte',    number_to_human_size(1)
       assert_equal '3 Bytes',   number_to_human_size(3.14159265)
@@ -122,7 +121,7 @@ describe "NumberHelpers" do
       assert_nil number_to_human_size(nil)
     end
 
-    should 'display number_to_human_size with options' do
+    it 'should display number_to_human_size with options' do
       assert_equal '1.18 MB', number_to_human_size(1234567, :precision => 2)
       assert_equal '3 Bytes', number_to_human_size(3.14159265, :precision => 4)
       assert_equal '1.01 KB', number_to_human_size(kilobytes(1.0123), :precision => 2)
@@ -134,7 +133,7 @@ describe "NumberHelpers" do
       assert_equal '40 KB',   number_to_human_size(41100, :precision => 0)
     end
 
-    should 'display number_to_human_size with custom delimiter and separator' do
+    it 'should display number_to_human_size with custom delimiter and separator' do
       assert_equal '1,01 KB',     number_to_human_size(kilobytes(1.0123), :precision => 2, :separator => ',')
       assert_equal '1,01 KB',     number_to_human_size(kilobytes(1.0100), :precision => 4, :separator => ',')
       assert_equal '1.000,1 TB',  number_to_human_size(terabytes(1000.1), :delimiter => '.', :separator => ',')

data/test/test_output_helpers.rb

@@ -6,8 +6,8 @@ describe "OutputHelpers" do
     MarkupDemo
   end
 
-  context 'for #content_for method' do
-    should 'work for erb templates' do
+  describe 'for #content_for method' do
+    it 'should work for erb templates' do
       visit '/erb/content_for'
       assert_have_selector '.demo h1', :content => "This is content yielded from a content_for", :count => 1
       assert_have_selector '.demo2 h1', :content => "This is content yielded with name Johnny Smith", :count => 1
@@ -15,7 +15,7 @@ describe "OutputHelpers" do
       assert_have_selector '.demo3 p', :content => "Two", :class => "duplication"
     end
 
-    should "work for haml templates" do
+    it 'should work for haml templates' do
       visit '/haml/content_for'
       assert_have_selector '.demo h1', :content => "This is content yielded from a content_for", :count => 1
       assert_have_selector '.demo2 h1', :content => "This is content yielded with name Johnny Smith", :count => 1
@@ -23,7 +23,7 @@ describe "OutputHelpers" do
       assert_have_selector '.demo3 p', :content => "Two", :class => "duplication"
     end
 
-    should "work for slim templates" do
+    it 'should work for slim templates' do
       visit '/slim/content_for'
       assert_have_selector '.demo h1', :content => "This is content yielded from a content_for", :count => 1
       assert_have_selector '.demo2 h1', :content => "This is content yielded with name Johnny Smith", :count => 1
@@ -32,85 +32,85 @@ describe "OutputHelpers" do
     end
   end # content_for
 
-  context "for #content_for? method" do
-    should 'work for erb templates' do
+  describe "for #content_for? method" do
+    it 'should work for erb templates' do
       visit '/erb/content_for'
       assert_have_selector '.demo_has_content', :content => "true"
       assert_have_selector '.fake_has_content', :content => "false"
     end
 
-    should "work for haml templates" do
+    it 'should work for haml templates' do
       visit '/haml/content_for'
       assert_have_selector '.demo_has_content', :content => "true"
       assert_have_selector '.fake_has_content', :content => "false"
     end
 
-    should "work for slim templates" do
+    it 'should work for slim templates' do
       visit '/slim/content_for'
       assert_have_selector '.demo_has_content', :content => "true"
       assert_have_selector '.fake_has_content', :content => "false"
     end
   end # content_for?
 
-  context 'for #capture_html method' do
-    should "work for erb templates" do
+  describe 'for #capture_html method' do
+    it 'should work for erb templates' do
       visit '/erb/capture_concat'
       assert_have_selector 'p span', :content => "Captured Line 1", :count => 1
       assert_have_selector 'p span', :content => "Captured Line 2", :count => 1
     end
 
-    should "work for haml templates" do
+    it 'should work for haml templates' do
       visit '/haml/capture_concat'
       assert_have_selector 'p span', :content => "Captured Line 1", :count => 1
       assert_have_selector 'p span', :content => "Captured Line 2", :count => 1
     end
 
-    should "work for slim templates" do
+    it 'should work for slim templates' do
       visit '/slim/capture_concat'
       assert_have_selector 'p span', :content => "Captured Line 1", :count => 1
       assert_have_selector 'p span', :content => "Captured Line 2", :count => 1
     end
   end
 
-  context 'for #concat_content method' do
-    should "work for erb templates" do
+  describe 'for #concat_content method' do
+    it 'should work for erb templates' do
       visit '/erb/capture_concat'
       assert_have_selector 'p', :content => "Concat Line 3", :count => 1
     end
 
-    should "work for haml templates" do
+    it 'should work for haml templates' do
       visit '/haml/capture_concat'
       assert_have_selector 'p', :content => "Concat Line 3", :count => 1
     end
 
-    should "work for slim templates" do
+    it 'should work for slim templates' do
       visit '/slim/capture_concat'
       assert_have_selector 'p', :content => "Concat Line 3", :count => 1
     end
   end
 
-  context 'for #block_is_template?' do
-    should "work for erb templates" do
+  describe 'for #block_is_template?' do
+    it 'should work for erb templates' do
       visit '/erb/capture_concat'
       assert_have_selector 'p', :content => "The erb block passed in is a template", :class => 'is_template', :count => 1
       assert_have_no_selector 'p', :content => "The ruby block passed in is a template", :class => 'is_template', :count => 1
     end
 
-    should "work for haml templates" do
+    it 'should work for haml templates' do
       visit '/haml/capture_concat'
       assert_have_selector 'p', :content => "The haml block passed in is a template", :class => 'is_template', :count => 1
       assert_have_no_selector 'p', :content => "The ruby block passed in is a template", :class => 'is_template', :count => 1
     end
 
-    should "work for slim templates" do
+    it 'should work for slim templates' do
       visit '/slim/capture_concat'
       assert_have_selector 'p', :content => "The slim block passed in is a template", :class => 'is_template', :count => 1
       assert_have_no_selector 'p', :content => "The ruby block passed in is a template", :class => 'is_template', :count => 1
     end
   end
 
-  context 'for #current_engine method' do
-    should 'detect correctly current engine for erb' do
+  describe 'for #current_engine method' do
+    it 'should detect correctly current engine for erb' do
       visit '/erb/current_engine'
       assert_have_selector 'p.start', :content => "erb"
       assert_have_selector 'p.haml',  :content => "haml"
@@ -119,7 +119,7 @@ describe "OutputHelpers" do
       assert_have_selector 'p.end',   :content => "erb"
     end
 
-    should 'detect correctly current engine for haml' do
+    it 'should detect correctly current engine for haml' do
       visit '/haml/current_engine'
       assert_have_selector 'p.start', :content => "haml"
       assert_have_selector 'p.haml',  :content => "haml"
@@ -128,7 +128,7 @@ describe "OutputHelpers" do
       assert_have_selector 'p.end',   :content => "haml"
     end
 
-    should 'detect correctly current engine for slim' do
+    it 'should detect correctly current engine for slim' do
       visit '/slim/current_engine'
       assert_have_selector 'p.start', :content => "slim"
       assert_have_selector 'p.haml',  :content => "haml"
@@ -138,18 +138,18 @@ describe "OutputHelpers" do
     end
   end
 
-  context 'for #partial method in simple sinatra application' do
-    should 'properly output in erb' do
+  describe 'for #partial method in simple sinatra application' do
+    it 'should properly output in erb' do
       visit '/erb/simple_partial'
       assert_have_selector 'p.erb',  :content => "erb"
     end
 
-    should 'properly output in haml' do
+    it 'should properly output in haml' do
       visit '/haml/simple_partial'
       assert_have_selector 'p.haml',  :content => "haml"
     end
 
-    should 'properly output in slim' do
+    it 'should properly output in slim' do
       visit '/slim/simple_partial'
       assert_have_selector 'p.slim',  :content => "slim"
     end