padrino-helpers 0.16.0.pre4 → 0.16.0

data/test/test_format_helpers.rb

@@ -1,7 +1,7 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-require File.expand_path(File.dirname(__FILE__) + '/fixtures/markup_app/app')
+require_relative 'helper'
+require_relative 'fixtures/markup_app/app'
 
-describe "FormatHelpers" do
+describe 'FormatHelpers' do
   include Padrino::Helpers::FormatHelpers
 
   def app
@@ -15,7 +15,7 @@ describe "FormatHelpers" 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 actual_text.html_safe?
       assert_equal "<p>Here is some basic text...\n<br />...with a line break.</p>", actual_text
     end
 
@@ -25,13 +25,13 @@ describe "FormatHelpers" do
     end
 
     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
+      actual_text = simple_format('Look me! A class!', class: 'description')
+      assert_equal '<p class="description">Look me! A class!</p>', actual_text
     end
 
     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;/b&gt;?</p>", actual_text
+      actual_text = simple_format('Will you escape <b>that</b>?')
+      assert_equal '<p>Will you escape &lt;b&gt;that&lt;/b&gt;?</p>', actual_text
     end
 
     it 'should support already sanitized text' do
@@ -41,36 +41,36 @@ describe "FormatHelpers" 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)
+        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
 
       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)
+        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
 
       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
+        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
 
   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)
+      actual_text = word_wrap('Once upon a time', line_width: 8)
       assert_equal "Once\nupon a\ntime", actual_text
     end
     it 'should return proper formatting for 1 max width' do
-      actual_text = word_wrap('Once upon a time', :line_width => 1)
+      actual_text = word_wrap('Once upon a time', line_width: 1)
       assert_equal "Once\nupon\na\ntime", actual_text
     end
     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)
-      assert_equal (1..30).to_a.join(" ") + "\n" + (31..50).to_a.join(" "), actual_text
+      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)
+      assert_equal "#{(1..30).to_a.join(' ')}\n#{(31..50).to_a.join(' ')}", actual_text
     end
   end
 
@@ -81,38 +81,41 @@ describe "FormatHelpers" do
     end
 
     it 'should highlight with highlighter' do
-      actual_text = highlight('Lorem ipsum dolor sit amet', 'dolor', :highlighter => '<span class="custom">\1</span>')
+      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
 
   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
+      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
     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
+      actual_text = truncate('Once upon a time in a world far far away', length: 14)
+      assert_equal 'Once upon a...', actual_text
     end
     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
+      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
 
   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
+      actual_text = truncate_words(<<~TEXT.chomp)
+        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.
+      TEXT
+      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
     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
+      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
     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
+      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
 
@@ -125,107 +128,107 @@ describe "FormatHelpers" do
       assert_equal '&lt;h1&gt;&lt;&gt;&quot;&amp;demo&amp;&quot;&lt;&gt;&lt;/h1&gt;', h('<h1><>"&demo&"<></h1>')
     end
     it 'should return default text if text is empty' do
-      assert_equal 'default', h!("", "default")
-      assert_equal '&nbsp;', h!("")
+      assert_equal 'default', h!('', 'default')
+      assert_equal '&nbsp;', h!('')
     end
     it 'should return text escaped if not empty' do
       assert_equal '&lt;h1&gt;hello&lt;/h1&gt;', h!('<h1>hello</h1>')
     end
     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?
+      refute '<h1>hello</h1>'.html_safe?
+      assert h('<h1>hello</h1>').html_safe?
+      assert h!('', 'default').html_safe?
     end
   end
 
   describe 'for #time_ago_in_words method' do
-    _DAY = 24*60*60
+    A_DAY = 24 * 60 * 60
 
     it 'should less than 5 seconds' do
       assert_equal 'less than 5 seconds', time_ago_in_words(Time.now, true)
     end
     it 'should less than 10 seconds' do
-      assert_equal 'less than 10 seconds', time_ago_in_words(Time.now-5, true)
+      assert_equal 'less than 10 seconds', time_ago_in_words(Time.now - 5, true)
     end
     it 'should less than 20 seconds' do
-      assert_equal 'less than 20 seconds', time_ago_in_words(Time.now-10, true)
+      assert_equal 'less than 20 seconds', time_ago_in_words(Time.now - 10, true)
     end
     it 'should less than a minute' do
-      assert_equal 'less than a minute', time_ago_in_words(Time.now-40, true)
+      assert_equal 'less than a minute', time_ago_in_words(Time.now - 40, true)
     end
     it 'should 2 minutes' do
-      assert_equal '2 minutes', time_ago_in_words(Time.now-120, true)
+      assert_equal '2 minutes', time_ago_in_words(Time.now - 120, true)
     end
     it 'should display today' do
       assert_equal 'less than a minute', time_ago_in_words(Time.now)
     end
     it 'should display yesterday' do
-      assert_equal '1 day', time_ago_in_words(Time.now - _DAY)
+      assert_equal '1 day', time_ago_in_words(Time.now - A_DAY)
     end
     it 'should display tomorrow' do
-      assert_equal '1 day', time_ago_in_words(Time.now + _DAY)
+      assert_equal '1 day', time_ago_in_words(Time.now + A_DAY)
     end
     it 'should return future number of days' do
-      assert_equal '4 days', time_ago_in_words(Time.now + 4*_DAY)
+      assert_equal '4 days', time_ago_in_words(Time.now + 4 * A_DAY)
     end
     it 'should return past days ago' do
-      assert_equal '4 days', time_ago_in_words(Time.now - 4*_DAY)
+      assert_equal '4 days', time_ago_in_words(Time.now - 4 * A_DAY)
     end
     it 'should return formatted archived date' do
-      assert_equal '3 months', time_ago_in_words(Time.now - 100*_DAY)
+      assert_equal '3 months', time_ago_in_words(Time.now - 100 * A_DAY)
     end
     it 'should return formatted archived year date' do
-      assert_equal 'over 1 year', time_ago_in_words(Time.now - 500*_DAY)
+      assert_equal 'over 1 year', time_ago_in_words(Time.now - 500 * A_DAY)
     end
     it 'should display now as a minute ago' do
       assert_equal '1 minute', time_ago_in_words(Time.now - 60)
     end
     it 'should display a few minutes ago' do
-      assert_equal '4 minutes', time_ago_in_words(Time.now - 4*60)
+      assert_equal '4 minutes', time_ago_in_words(Time.now - 4 * 60)
     end
     it 'should display an hour ago' do
-      assert_equal 'about 1 hour', time_ago_in_words(Time.now - 60*60 + 5)
+      assert_equal 'about 1 hour', time_ago_in_words(Time.now - 60 * 60 + 5)
     end
     it 'should display a few hours ago' do
-      assert_equal 'about 3 hours', time_ago_in_words(Time.now - 3*60*60 + 5*60)
+      assert_equal 'about 3 hours', time_ago_in_words(Time.now - 3 * 60 * 60 + 5 * 60)
     end
     it 'should display a few days ago' do
-      assert_equal '5 days', time_ago_in_words(Time.now - 5*_DAY - 5*60)
+      assert_equal '5 days', time_ago_in_words(Time.now - 5 * A_DAY - 5 * 60)
     end
     it 'should display a month ago' do
-      assert_equal 'about 1 month', time_ago_in_words(Time.now - 32*_DAY + 5*60)
+      assert_equal 'about 1 month', time_ago_in_words(Time.now - 32 * A_DAY + 5 * 60)
     end
     it 'should display a few months ago' do
-      assert_equal '6 months', time_ago_in_words(Time.now - 180*_DAY - 5*60)
+      assert_equal '6 months', time_ago_in_words(Time.now - 180 * A_DAY - 5 * 60)
     end
     it 'should display a year ago' do
-      assert_equal 'about 1 year', time_ago_in_words(Time.now - 365*_DAY - 5*60)
+      assert_equal 'about 1 year', time_ago_in_words(Time.now - 365 * A_DAY - 5 * 60)
     end
     it 'should display a few years ago' do
-      assert_equal 'over 7 years', time_ago_in_words(Time.now - 2800*_DAY - 5*60)
+      assert_equal 'over 7 years', time_ago_in_words(Time.now - 2800 * A_DAY - 5 * 60)
     end
   end
 
   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(SafeBuffer.new('"hello"'))
+      assert_equal '\"hello\"', js_escape_html('"hello"')
+      assert_equal '\"hello\"', js_escape_html(SafeBuffer.new('"hello"'))
     end
     it 'should escape single quotes' do
       assert_equal "\\'hello\\'", js_escape_html("'hello'")
       assert_equal "\\'hello\\'", js_escape_html(SafeBuffer.new("'hello'"))
     end
     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(SafeBuffer.new("\n\r<p>hello</p>\r\n"))
+      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(SafeBuffer.new("\n\r<p>hello</p>\r\n"))
     end
     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(SafeBuffer.new("<data-confirm=\"are you sure\">"))
+      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(SafeBuffer.new('<data-confirm="are you sure">'))
     end
     it 'should keep html_safe content html_safe' do
-      assert_equal false, js_escape_html('"hello"').html_safe?
-      assert_equal true, js_escape_html(SafeBuffer.new('"hello"')).html_safe?
+      refute js_escape_html('"hello"').html_safe?
+      assert js_escape_html(SafeBuffer.new('"hello"')).html_safe?
     end
   end
 end

data/test/test_helpers.rb

@@ -1,6 +1,6 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
+require_relative 'helper'
 
-describe "Padrino::Helpers" do
+describe 'Padrino::Helpers' do
   it 'should allow including without registering' do
     class Foo
       include Padrino::Helpers

data/test/test_locale.rb

@@ -1,20 +1,22 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
+require_relative 'helper'
 
-describe "Locale Helpers" do
-  Dir[File.expand_path("../../lib/padrino-helpers/locale/*.yml", __FILE__)].each do |file|
+describe 'Locale Helpers' do
+  Dir[File.expand_path('../lib/padrino-helpers/locale/*.yml', __dir__)].each do |file|
     base_original = YAML.load_file(file)
     name = File.basename(file, '.yml')
+
     it "should should have correct locale for #{name}" do
       base = base_original[name]['number']['format']
-      assert !base['separator'].nil?
-      assert !base['delimiter'].nil?
-      assert !base['precision'].nil?
+      refute_nil base['separator']
+      refute_nil base['delimiter']
+      refute_nil base['precision']
+
       base = base_original[name]['number']['currency']['format']
-      assert !base['format'].nil?
-      assert !base['unit'].nil?
-      assert !base['separator'].nil?
-      assert !base['delimiter'].nil?
-      assert !base['precision'].nil?
+      refute_nil base['format']
+      refute_nil base['unit']
+      refute_nil base['separator']
+      refute_nil base['delimiter']
+      refute_nil base['precision']
     end
   end
 end

data/test/test_number_helpers.rb

@@ -1,7 +1,7 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-require File.expand_path(File.dirname(__FILE__) + '/fixtures/markup_app/app')
+require_relative 'helper'
+require_relative 'fixtures/markup_app/app'
 
-describe "NumberHelpers" do
+describe 'NumberHelpers' do
   include Padrino::Helpers::NumberHelpers
 
   def app
@@ -26,70 +26,70 @@ describe "NumberHelpers" 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.60, {:precision => 0})
-      assert_equal "$1,234,567,890.5",         number_to_currency(1234567890.50, {:precision => 1})
-      assert_equal "£1234567890,50",     number_to_currency(1234567890.50, {:unit => "£", :separator => ",", :delimiter => ""})
-      assert_equal "$1,234,567,890.50",        number_to_currency("1234567890.50")
-      assert_equal "1,234,567,890.50 Kč", number_to_currency("1234567890.50", {:unit => "Kč", :format => "%n %u"})
-      assert_equal "$x",                       number_to_currency("x")
+      assert_equal '$1,234,567,890.50',        number_to_currency(1_234_567_890.50)
+      assert_equal '$1,234,567,890.51',        number_to_currency(1_234_567_890.506)
+      assert_equal '$1,234,567,892',           number_to_currency(1_234_567_891.60, { precision: 0 })
+      assert_equal '$1,234,567,890.5',         number_to_currency(1_234_567_890.50, { precision: 1 })
+      assert_equal '£1234567890,50',     number_to_currency(1_234_567_890.50, { unit: '£', separator: ',', delimiter: '' })
+      assert_equal '$1,234,567,890.50',        number_to_currency('1234567890.50')
+      assert_equal '1,234,567,890.50 Kč', number_to_currency('1234567890.50', { unit: 'Kč', format: '%n %u' })
+      assert_equal '$x',                       number_to_currency('x')
 
       assert_nil number_to_currency(nil)
     end
 
     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})
-      assert_equal "100.000%",   number_to_percentage("100")
-      assert_equal "1000.000%",  number_to_percentage("1000")
-      assert_equal "x%",         number_to_percentage("x")
-      assert_equal "1.000,000%", number_to_percentage(1000, :delimiter => '.', :separator => ',')
+      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 })
+      assert_equal '100.000%',   number_to_percentage('100')
+      assert_equal '1000.000%',  number_to_percentage('1000')
+      assert_equal 'x%',         number_to_percentage('x')
+      assert_equal '1.000,000%', number_to_percentage(1000, delimiter: '.', separator: ',')
 
       assert_nil number_to_percentage(nil)
     end
 
     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)
-      assert_equal "123,456",           number_with_delimiter(123456)
-      assert_equal "123,456.78",        number_with_delimiter(123456.78)
-      assert_equal "123,456.789",       number_with_delimiter(123456.789)
-      assert_equal "123,456.78901",     number_with_delimiter(123456.78901)
-      assert_equal "123,456,789.78901", number_with_delimiter(123456789.78901)
-      assert_equal "0.78901",           number_with_delimiter(0.78901)
-      assert_equal "123,456.78",        number_with_delimiter("123456.78")
-      assert_equal "x",                 number_with_delimiter("x")
+      assert_equal '12,345,678',        number_with_delimiter(12_345_678)
+      assert_equal '0',                 number_with_delimiter(0)
+      assert_equal '123',               number_with_delimiter(123)
+      assert_equal '123,456',           number_with_delimiter(123_456)
+      assert_equal '123,456.78',        number_with_delimiter(123_456.78)
+      assert_equal '123,456.789',       number_with_delimiter(123_456.789)
+      assert_equal '123,456.78901',     number_with_delimiter(123_456.78901)
+      assert_equal '123,456,789.78901', number_with_delimiter(123_456_789.78901)
+      assert_equal '0.78901',           number_with_delimiter(0.78901)
+      assert_equal '123,456.78',        number_with_delimiter('123456.78')
+      assert_equal 'x',                 number_with_delimiter('x')
 
       assert_nil number_with_delimiter(nil)
     end
 
     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 => ',')
+      assert_equal '12 345 678',    number_with_delimiter(12_345_678, delimiter: ' ')
+      assert_equal '12,345,678-05', number_with_delimiter(12_345_678.05, separator: '-')
+      assert_equal '12.345.678,05', number_with_delimiter(12_345_678.05, separator: ',', delimiter: '.')
+      assert_equal '12.345.678,05', number_with_delimiter(12_345_678.05, delimiter: '.', separator: ',')
     end
 
     it 'should display number_with_precision' do
-      assert_equal "111.235",    number_with_precision(111.2346)
-      assert_equal "111.23",     number_with_precision(111.2346, :precision => 2)
-      assert_equal "111.00",     number_with_precision(111, :precision => 2)
-      assert_equal "111.235",    number_with_precision("111.2346")
-      assert_equal "3268",       number_with_precision((32.6751 * 100.00), :precision => 0)
-      assert_equal "112",        number_with_precision(111.60, :precision => 0)
-      assert_equal "1234567892", number_with_precision(1234567891.60, :precision => 0)
+      assert_equal '111.235',    number_with_precision(111.2346)
+      assert_equal '111.23',     number_with_precision(111.2346, precision: 2)
+      assert_equal '111.00',     number_with_precision(111, precision: 2)
+      assert_equal '111.235',    number_with_precision('111.2346')
+      assert_equal '3268',       number_with_precision(32.6751 * 100.00, precision: 0)
+      assert_equal '112',        number_with_precision(111.60, precision: 0)
+      assert_equal '1234567892', number_with_precision(1_234_567_891.60, precision: 0)
 
       # Return non-numeric params unchanged.
-      assert_equal "x", number_with_precision("x")
+      assert_equal 'x', number_with_precision('x')
       assert_nil number_with_precision(nil)
     end
 
     it 'should display number_with_precision with custom delimiter and separator' do
-      assert_equal '31,83',     number_with_precision(31.826, :precision => 2, :separator => ',')
-      assert_equal '1.231,83',  number_with_precision(1231.826, :precision => 2, :separator => ',', :delimiter => '.')
+      assert_equal '31,83',     number_with_precision(31.826, precision: 2, separator: ',')
+      assert_equal '1.231,83',  number_with_precision(1231.826, precision: 2, separator: ',', delimiter: '.')
     end
 
     it 'should display number_to_human_size' do
@@ -99,20 +99,20 @@ describe "NumberHelpers" do
       assert_equal '123 Bytes', number_to_human_size(123.0)
       assert_equal '123 Bytes', number_to_human_size(123)
       assert_equal '1.2 KB',    number_to_human_size(1234)
-      assert_equal '12.1 KB',   number_to_human_size(12345)
-      assert_equal '1.2 MB',    number_to_human_size(1234567)
-      assert_equal '1.1 GB',    number_to_human_size(1234567890)
-      assert_equal '1.1 TB',    number_to_human_size(1234567890123)
+      assert_equal '12.1 KB',   number_to_human_size(12_345)
+      assert_equal '1.2 MB',    number_to_human_size(1_234_567)
+      assert_equal '1.1 GB',    number_to_human_size(1_234_567_890)
+      assert_equal '1.1 TB',    number_to_human_size(1_234_567_890_123)
       assert_equal '1025 TB',   number_to_human_size(terabytes(1025))
       assert_equal '444 KB',    number_to_human_size(kilobytes(444))
       assert_equal '1023 MB',   number_to_human_size(megabytes(1023))
       assert_equal '3 TB',      number_to_human_size(terabytes(3))
-      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 '123 Bytes', number_to_human_size("123")
-      assert_equal '1.01 KB',   number_to_human_size(kilobytes(1.0123), :precision => 2)
-      assert_equal '1.01 KB',   number_to_human_size(kilobytes(1.0100), :precision => 4)
-      assert_equal '10 KB',     number_to_human_size(kilobytes(10.000), :precision => 4)
+      assert_equal '1.18 MB',   number_to_human_size(1_234_567, precision: 2)
+      assert_equal '3 Bytes',   number_to_human_size(3.14159265, precision: 4)
+      assert_equal '123 Bytes', number_to_human_size('123')
+      assert_equal '1.01 KB',   number_to_human_size(kilobytes(1.0123), precision: 2)
+      assert_equal '1.01 KB',   number_to_human_size(kilobytes(1.0100), precision: 4)
+      assert_equal '10 KB',     number_to_human_size(kilobytes(10.000), precision: 4)
       assert_equal '1 Byte',    number_to_human_size(1.1)
       assert_equal '10 Bytes',  number_to_human_size(10)
 
@@ -120,21 +120,21 @@ describe "NumberHelpers" do
     end
 
     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)
-      assert_equal '1.01 KB', number_to_human_size(kilobytes(1.0100), :precision => 4)
-      assert_equal '10 KB',   number_to_human_size(kilobytes(10.000), :precision => 4)
-      assert_equal '1 TB',    number_to_human_size(1234567890123, :precision => 0)
-      assert_equal '500 MB',  number_to_human_size(524288000, :precision => 0)
-      assert_equal '40 KB',   number_to_human_size(41010, :precision => 0)
-      assert_equal '40 KB',   number_to_human_size(41100, :precision => 0)
+      assert_equal '1.18 MB', number_to_human_size(1_234_567, 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)
+      assert_equal '1.01 KB', number_to_human_size(kilobytes(1.0100), precision: 4)
+      assert_equal '10 KB',   number_to_human_size(kilobytes(10.000), precision: 4)
+      assert_equal '1 TB',    number_to_human_size(1_234_567_890_123, precision: 0)
+      assert_equal '500 MB',  number_to_human_size(524_288_000, precision: 0)
+      assert_equal '40 KB',   number_to_human_size(41_010, precision: 0)
+      assert_equal '40 KB',   number_to_human_size(41_100, precision: 0)
     end
 
     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 => ',')
+      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: ',')
     end
   end
 end