From 1ee7d46e17423fb95f38cd5144c27e210c3170b3 Mon Sep 17 00:00:00 2001 From: Clemens Kofler Date: Mon, 21 Jul 2008 02:25:13 +0200 Subject: [PATCH] Refactored DateHelper API to consistently use options hash instead of ordered parameters. Old API is still supported for now. --- .../lib/action_view/helpers/number_helper.rb | 92 +++++++++++++------ actionpack/test/template/number_helper_test.rb | 26 ++++++ 2 files changed, 89 insertions(+), 29 deletions(-) diff --git a/actionpack/lib/action_view/helpers/number_helper.rb b/actionpack/lib/action_view/helpers/number_helper.rb index 6bb8263..63d9734 100644 --- a/actionpack/lib/action_view/helpers/number_helper.rb +++ b/actionpack/lib/action_view/helpers/number_helper.rb @@ -118,40 +118,62 @@ module ActionView end end - # Formats a +number+ with grouped thousands using +delimiter+ (e.g., 12,324). You - # can customize the format using optional delimiter and separator parameters. + # Formats a +number+ with grouped thousands using +delimiter+ (e.g., 12,324). You can + # customize the format in the +options+ hash. # # ==== Options - # * delimiter - Sets the thousands delimiter (defaults to ","). - # * separator - Sets the separator between the units (defaults to "."). + # * :delimiter - Sets the thousands delimiter (defaults to ","). + # * :separator - Sets the separator between the units (defaults to "."). # # ==== Examples - # number_with_delimiter(12345678) # => 12,345,678 - # number_with_delimiter(12345678.05) # => 12,345,678.05 - # number_with_delimiter(12345678, ".") # => 12.345.678 - # - # number_with_delimiter(98765432.98, " ", ",") + # number_with_delimiter(12345678) # => 12,345,678 + # number_with_delimiter(12345678.05) # => 12,345,678.05 + # number_with_delimiter(12345678, :delimiter => ".") # => 12.345.678 + # number_with_delimiter(12345678, :seperator => ",") # => 12,345,678 + # number_with_delimiter(98765432.98, :delimiter => " ", :separator => ",") # # => 98 765 432,98 - def number_with_delimiter(number, delimiter=",", separator=".") + # + # You can still use number_with_delimiter with the old API that accepts the + # +delimiter+ as its optional second and the +separator+ as its + # optional third parameter: + # number_with_delimiter(12345678, " ") # => 12 345.678 + # number_with_delimiter(12345678.05, ".", ",") # => 12.345.678,05 + def number_with_delimiter(number, *args) + options = args.extract_options! + unless args.empty? + options[:delimiter] = args[0] || "," + options[:separator] = args[1] || "." + end + options.reverse_merge!(:delimiter => ",", :separator => ".") + begin parts = number.to_s.split('.') - parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}") - parts.join separator + parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{options[:delimiter]}") + parts.join options[:separator] rescue number end end - # Formats a +number+ with the specified level of +precision+ (e.g., 112.32 has a precision of 2). The default + # Formats a +number+ with the specified level of :precision (e.g., 112.32 has a precision of 2). The default # level of precision is 3. # # ==== Examples - # number_with_precision(111.2345) # => 111.235 - # number_with_precision(111.2345, 2) # => 111.23 - # number_with_precision(13, 5) # => 13.00000 - # number_with_precision(389.32314, 0) # => 389 - def number_with_precision(number, precision=3) - "%01.#{precision}f" % ((Float(number) * (10 ** precision)).round.to_f / 10 ** precision) + # number_with_precision(111.2345) # => 111.235 + # number_with_precision(111.2345, :precision => 2) # => 111.23 + # number_with_precision(13, :precision => 5) # => 13.00000 + # number_with_precision(389.32314, :precision => 0) # => 389 + # + # You can still use number_with_precision with the old API that accepts the + # +precision+ as its optional second parameter: + # number_with_precision(number_with_precision(111.2345, 2) # => 111.23 + def number_with_precision(number, *args) + options = args.extract_options! + unless args.empty? + options[:precision] = args[0] || 3 + end + options.reverse_merge!(:precision => 3) + "%01.#{options[:precision]}f" % ((Float(number) * (10 ** options[:precision])).round.to_f / 10 ** options[:precision]) rescue number end @@ -160,7 +182,7 @@ module ActionView # (e.g., giving it 1500 yields 1.5 KB). This method is useful for # reporting file sizes to users. This method returns nil if # +size+ cannot be converted into a number. You can change the default - # precision of 1 using the precision parameter +precision+. + # precision of 1 using the precision parameter :precision. # # ==== Examples # number_to_human_size(123) # => 123 Bytes @@ -169,20 +191,32 @@ module ActionView # number_to_human_size(1234567) # => 1.2 MB # number_to_human_size(1234567890) # => 1.1 GB # number_to_human_size(1234567890123) # => 1.1 TB + # number_to_human_size(1234567, :precision => 2) # => 1.18 MB + # number_to_human_size(483989, :precision => 0) # => 473 KB + # + # You can still use number_to_human_size with the old API that accepts the + # +precision+ as its optional second parameter: # number_to_human_size(1234567, 2) # => 1.18 MB - # number_to_human_size(483989, 0) # => 4 MB - def number_to_human_size(size, precision=1) - size = Kernel.Float(size) + # number_to_human_size(483989, 0) # => 473 KB + def number_to_human_size(size, *args) + options = args.extract_options! + unless args.empty? + options[:precision] = args[0] || 1 + end + options.reverse_merge!(:precision => 1) + + size = Float(size) case when size.to_i == 1; "1 Byte" when size < 1.kilobyte; "%d Bytes" % size - when size < 1.megabyte; "%.#{precision}f KB" % (size / 1.0.kilobyte) - when size < 1.gigabyte; "%.#{precision}f MB" % (size / 1.0.megabyte) - when size < 1.terabyte; "%.#{precision}f GB" % (size / 1.0.gigabyte) - else "%.#{precision}f TB" % (size / 1.0.terabyte) + when size < 1.megabyte; "%.#{options[:precision]}f KB" % (size / 1.0.kilobyte) + when size < 1.gigabyte; "%.#{options[:precision]}f MB" % (size / 1.0.megabyte) + when size < 1.terabyte; "%.#{options[:precision]}f GB" % (size / 1.0.gigabyte) + else "%.#{options[:precision]}f TB" % (size / 1.0.terabyte) end.sub(/([0-9]\.\d*?)0+ /, '\1 ' ).sub(/\. /,' ') - rescue - nil + + rescue + nil end end end diff --git a/actionpack/test/template/number_helper_test.rb b/actionpack/test/template/number_helper_test.rb index 4a8d09b..eaeacd5 100644 --- a/actionpack/test/template/number_helper_test.rb +++ b/actionpack/test/template/number_helper_test.rb @@ -53,6 +53,13 @@ class NumberHelperTest < ActionView::TestCase assert_equal("x", number_with_delimiter("x")) assert_nil number_with_delimiter(nil) end + + def test_number_with_delimiter_with_options_hash + 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 def test_number_with_precision assert_equal("111.235", number_with_precision(111.2346)) @@ -68,6 +75,17 @@ class NumberHelperTest < ActionView::TestCase assert_equal("x", number_with_precision("x")) assert_nil number_with_precision(nil) end + + def test_number_with_precision_with_options_hash + 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) + assert_equal '111.00', number_with_precision(111, :precision => 2) + assert_equal '111.235', number_with_precision("111.2346") + assert_equal '31.83', number_with_precision("31.825", :precision => 2) + assert_equal '112', number_with_precision(111.50, :precision => 0) + assert_equal '1234567892', number_with_precision(1234567891.50, :precision => 0) + end def test_number_to_human_size assert_equal '0 Bytes', number_to_human_size(0) @@ -94,4 +112,12 @@ class NumberHelperTest < ActionView::TestCase assert_nil number_to_human_size('x') assert_nil number_to_human_size(nil) end + + def test_number_to_human_size_with_options_hash + 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(1.0123.kilobytes, :precision => 2) + assert_equal '1.01 KB', number_to_human_size(1.0100.kilobytes, :precision => 4) + assert_equal '10 KB', number_to_human_size(10.000.kilobytes, :precision => 4) + end end -- 1.5.2.4