Class: Numeric

Inherits:
Object show all
Defined in:
lib/active_support/core_ext/object/blank.rb,
lib/active_support/core_ext/object/json.rb,
lib/active_support/core_ext/numeric/time.rb,
lib/active_support/core_ext/numeric/bytes.rb,
lib/active_support/core_ext/object/duplicable.rb,
lib/active_support/core_ext/numeric/conversions.rb,
lib/active_support/core_ext/string/output_safety.rb

Overview

:nodoc:

Constant Summary collapse

KILOBYTE = 
1024
MEGABYTE = 
KILOBYTE * 1024
GIGABYTE = 
MEGABYTE * 1024
TERABYTE = 
GIGABYTE * 1024
PETABYTE = 
TERABYTE * 1024
EXABYTE = 
PETABYTE * 1024

Instance Method Summary collapse

Instance Method Details

#as_json(options = nil) ⇒ Object

:nodoc:



92
93
94
 
# File 'lib/active_support/core_ext/object/json.rb', line 92

def as_json(options = nil) #:nodoc:
  self
end

#blank? ⇒ false

No number is blank:

1.blank? # => false
0.blank? # => false

Returns:

  • (false) 


128
129
130
 
# File 'lib/active_support/core_ext/object/blank.rb', line 128

def blank?
  false
end

#bytes ⇒ Object Also known as: byte

Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes



10
11
12
 
# File 'lib/active_support/core_ext/numeric/bytes.rb', line 10

def bytes
  self
end

#days ⇒ Object Also known as: day 



34
35
36
 
# File 'lib/active_support/core_ext/numeric/time.rb', line 34

def days
  ActiveSupport::Duration.new(self * 24.hours, [[:days, self]])
end

#duplicable? ⇒ Boolean

Numbers are not duplicable:

3.duplicable? # => false
3.dup         # => TypeError: can't dup Fixnum

Returns:

  • (Boolean) 


74
75
76
 
# File 'lib/active_support/core_ext/object/duplicable.rb', line 74

def duplicable?
  false
end

#exabytes ⇒ Object Also known as: exabyte 



40
41
42
 
# File 'lib/active_support/core_ext/numeric/bytes.rb', line 40

def exabytes
  self * EXABYTE
end

#fortnights ⇒ Object Also known as: fortnight 



44
45
46
 
# File 'lib/active_support/core_ext/numeric/time.rb', line 44

def fortnights
  ActiveSupport::Duration.new(self * 2.weeks, [[:days, self * 14]])
end

#gigabytes ⇒ Object Also known as: gigabyte 



25
26
27
 
# File 'lib/active_support/core_ext/numeric/bytes.rb', line 25

def gigabytes
  self * GIGABYTE
end

#hours ⇒ Object Also known as: hour 



29
30
31
 
# File 'lib/active_support/core_ext/numeric/time.rb', line 29

def hours
  ActiveSupport::Duration.new(self * 3600, [[:seconds, self * 3600]])
end

#html_safe? ⇒ Boolean

Returns:

  • (Boolean) 


126
127
128
 
# File 'lib/active_support/core_ext/string/output_safety.rb', line 126

def html_safe?
  true
end

#in_milliseconds ⇒ Object

Used with the standard time durations, like 1.hour.in_milliseconds – so we can feed them to JavaScript functions like getTime().



51
52
53
 
# File 'lib/active_support/core_ext/numeric/time.rb', line 51

def in_milliseconds
  self * 1000
end

#kilobytes ⇒ Object Also known as: kilobyte 



15
16
17
 
# File 'lib/active_support/core_ext/numeric/bytes.rb', line 15

def kilobytes
  self * KILOBYTE
end

#megabytes ⇒ Object Also known as: megabyte 



20
21
22
 
# File 'lib/active_support/core_ext/numeric/bytes.rb', line 20

def megabytes
  self * MEGABYTE
end

#minutes ⇒ Object Also known as: minute 



24
25
26
 
# File 'lib/active_support/core_ext/numeric/time.rb', line 24

def minutes
  ActiveSupport::Duration.new(self * 60, [[:seconds, self * 60]])
end

#petabytes ⇒ Object Also known as: petabyte 



35
36
37
 
# File 'lib/active_support/core_ext/numeric/bytes.rb', line 35

def petabytes
  self * PETABYTE
end

#seconds ⇒ Object Also known as: second

Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.

These methods use Time#advance for precise date calculations when using from_now, ago, etc. as well as adding or subtracting their results from a Time object. For example:

# equivalent to Time.current.advance(months: 1)
1.month.from_now

# equivalent to Time.current.advance(years: 2)
2.years.from_now

# equivalent to Time.current.advance(months: 4, years: 5)
(4.months + 5.years).from_now



19
20
21
 
# File 'lib/active_support/core_ext/numeric/time.rb', line 19

def seconds
  ActiveSupport::Duration.new(self, [[:seconds, self]])
end

#terabytes ⇒ Object Also known as: terabyte 



30
31
32
 
# File 'lib/active_support/core_ext/numeric/bytes.rb', line 30

def terabytes
  self * TERABYTE
end

#to_formatted_s(format = :default, options = {}) ⇒ Object

Provides options for converting numbers into formatted strings. Options are provided for phone numbers, currency, percentage, precision, positional notation, file size and pretty printing.

Options

For details on which formats use which options, see ActiveSupport::NumberHelper

Examples

Phone Numbers:
5551234.to_s(:phone)                                     # => 555-1234
1235551234.to_s(:phone)                                  # => 123-555-1234
1235551234.to_s(:phone, area_code: true)                 # => (123) 555-1234
1235551234.to_s(:phone, delimiter: ' ')                  # => 123 555 1234
1235551234.to_s(:phone, area_code: true, extension: 555) # => (123) 555-1234 x 555
1235551234.to_s(:phone, country_code: 1)                 # => +1-123-555-1234
1235551234.to_s(:phone, country_code: 1, extension: 1343, delimiter: '.')
# => +1.123.555.1234 x 1343

Currency:
1234567890.50.to_s(:currency)                 # => $1,234,567,890.50
1234567890.506.to_s(:currency)                # => $1,234,567,890.51
1234567890.506.to_s(:currency, precision: 3)  # => $1,234,567,890.506
1234567890.506.to_s(:currency, locale: :fr)   # => 1 234 567 890,51 €
-1234567890.50.to_s(:currency, negative_format: '(%u%n)')
# => ($1,234,567,890.50)
1234567890.50.to_s(:currency, unit: '£', separator: ',', delimiter: '')
# => £1234567890,50
1234567890.50.to_s(:currency, unit: '£', separator: ',', delimiter: '', format: '%n %u')
# => 1234567890,50 £

Percentage:
100.to_s(:percentage)                                  # => 100.000%
100.to_s(:percentage, precision: 0)                    # => 100%
1000.to_s(:percentage, delimiter: '.', separator: ',') # => 1.000,000%
302.24398923423.to_s(:percentage, precision: 5)        # => 302.24399%
1000.to_s(:percentage, locale: :fr)                    # => 1 000,000%
100.to_s(:percentage, format: '%n  %')                 # => 100  %

Delimited:
12345678.to_s(:delimited)                     # => 12,345,678
12345678.05.to_s(:delimited)                  # => 12,345,678.05
12345678.to_s(:delimited, delimiter: '.')     # => 12.345.678
12345678.to_s(:delimited, delimiter: ',')     # => 12,345,678
12345678.05.to_s(:delimited, separator: ' ')  # => 12,345,678 05
12345678.05.to_s(:delimited, locale: :fr)     # => 12 345 678,05
98765432.98.to_s(:delimited, delimiter: ' ', separator: ',')
# => 98 765 432,98

Rounded:
111.2345.to_s(:rounded)                                      # => 111.235
111.2345.to_s(:rounded, precision: 2)                        # => 111.23
13.to_s(:rounded, precision: 5)                              # => 13.00000
389.32314.to_s(:rounded, precision: 0)                       # => 389
111.2345.to_s(:rounded, significant: true)                   # => 111
111.2345.to_s(:rounded, precision: 1, significant: true)     # => 100
13.to_s(:rounded, precision: 5, significant: true)           # => 13.000
111.234.to_s(:rounded, locale: :fr)                          # => 111,234
13.to_s(:rounded, precision: 5, significant: true, strip_insignificant_zeros: true)
# => 13
389.32314.to_s(:rounded, precision: 4, significant: true)    # => 389.3
1111.2345.to_s(:rounded, precision: 2, separator: ',', delimiter: '.')
# => 1.111,23

Human-friendly size in Bytes:
123.to_s(:human_size)                                   # => 123 Bytes
1234.to_s(:human_size)                                  # => 1.21 KB
12345.to_s(:human_size)                                 # => 12.1 KB
1234567.to_s(:human_size)                               # => 1.18 MB
1234567890.to_s(:human_size)                            # => 1.15 GB
1234567890123.to_s(:human_size)                         # => 1.12 TB
1234567.to_s(:human_size, precision: 2)                 # => 1.2 MB
483989.to_s(:human_size, precision: 2)                  # => 470 KB
1234567.to_s(:human_size, precision: 2, separator: ',') # => 1,2 MB
1234567890123.to_s(:human_size, precision: 5)           # => "1.1229 TB"
524288000.to_s(:human_size, precision: 5)               # => "500 MB"

Human-friendly format:
123.to_s(:human)                                       # => "123"
1234.to_s(:human)                                      # => "1.23 Thousand"
12345.to_s(:human)                                     # => "12.3 Thousand"
1234567.to_s(:human)                                   # => "1.23 Million"
1234567890.to_s(:human)                                # => "1.23 Billion"
1234567890123.to_s(:human)                             # => "1.23 Trillion"
1234567890123456.to_s(:human)                          # => "1.23 Quadrillion"
1234567890123456789.to_s(:human)                       # => "1230 Quadrillion"
489939.to_s(:human, precision: 2)                      # => "490 Thousand"
489939.to_s(:human, precision: 4)                      # => "489.9 Thousand"
1234567.to_s(:human, precision: 4,
                 significant: false)                   # => "1.2346 Million"
1234567.to_s(:human, precision: 1,
                 separator: ',',
                 significant: false)                   # => "1,2 Million"



100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/active_support/core_ext/numeric/conversions.rb', line 100

def to_formatted_s(format = :default, options = {})
  case format
  when :phone
    return ActiveSupport::NumberHelper.number_to_phone(self, options)
  when :currency
    return ActiveSupport::NumberHelper.number_to_currency(self, options)
  when :percentage
    return ActiveSupport::NumberHelper.number_to_percentage(self, options)
  when :delimited
    return ActiveSupport::NumberHelper.number_to_delimited(self, options)
  when :rounded
    return ActiveSupport::NumberHelper.number_to_rounded(self, options)
  when :human
    return ActiveSupport::NumberHelper.number_to_human(self, options)
  when :human_size
    return ActiveSupport::NumberHelper.number_to_human_size(self, options)
  else
    self.to_default_s
  end
end

#weeks ⇒ Object Also known as: week 



39
40
41
 
# File 'lib/active_support/core_ext/numeric/time.rb', line 39

def weeks
  ActiveSupport::Duration.new(self * 7.days, [[:days, self * 7]])
end