module ActiveSupport::NumberHelper

# => "$1,234,567,890.5"
number_to_currency(1234567890.50, strip_insignificant_zeros: true)

Defaults to false.
Whether to remove insignificant zeros after the decimal separator.
[+:strip_insignificant_zeros+]

# => "($1,234,567,890.50)"
number_to_currency(-1234567890.50, negative_format: "(%u%n)")

the number. Defaults to the value of +:format+ prepended with -.
same as in +:format+, but %n represents the absolute value of
The format for negative numbers. %u and %n behave the
[+:negative_format+]

# => "1,234,567,890.50 $"
number_to_currency(1234567890.50, format: "%n %u")

and %n represents the number. Defaults to "%u%n".
The format for non-negative numbers. %u represents the currency,
[+:format+]

The thousands delimiter. Defaults to ",".
[+:delimiter+]

The decimal separator. Defaults to ".".
[+:separator+]

The denomination of the currency. Defaults to "$".
[+:unit+]

# => "$1,234,567,891"
number_to_currency(1234567890.01, precision: 0, round_mode: :up)

+:default+.
Specifies how rounding is performed. See +BigDecimal.mode+. Defaults to
[+:round_mode+]

number_to_currency(0.456789, precision: 0) # => "$0"
number_to_currency(1234567890.123, precision: 3) # => "$1,234,567,890.123"

The level of precision. Defaults to 2.
[+:precision+]

# => "1 234 567 890,51 €"
number_to_currency(1234567890.506, locale: :fr)

The locale to use for formatting. Defaults to the current locale.
[+:locale+]

==== Options

library capable of currency conversion.
may want to specify a constant +:locale+ option or consider using a
this helper. If your application will ever support multiple locales, you
also be able to change the relative value of the currency displayed with
performed. If the user is given a way to change their locale, they will
unless otherwise specified via options. No currency conversion is
The currency unit and number formatting of the current locale will be used

# => "£1234567890,50"
number_to_currency(1234567890.50, unit: "£", separator: ",", delimiter: "")

number_to_currency("12x34") # => "$12x34"
number_to_currency(1234567890.506) # => "$1,234,567,890.51"
number_to_currency(1234567890.50) # => "$1,234,567,890.50"

Formats a +number+ into a currency string.

def number_to_currency(number, options = {})
  NumberToCurrencyConverter.convert(number, options)
end

# => "1,23,456.78"
number_to_delimited("123456.78", delimiter_pattern: /(\d+?)(?=(\d\d)+(\d)(?!\d))/)

currency formats like INR.
A regexp to determine the placement of delimiters. Helpful when using
[+:delimiter_pattern+]

# => "12,345,678 05"
number_to_delimited(12345678.05, separator: " ")

The decimal separator. Defaults to ".".
[+:separator+]

# => "12.345.678"
number_to_delimited(12345678, delimiter: ".")

The thousands delimiter. Defaults to ",".
[+:delimiter+]

# => "12 345 678,05"
number_to_delimited(12345678.05, locale: :fr)

The locale to use for formatting. Defaults to the current locale.
[+:locale+]

==== Options

# => "12.345.678,9876"
number_to_delimited(12345678.9876, delimiter: ".", separator: ",")

number_to_delimited("12x34") # => "12x34"
number_to_delimited(12345678.9876) # => "12,345,678.9876"
number_to_delimited("123456") # => "123,456"
number_to_delimited(12345678) # => "12,345,678"

Formats +number+ by grouping thousands with a delimiter.

def number_to_delimited(number, options = {})
  NumberToDelimitedConverter.convert(number, options)
end

number_to_human(0.01, units: :distance) # => "1 centimeter"
number_to_human(0.1, units: :distance) # => "10 centimeters"
number_to_human(10000000, units: :distance) # => "10000 kilometers"
number_to_human(100000, units: :distance) # => "100 kilometers"
number_to_human(1000, units: :distance) # => "1 kilometer"
number_to_human(100, units: :distance) # => "100 meters"
number_to_human(1, units: :distance) # => "1 meter"

Then it can be specified by name:

other: "kilometers"
one: "kilometer"
thousand:
other: "meters"
one: "meter"
unit:
other: "centimeters"
one: "centimeter"
centi:
distance:
en:

The Hash can also be defined as a scope in an I18n locale. For example:

+:pico+, +:femto+.
fractional units: +:deci+, +:centi+, +:mili+, +:micro+, +:nano+,
+:quadrillion+. Additionally, the following keys are supported for
+:hundred+, +:thousand+, +:million+, +:billion+, +:trillion+,
The following keys are supported for integer units: +:unit+, +:ten+,

number_to_human(10000000, units: { unit: "m", thousand: "km" }) # => "10000 km"
number_to_human(100000, units: { unit: "m", thousand: "km" }) # => "100 km"
number_to_human(1000, units: { unit: "m", thousand: "km" }) # => "1 km"
number_to_human(100, units: { unit: "m", thousand: "km" }) # => "100 m"
number_to_human(1, units: { unit: "m", thousand: "km" }) # => "1 m"

A Hash of custom unit quantifier names.
[+:units+]

"%n %u".
%u represents the quantifier (e.g., "Thousand"). Defaults to
The format of the output. %n represents the number, and
[+:format+]

number_to_human(10.01, strip_insignificant_zeros: false) # => "10.0"
number_to_human(10.01) # => "10"
number_to_human(1000000, strip_insignificant_zeros: false) # => "1.00 Million"
number_to_human(1000000) # => "1 Million"

Defaults to true.
Whether to remove insignificant zeros after the decimal separator.
[+:strip_insignificant_zeros+]

The thousands delimiter. Defaults to ",".
[+:delimiter+]

# => "123,5 Thousand"
number_to_human(123456, precision: 4, separator: ",")

The decimal separator. Defaults to ".".
[+:separator+]

fractional digits. Defaults to true.
Whether +:precision+ should be applied to significant digits instead of
[+:significant+]

# => "130 Thousand"
number_to_human(123456, precision: 2, round_mode: :up)

+:default+.
Specifies how rounding is performed. See +BigDecimal.mode+. Defaults to
[+:round_mode+]

number_to_human(123456, precision: 4) # => "123.5 Thousand"
number_to_human(123456, precision: 2) # => "120 Thousand"

The level of precision. Defaults to 3.
[+:precision+]

The locale to use for formatting. Defaults to the current locale.
[+:locale+]

==== Options

See #number_to_human_size if you want to pretty-print a file size.

number_to_human(1234567890123456789) # => "1230 Quadrillion"
number_to_human(1234567890123456) # => "1.23 Quadrillion"
number_to_human(1234567890123) # => "1.23 Trillion"
number_to_human(1234567890) # => "1.23 Billion"
number_to_human(1234567) # => "1.23 Million"
number_to_human(12345) # => "12.3 Thousand"
number_to_human(1234) # => "1.23 Thousand"
number_to_human(123) # => "123"

numbers that can become very large and too hard to read.
Formats +number+ into a more human-friendly representation. Useful for

def number_to_human(number, options = {})
  NumberToHumanConverter.convert(number, options)
end

Defaults to true.
Whether to remove insignificant zeros after the decimal separator.
[+:strip_insignificant_zeros+]

The thousands delimiter. Defaults to ",".
[+:delimiter+]

# => "1,18 MB"
number_to_human_size(1234567, separator: ",")

The decimal separator. Defaults to ".".
[+:separator+]

fractional digits. Defaults to true.
Whether +:precision+ should be applied to significant digits instead of
[+:significant+]

# => "130 KB"
number_to_human_size(123456, precision: 2, round_mode: :up)

+:default+.
Specifies how rounding is performed. See +BigDecimal.mode+. Defaults to
[+:round_mode+]

number_to_human_size(1234567, precision: 2) # => "1.2 MB"
number_to_human_size(123456, precision: 2) # => "120 KB"

The level of precision. Defaults to 3.
[+:precision+]

The locale to use for formatting. Defaults to the current locale.
[+:locale+]

==== Options

See #number_to_human if you want to pretty-print a generic number.

number_to_human_size(1234567890123456789) # => "1.07 EB"
number_to_human_size(1234567890123456) # => "1.1 PB"
number_to_human_size(1234567890123) # => "1.12 TB"
number_to_human_size(1234567890) # => "1.15 GB"
number_to_human_size(1234567) # => "1.18 MB"
number_to_human_size(12345) # => "12.1 KB"
number_to_human_size(1234) # => "1.21 KB"
number_to_human_size(123) # => "123 Bytes"

Useful for reporting file sizes to users.
Formats +number+ as bytes into a more human-friendly representation.

def number_to_human_size(number, options = {})
  NumberToHumanSizeConverter.convert(number, options)
end

# => "100.000 %"
number_to_percentage(100, format: "%n %")

"%n%".
The format of the output. %n represents the number. Defaults to
[+:format+]

Defaults to false.
Whether to remove insignificant zeros after the decimal separator.
[+:strip_insignificant_zeros+]

The thousands delimiter. Defaults to ",".
[+:delimiter+]

The decimal separator. Defaults to ".".
[+:separator+]

number_to_percentage(12345.6789, precision: 2, significant: true) # => "12000%"
number_to_percentage(12345.6789, precision: 2) # => "12345.68%"
number_to_percentage(12345.6789, significant: true) # => "12300%"
number_to_percentage(12345.6789) # => "12345.679%"

fractional digits. Defaults to false.
Whether +:precision+ should be applied to significant digits instead of
[+:significant+]

# => "12.3456%"
number_to_percentage(12.3456789, precision: 4, round_mode: :down)

+:default+.
Specifies how rounding is performed. See +BigDecimal.mode+. Defaults to
[+:round_mode+]

number_to_percentage(99.999, precision: nil) # => "99.999%"
number_to_percentage(99.999, precision: 0) # => "100%"
number_to_percentage(12.3456789, precision: 4) # => "12.3457%"

Defaults to 2.
The level of precision, or +nil+ to preserve +number+'s precision.
[+:precision+]

# => "1000,000%"
number_to_percentage(1000, locale: :fr)

The locale to use for formatting. Defaults to the current locale.
[+:locale+]

==== Options

# => "12.345,68%"
number_to_percentage(12345.6789, delimiter: ".", separator: ",", precision: 2)

number_to_percentage("99x") # => "99x%"
number_to_percentage("99") # => "99.000%"
number_to_percentage(100) # => "100.000%"

Formats +number+ as a percentage string.

def number_to_percentage(number, options = {})
  NumberToPercentageConverter.convert(number, options)
end

# => "(755) 6123-4567"
number_to_phone(75561234567, pattern: /(\d{1,4})(\d{4})(\d{4})$/, area_code: true)
# => "133-1234-5678"
number_to_phone(13312345678, pattern: /(\d{3})(\d{4})(\d{4})$/)

three captures from the regexp are treated as digit groups.
A regexp that specifies how the digits should be grouped. The first
[+:pattern+]

# => "123-555-1234 x 555"
number_to_phone(1235551234, extension: 555)

An extension to append.
[+:extension+]

# => "+1-123-555-1234"
number_to_phone(1235551234, country_code: 1)

A country code to prepend.
[+:country_code+]

# => "123 555 1234"
number_to_phone(1235551234, delimiter: " ")

The digit group delimiter to use. Defaults to "-".
[+:delimiter+]

# => "(123) 555-1234"
number_to_phone(1235551234, area_code: true)

Whether to use parentheses for the area code. Defaults to false.
[+:area_code+]

==== Options

# => "+1.123.555.1234 x 1343"
number_to_phone(1235551234, delimiter: ".", country_code: 1, extension: 1343)

number_to_phone("12x34") # => "12x34"
number_to_phone(1235551234) # => "123-555-1234"
number_to_phone("5551234") # => "555-1234"
number_to_phone(5551234) # => "555-1234"

Formats +number+ into a phone number.

def number_to_phone(number, options = {})
  NumberToPhoneConverter.convert(number, options)
end

number_to_rounded(12.3456, strip_insignificant_zeros: true) # => "12.346"
number_to_rounded(12.34, strip_insignificant_zeros: true) # => "12.34"
number_to_rounded(12.34, strip_insignificant_zeros: false) # => "12.340"

Defaults to false.
Whether to remove insignificant zeros after the decimal separator.
[+:strip_insignificant_zeros+]

The thousands delimiter. Defaults to ",".
[+:delimiter+]

The decimal separator. Defaults to ".".
[+:separator+]

number_to_rounded(12345.6789, precision: 2, significant: true) # => "12000"
number_to_rounded(12345.6789, precision: 2) # => "12345.68"
number_to_rounded(12345.6789, significant: true) # => "12300"
number_to_rounded(12345.6789) # => "12345.679"

fractional digits. Defaults to false.
Whether +:precision+ should be applied to significant digits instead of
[+:significant+]

# => "13"
number_to_rounded(12.34, precision: 0, round_mode: :up)

+:default+.
Specifies how rounding is performed. See +BigDecimal.mode+. Defaults to
[+:round_mode+]

# => "12345.6789"
number_to_rounded(12345.6789, precision: nil)

Defaults to 3.
The level of precision, or +nil+ to preserve +number+'s precision.
[+:precision+]

# => "111,234"
number_to_rounded(111.234, locale: :fr)

The locale to use for formatting. Defaults to the current locale.
[+:locale+]

==== Options

number_to_rounded(12345, precision: 5) # => "12345.00000"
number_to_rounded(12345.6789, precision: 0) # => "12345"
number_to_rounded(12345.6789, precision: 2) # => "12345.68"
number_to_rounded(12345.6789) # => "12345.679"

Formats +number+ to a specific level of precision.

def number_to_rounded(number, options = {})
  NumberToRoundedConverter.convert(number, options)
end