mirror of
https://github.com/rails/rails.git
synced 2022-11-09 12:12:34 -05:00
Upgraded NumberHelper with number_to_phone support international formats to comply with ITU E.123 by supporting area codes with less than 3 digits, added precision argument to number_to_human_size (defaults to 1) (closes #6421) [BobSilva]
git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@5336 5ecf4fe2-1ee6-0310-87b1-e25e094e27de
This commit is contained in:
David Heinemeier Hansson
parent
afd288cf81
commit
1c71a5d25f
3 changed files with 159 additions and 91 deletions
|
|
@ -1,5 +1,7 @@
|
|||
*SVN*
|
||||
|
||||
* Upgraded NumberHelper with number_to_phone support international formats to comply with ITU E.123 by supporting area codes with less than 3 digits, added precision argument to number_to_human_size (defaults to 1) #6421 [BobSilva]
|
||||
|
||||
* Fixed that setting RAILS_ASSET_ID to "" should not add a trailing slash after assets #6454 [BobSilva/chrismear]
|
||||
|
||||
* Force *_url named routes to show the host in ActionView [Rick]
|
||||
|
|
|
|||
|
|
@ -1,42 +1,64 @@
|
|||
module ActionView
|
||||
module Helpers
|
||||
# Provides methods for converting a number into a formatted string that currently represents
|
||||
# one of the following forms: phone number, percentage, money, or precision level.
|
||||
module Helpers #:nodoc:
|
||||
# Provides methods for converting a numbers into formatted strings.
|
||||
# Methods are provided for phone numbers, currency, percentage,
|
||||
# precision, positional notation, and file size.
|
||||
module NumberHelper
|
||||
# Formats a +number+ into a US phone number string. The +options+ can be a hash used to customize the format of the output.
|
||||
# The area code can be surrounded by parentheses by setting +:area_code+ to true; default is false
|
||||
# The delimiter can be set using +:delimiter+; default is "-"
|
||||
# Examples:
|
||||
# number_to_phone(1235551234) => 123-555-1234
|
||||
# number_to_phone(1235551234, {:area_code => true}) => (123) 555-1234
|
||||
# number_to_phone(1235551234, {:delimiter => " "}) => 123 555 1234
|
||||
# number_to_phone(1235551234, {:area_code => true, :extension => 555}) => (123) 555-1234 x 555
|
||||
# Formats a +number+ into a US phone number. You can customize the format
|
||||
# in the +options+ hash.
|
||||
# * <tt>:area_code</tt> - Adds parentheses around the area code.
|
||||
# * <tt>:delimiter</tt> - Specifies the delimiter to use, defaults to "-".
|
||||
# * <tt>:extension</tt> - Specifies an extension to add to the end of the
|
||||
# generated number
|
||||
# * <tt>:country_code</tt> - Sets the country code for the phone number.
|
||||
#
|
||||
# number_to_phone(1235551234) => 123-555-1234
|
||||
# number_to_phone(1235551234, :area_code => true) => (123) 555-1234
|
||||
# number_to_phone(1235551234, :delimiter => " ") => 123 555 1234
|
||||
# number_to_phone(1235551234, :area_code => true, :extension => 555) => (123) 555-1234 x 555
|
||||
# number_to_phone(1235551234, :country_code => 1)
|
||||
def number_to_phone(number, options = {})
|
||||
options = options.stringify_keys
|
||||
area_code = options.delete("area_code") { false }
|
||||
delimiter = options.delete("delimiter") { "-" }
|
||||
extension = options.delete("extension") { "" }
|
||||
number = number.to_s.strip unless number.nil?
|
||||
options = options.stringify_keys
|
||||
area_code = options["area_code"] || nil
|
||||
delimiter = options["delimiter"] || "-"
|
||||
extension = options["extension"].to_s.strip || nil
|
||||
country_code = options["country_code"] || nil
|
||||
|
||||
begin
|
||||
str = area_code == true ? number.to_s.gsub(/([0-9]{3})([0-9]{3})([0-9]{4})/,"(\\1) \\2#{delimiter}\\3") : number.to_s.gsub(/([0-9]{3})([0-9]{3})([0-9]{4})/,"\\1#{delimiter}\\2#{delimiter}\\3")
|
||||
extension.to_s.strip.empty? ? str : "#{str} x #{extension.to_s.strip}"
|
||||
str = ""
|
||||
str << "+#{country_code}#{delimiter}" unless country_code.blank?
|
||||
str << if area_code
|
||||
number.gsub!(/([0-9]{1,3})([0-9]{3})([0-9]{4}$)/,"(\\1) \\2#{delimiter}\\3")
|
||||
else
|
||||
number.gsub!(/([0-9]{1,3})([0-9]{3})([0-9]{4})$/,"\\1#{delimiter}\\2#{delimiter}\\3")
|
||||
end
|
||||
str << " x #{extension}" unless extension.blank?
|
||||
str
|
||||
rescue
|
||||
number
|
||||
end
|
||||
end
|
||||
|
||||
# Formats a +number+ into a currency string. The +options+ hash can be used to customize the format of the output.
|
||||
# The +number+ can contain a level of precision using the +precision+ key; default is 2
|
||||
# The currency type can be set using the +unit+ key; default is "$"
|
||||
# The unit separator can be set using the +separator+ key; default is "."
|
||||
# The delimiter can be set using the +delimiter+ key; default is ","
|
||||
# Examples:
|
||||
# number_to_currency(1234567890.50) => $1,234,567,890.50
|
||||
# number_to_currency(1234567890.506) => $1,234,567,890.51
|
||||
# number_to_currency(1234567890.50, {:unit => "£", :separator => ",", :delimiter => ""}) => £1234567890,50
|
||||
# Formats a +number+ into a currency string. You can customize the format
|
||||
# in the +options+ hash.
|
||||
# * <tt>:precision</tt> - Sets the level of precision, defaults to 2
|
||||
# * <tt>:unit</tt> - Sets the denomination of the currency, defaults to "$"
|
||||
# * <tt>:separator</tt> - Sets the separator between the units, defaults to "."
|
||||
# * <tt>:delimiter</tt> - Sets the thousands delimiter, defaults to ","
|
||||
#
|
||||
# number_to_currency(1234567890.50) => $1,234,567,890.50
|
||||
# number_to_currency(1234567890.506) => $1,234,567,890.51
|
||||
# number_to_currency(1234567890.506, :precision => 3) => $1,234,567,890.506
|
||||
# number_to_currency(1234567890.50, :unit => "£", :separator => ",", :delimiter => "")
|
||||
# => £1234567890,50
|
||||
def number_to_currency(number, options = {})
|
||||
options = options.stringify_keys
|
||||
precision, unit, separator, delimiter = options.delete("precision") { 2 }, options.delete("unit") { "$" }, options.delete("separator") { "." }, options.delete("delimiter") { "," }
|
||||
separator = "" unless precision > 0
|
||||
options = options.stringify_keys
|
||||
precision = options["precision"] || 2
|
||||
unit = options["unit"] || "$"
|
||||
separator = precision > 0 ? options["separator"] || "." : ""
|
||||
delimiter = options["delimiter"] || ","
|
||||
|
||||
begin
|
||||
parts = number_with_precision(number, precision).split('.')
|
||||
unit + number_with_delimiter(parts[0], delimiter) + separator + parts[1].to_s
|
||||
|
|
@ -45,16 +67,19 @@ module ActionView
|
|||
end
|
||||
end
|
||||
|
||||
# Formats a +number+ as into a percentage string. The +options+ hash can be used to customize the format of the output.
|
||||
# The +number+ can contain a level of precision using the +precision+ key; default is 3
|
||||
# The unit separator can be set using the +separator+ key; default is "."
|
||||
# Examples:
|
||||
# number_to_percentage(100) => 100.000%
|
||||
# number_to_percentage(100, {:precision => 0}) => 100%
|
||||
# number_to_percentage(302.0574, {:precision => 2}) => 302.06%
|
||||
# Formats a +number+ as a percentage string. You can customize the
|
||||
# format in the +options+ hash.
|
||||
# * <tt>:precision</tt> - Sets the level of precision, defaults to 3
|
||||
# * <tt>:separator</tt> - Sets the separator between the units, defaults to "."
|
||||
#
|
||||
# number_to_percentage(100) => 100.000%
|
||||
# number_to_percentage(100, {:precision => 0}) => 100%
|
||||
# number_to_percentage(302.0574, {:precision => 2}) => 302.06%
|
||||
def number_to_percentage(number, options = {})
|
||||
options = options.stringify_keys
|
||||
precision, separator = options.delete("precision") { 3 }, options.delete("separator") { "." }
|
||||
options = options.stringify_keys
|
||||
precision = options["precision"] || 3
|
||||
separator = options["separator"] || "."
|
||||
|
||||
begin
|
||||
number = number_with_precision(number, precision)
|
||||
parts = number.split('.')
|
||||
|
|
@ -68,9 +93,14 @@ module ActionView
|
|||
end
|
||||
end
|
||||
|
||||
# Formats a +number+ with a +delimiter+.
|
||||
# Example:
|
||||
# number_with_delimiter(12345678) => 12,345,678
|
||||
# Formats a +number+ with grouped thousands using +delimiter+. You
|
||||
# can customize the format in the +options+ hash.
|
||||
# * <tt>:delimiter</tt> - Sets the thousands delimiter, defaults to ","
|
||||
# * <tt>:separator</tt> - Sets the separator between the units, defaults to "."
|
||||
#
|
||||
# number_with_delimiter(12345678) => 12,345,678
|
||||
# number_with_delimiter(12345678.05) => 12,345,678.05
|
||||
# number_with_delimiter(12345678, :delimiter => ".") => 12.345.678
|
||||
def number_with_delimiter(number, delimiter=",", separator=".")
|
||||
begin
|
||||
parts = number.to_s.split(separator)
|
||||
|
|
@ -81,35 +111,45 @@ module ActionView
|
|||
end
|
||||
end
|
||||
|
||||
# Returns a formatted-for-humans file size.
|
||||
# Formats a +number+ with the specified level of +precision+. The default
|
||||
# level of precision is 3.
|
||||
#
|
||||
# number_with_precision(111.2345) => 111.235
|
||||
# number_with_precision(111.2345, 2) => 111.24
|
||||
def number_with_precision(number, precision=3)
|
||||
"%01.#{precision}f" % number
|
||||
rescue
|
||||
number
|
||||
end
|
||||
|
||||
# Formats the bytes in +size+ into a more understandable representation.
|
||||
# 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 in +precision+.
|
||||
#
|
||||
# Examples:
|
||||
# human_size(123) => 123 Bytes
|
||||
# human_size(1234) => 1.2 KB
|
||||
# human_size(12345) => 12.1 KB
|
||||
# human_size(1234567) => 1.2 MB
|
||||
# human_size(1234567890) => 1.1 GB
|
||||
def number_to_human_size(size)
|
||||
# number_to_human_size(123) => 123 Bytes
|
||||
# number_to_human_size(1234) => 1.2 KB
|
||||
# number_to_human_size(12345) => 12.1 KB
|
||||
# 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, 2) => 1.18 MB
|
||||
def number_to_human_size(size, precision=1)
|
||||
size = Kernel.Float(size)
|
||||
case
|
||||
when size == 1 : '1 Byte'
|
||||
when size < 1.kilobyte: '%d Bytes' % size
|
||||
when size < 1.megabyte: '%.1f KB' % (size / 1.0.kilobyte)
|
||||
when size < 1.gigabyte: '%.1f MB' % (size / 1.0.megabyte)
|
||||
when size < 1.terabyte: '%.1f GB' % (size / 1.0.gigabyte)
|
||||
else '%.1f TB' % (size / 1.0.terabyte)
|
||||
when size == 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)
|
||||
end.sub('.0', '')
|
||||
rescue
|
||||
nil
|
||||
end
|
||||
|
||||
alias_method :human_size, :number_to_human_size # deprecated alias
|
||||
|
||||
# Formats a +number+ with a level of +precision+.
|
||||
# Example:
|
||||
# number_with_precision(111.2345) => 111.235
|
||||
def number_with_precision(number, precision=3)
|
||||
sprintf("%01.#{precision}f", number)
|
||||
end
|
||||
deprecate :human_size
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
|
|||
|
|
@ -1,18 +1,22 @@
|
|||
require 'test/unit'
|
||||
require File.dirname(__FILE__) + '/../abstract_unit'
|
||||
require File.dirname(__FILE__) + '/../../lib/action_view/helpers/number_helper'
|
||||
require File.dirname(__FILE__) + '/../../../activesupport/lib/active_support/core_ext/hash' # for stringify_keys
|
||||
require File.dirname(__FILE__) + '/../../../activesupport/lib/active_support/core_ext/numeric' # for human_size
|
||||
|
||||
class NumberHelperTest < Test::Unit::TestCase
|
||||
include ActionView::Helpers::NumberHelper
|
||||
include ActiveSupport::CoreExtensions::Hash
|
||||
|
||||
def test_number_to_phone
|
||||
assert_equal("123-555-1234", number_to_phone(1235551234))
|
||||
assert_equal("(123) 555-1234", number_to_phone(1235551234, {:area_code => true}))
|
||||
assert_equal("123 555 1234", number_to_phone(1235551234, {:delimiter => " "}))
|
||||
assert_equal("(123) 555-1234 x 555", number_to_phone(1235551234, {:area_code => true, :extension => 555}))
|
||||
assert_equal("123-555-1234", number_to_phone(1235551234, :extension => " "))
|
||||
assert_equal("800-555-1212", number_to_phone(8005551212))
|
||||
assert_equal("(800) 555-1212", number_to_phone(8005551212, {:area_code => true}))
|
||||
assert_equal("800 555 1212", number_to_phone(8005551212, {:delimiter => " "}))
|
||||
assert_equal("(800) 555-1212 x 123", number_to_phone(8005551212, {:area_code => true, :extension => 123}))
|
||||
assert_equal("800-555-1212", number_to_phone(8005551212, :extension => " "))
|
||||
assert_equal("800-555-1212", number_to_phone("8005551212"))
|
||||
assert_equal("+1-800-555-1212", number_to_phone(8005551212, :country_code => 1))
|
||||
assert_equal("+18005551212", number_to_phone(8005551212, :country_code => 1, :delimiter => ''))
|
||||
assert_equal("22-555-1212", number_to_phone(225551212))
|
||||
assert_equal("+45-22-555-1212", number_to_phone(225551212, :country_code => 45))
|
||||
assert_equal("x", number_to_phone("x"))
|
||||
assert_nil number_to_phone(nil)
|
||||
end
|
||||
|
||||
def test_number_to_currency
|
||||
|
|
@ -21,17 +25,22 @@ class NumberHelperTest < Test::Unit::TestCase
|
|||
assert_equal("$1,234,567,890", number_to_currency(1234567890.50, {: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("$x.", number_to_currency("x"))
|
||||
assert_nil number_to_currency(nil)
|
||||
end
|
||||
|
||||
def test_number_to_percentage
|
||||
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("x%", number_to_percentage("x"))
|
||||
assert_nil number_to_percentage(nil)
|
||||
end
|
||||
|
||||
def test_number_with_delimiter
|
||||
assert_equal("12,345,678", number_with_delimiter(12345678))
|
||||
assert_equal(nil, number_with_delimiter(nil))
|
||||
assert_equal("0", number_with_delimiter(0))
|
||||
assert_equal("123", number_with_delimiter(123))
|
||||
assert_equal("123,456", number_with_delimiter(123456))
|
||||
|
|
@ -40,27 +49,44 @@ class NumberHelperTest < Test::Unit::TestCase
|
|||
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_nil number_with_delimiter(nil)
|
||||
end
|
||||
|
||||
def test_number_to_human_size
|
||||
assert_equal '0 Bytes', human_size(0)
|
||||
assert_equal '1 Byte', human_size(1)
|
||||
assert_equal '3 Bytes', human_size(3.14159265)
|
||||
assert_equal '123 Bytes', human_size(123.0)
|
||||
assert_equal '123 Bytes', human_size(123)
|
||||
assert_equal '1.2 KB', human_size(1234)
|
||||
assert_equal '12.1 KB', human_size(12345)
|
||||
assert_equal '1.2 MB', human_size(1234567)
|
||||
assert_equal '1.1 GB', human_size(1234567890)
|
||||
assert_equal '1.1 TB', human_size(1234567890123)
|
||||
assert_equal '444 KB', human_size(444.kilobytes)
|
||||
assert_equal '1023 MB', human_size(1023.megabytes)
|
||||
assert_equal '3 TB', human_size(3.terabytes)
|
||||
assert_nil human_size('x')
|
||||
assert_nil human_size(nil)
|
||||
end
|
||||
|
||||
|
||||
def test_number_with_precision
|
||||
assert_equal("111.235", number_with_precision(111.2346))
|
||||
assert_equal("111.23", number_with_precision(111.2346, 2))
|
||||
assert_equal("111.00", number_with_precision(111, 2))
|
||||
assert_equal("111.235", number_with_precision("111.2346"))
|
||||
assert_equal("x", number_with_precision("x"))
|
||||
assert_nil number_with_precision(nil)
|
||||
end
|
||||
|
||||
def test_number_to_human_size
|
||||
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)
|
||||
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 '444 KB', number_to_human_size(444.kilobytes)
|
||||
assert_equal '1023 MB', number_to_human_size(1023.megabytes)
|
||||
assert_equal '3 TB', number_to_human_size(3.terabytes)
|
||||
assert_equal '1.18 MB', number_to_human_size(1234567, 2)
|
||||
assert_equal '3 Bytes', number_to_human_size(3.14159265, 4)
|
||||
assert_equal("123 Bytes", number_to_human_size("123"))
|
||||
assert_nil number_to_human_size('x')
|
||||
assert_nil number_to_human_size(nil)
|
||||
end
|
||||
|
||||
def test_human_size_alias_is_deprecated
|
||||
assert_deprecated 'human_size' do
|
||||
assert_equal '0 Bytes', human_size(0)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
|
|||
Loading…
Reference in a new issue