active_object 2.5.2 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -2,7 +2,6 @@ module Enumerable
2
2
 
3
3
  def cluster(&block)
4
4
  result = []
5
-
6
5
  each do |element|
7
6
  if result.last && (yield(result.last.last) == yield(element))
8
7
  result.last << element
@@ -10,7 +9,6 @@ module Enumerable
10
9
  result << [element]
11
10
  end
12
11
  end
13
-
14
12
  result
15
13
  end
16
14
 
@@ -41,7 +39,7 @@ module Enumerable
41
39
  def drop_last_if
42
40
  return(to_enum(:drop_last_if)) unless block_given?
43
41
 
44
- result = []
42
+ result = []
45
43
  dropping = true
46
44
  reverse_each do |value|
47
45
  result.unshift(value) unless dropping &&= yield(value)
@@ -55,10 +53,8 @@ module Enumerable
55
53
  (found_count > n) ? false : n == found_count
56
54
  end
57
55
 
58
- unless defined?(Rails)
59
- def exclude?(object)
60
- !include?(object)
61
- end
56
+ def exclude?(object)
57
+ !include?(object)
62
58
  end
63
59
 
64
60
  def expand
@@ -81,17 +77,15 @@ module Enumerable
81
77
  any? { |x| object === x }
82
78
  end
83
79
 
84
- unless defined?(Rails)
85
- def many?
86
- found_count = 0
87
- if block_given?
88
- any? do |v|
89
- found_count += 1 if yield v
90
- found_count > 1
91
- end
92
- else
93
- any? { (found_count += 1) > 1 }
80
+ def many?
81
+ found_count = 0
82
+ if block_given?
83
+ any? do |v|
84
+ found_count += 1 if yield v
85
+ found_count > 1
94
86
  end
87
+ else
88
+ any? { (found_count += 1) > 1 }
95
89
  end
96
90
  end
97
91
 
@@ -110,6 +104,8 @@ module Enumerable
110
104
  sum.to_f / collection_length.to_f
111
105
  end
112
106
 
107
+ alias_method :average, :mean
108
+
113
109
  def median(identity=0)
114
110
  collection_length = length.to_f
115
111
  collection_sorted = sort
@@ -127,7 +123,7 @@ module Enumerable
127
123
  return(identity) unless length > 0
128
124
 
129
125
  frequency_distribution = inject(Hash.new(0)) { |h, v| h[v] += 1; h }
130
- frequency_top_two = frequency_distribution.sort { |k, v| v[1] <=> k[1] }.take(2)
126
+ frequency_top_two = frequency_distribution.sort { |k, v| v[1] <=> k[1] }.take(2)
131
127
 
132
128
  if frequency_top_two.length == 1
133
129
  frequency_top_two.first.first
@@ -165,13 +161,11 @@ module Enumerable
165
161
  Math.sqrt(variance)
166
162
  end
167
163
 
168
- unless defined?(Rails)
169
- def sum(identity=0, &block)
170
- if block_given?
171
- map(&block).sum(identity)
172
- else
173
- inject { |s, v| s + v } || identity
174
- end
164
+ def sum(identity=0, &block)
165
+ if block_given?
166
+ map(&block).sum(identity)
167
+ else
168
+ inject { |s, v| s + v } || identity
175
169
  end
176
170
  end
177
171
 
@@ -200,4 +194,4 @@ module Enumerable
200
194
  sum.to_f / (collection_length.to_f - 1.0)
201
195
  end
202
196
 
203
- end
197
+ end
@@ -1,48 +1,49 @@
1
- class Hash
2
-
3
- unless defined?(Rails)
4
- def assert_valid_keys(*valid_keys)
5
- valid_keys.flatten!
6
- each_key do |k|
7
- unless valid_keys.include?(k)
8
- raise ArgumentError,
9
- "Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
10
- end
1
+ module ActiveObject::Hash
2
+
3
+ def assert_valid_keys(*valid_keys)
4
+ valid_keys.flatten!
5
+
6
+ each_key do |k|
7
+ unless valid_keys.include?(k)
8
+ raise ArgumentError,
9
+ "Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
11
10
  end
12
11
  end
13
12
  end
14
13
 
15
- unless defined?(Rails)
16
- def compact
17
- select { |k, v| !v.nil? }
18
- end
14
+ def compact
15
+ select { |k, v| !v.nil? }
19
16
  end
20
17
 
21
- unless defined?(Rails)
22
- def compact!
23
- reject! { |k, v| v.nil? }
24
- end
18
+ def compact!
19
+ reject! { |k, v| v.nil? }
25
20
  end
26
21
 
27
- unless defined?(Rails)
28
- def deep_merge(other_hash, &block)
29
- dup.deep_merge!(other_hash, &block)
30
- end
22
+ def deep_merge(other_hash, &block)
23
+ dup.deep_merge!(other_hash, &block)
31
24
  end
32
25
 
33
- unless defined?(Rails)
34
- def deep_merge!(other_hash, &block)
35
- other_hash.each_pair do |current_key, other_value|
36
- this_value = self[current_key]
26
+ def deep_merge!(other_hash, &block)
27
+ other_hash.each_pair do |current_key, other_value|
28
+ this_value = self[current_key]
37
29
 
38
- self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
39
- this_value.deep_merge(other_value, &block)
40
- else
41
- block_given? && key?(current_key) ? block.call(current_key, this_value, other_value) : other_value
42
- end
30
+ self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
31
+ this_value.deep_merge(other_value, &block)
32
+ else
33
+ block_given? && key?(current_key) ? block.call(current_key, this_value, other_value) : other_value
43
34
  end
35
+ end
44
36
 
45
- self
37
+ self
38
+ end
39
+
40
+ def dig(key, *rest)
41
+ if value = (self[key] rescue nil)
42
+ if rest.empty?
43
+ value
44
+ elsif value.respond_to?(:dig)
45
+ value.dig(*rest)
46
+ end
46
47
  end
47
48
  end
48
49
 
@@ -91,16 +92,12 @@ class Hash
91
92
  self
92
93
  end
93
94
 
94
- unless defined?(Rails)
95
- def reverse_merge(other_hash)
96
- other_hash.merge(self)
97
- end
95
+ def reverse_merge(other_hash)
96
+ other_hash.merge(self)
98
97
  end
99
98
 
100
- unless defined?(Rails)
101
- def reverse_merge!(other_hash)
102
- replace(reverse_merge(other_hash))
103
- end
99
+ def reverse_merge!(other_hash)
100
+ replace(reverse_merge(other_hash))
104
101
  end
105
102
 
106
103
  def sample
@@ -143,37 +140,29 @@ class Hash
143
140
  replace(shuffle)
144
141
  end
145
142
 
146
- unless defined?(Rails)
147
- def slice(*keys)
148
- keys.flatten.each_with_object(self.class.new) { |k, h| h[k] = self[k] if has_key?(k) }
149
- end
143
+ def slice(*keys)
144
+ keys.flatten.each_with_object(self.class.new) { |k, h| h[k] = self[k] if has_key?(k) }
150
145
  end
151
146
 
152
- unless defined?(Rails)
153
- def slice!(*keys)
154
- omit = slice(*self.keys - keys)
155
- hash = slice(*keys)
147
+ def slice!(*keys)
148
+ omit = slice(*self.keys - keys)
149
+ hash = slice(*keys)
156
150
 
157
- hash.default = default
158
- hash.default_proc = default_proc if default_proc
151
+ hash.default = default
152
+ hash.default_proc = default_proc if default_proc
159
153
 
160
- replace(hash)
161
- omit
162
- end
154
+ replace(hash)
155
+ omit
163
156
  end
164
157
 
165
- unless defined?(Rails)
166
- def stringify_keys
167
- dup.stringify_keys!
168
- end
158
+ def stringify_keys
159
+ dup.stringify_keys!
169
160
  end
170
161
 
171
- unless defined?(Rails)
172
- def stringify_keys!
173
- inject({}) do |options, (key, value)|
174
- options[key.to_s] = value
175
- options
176
- end
162
+ def stringify_keys!
163
+ inject({}) do |options, (key, value)|
164
+ options[key.to_s] = value
165
+ options
177
166
  end
178
167
  end
179
168
 
@@ -185,18 +174,14 @@ class Hash
185
174
  reject! { |k, v| v.blank? }
186
175
  end
187
176
 
188
- unless defined?(Rails)
189
- def symbolize_keys
190
- dup.symbolize_keys!
191
- end
177
+ def symbolize_keys
178
+ dup.symbolize_keys!
192
179
  end
193
180
 
194
- unless defined?(Rails)
195
- def symbolize_keys!
196
- inject({}) do |options, (key, value)|
197
- options[(key.to_sym rescue key) || key] = value
198
- options
199
- end
181
+ def symbolize_keys!
182
+ inject({}) do |options, (key, value)|
183
+ options[(key.to_sym rescue key) || key] = value
184
+ options
200
185
  end
201
186
  end
202
187
 
@@ -206,38 +191,32 @@ class Hash
206
191
 
207
192
  def symbolize_and_underscore_keys!
208
193
  inject({}) do |options, (key, value)|
209
- options[(key.to_s.gsub(' '.freeze, '_'.freeze).underscore.to_sym rescue key) || key] = value
194
+ options[(key.to_s.gsub(" ", "_").underscore.to_sym rescue key) || key] = value
210
195
  options
211
196
  end
212
197
  end
213
198
 
214
- unless defined?(Rails)
215
- def transform_keys(&block)
216
- dup.transform_keys!(&block)
217
- end
199
+ def transform_keys(&block)
200
+ dup.transform_keys!(&block)
218
201
  end
219
202
 
220
- unless defined?(Rails)
221
- def transform_keys!(&block)
222
- return(enum_for(:transform_keys!)) unless block_given?
203
+ def transform_keys!(&block)
204
+ return(enum_for(:transform_keys!)) unless block_given?
223
205
 
224
- keys.each { |k| self[yield(k)] = delete(k) }
225
- self
226
- end
206
+ keys.each { |k| self[yield(k)] = delete(k) }
207
+ self
227
208
  end
228
209
 
229
- unless defined?(Rails)
230
- def transform_values(&block)
231
- dup.transform_values!(&block)
232
- end
210
+ def transform_values(&block)
211
+ dup.transform_values!(&block)
233
212
  end
234
213
 
235
- unless defined?(Rails)
236
- def transform_values!(&block)
237
- return(enum_for(:transform_values!)) unless block_given?
214
+ def transform_values!(&block)
215
+ return(enum_for(:transform_values!)) unless block_given?
238
216
 
239
- each { |k, v| self[k] = yield(v) }
240
- end
217
+ each { |k, v| self[k] = yield(v) }
241
218
  end
242
219
 
243
- end
220
+ end
221
+
222
+ Hash.send(:include, ActiveObject::Hash) if ActiveObject.configuration.autoload_hash
@@ -1,20 +1,9 @@
1
- class Integer
1
+ module ActiveObject::Integer
2
2
 
3
3
  ROMAN_VALUES = {
4
- 'M' => 1000,
5
- 'CM' => 900,
6
- 'D' => 500,
7
- 'CD' => 400,
8
- 'C' => 100,
9
- 'XC' => 90,
10
- 'L' => 50,
11
- 'XL' => 40,
12
- 'X' => 10,
13
- 'IX' => 9,
14
- 'V' => 5,
15
- 'IV' => 4,
16
- 'I' => 1
17
- }.freeze
4
+ M: 1000, CM: 900, D: 500, CD: 400, C: 100, XC: 90, L: 50, XL: 40, X: 10,
5
+ IX: 9, V: 5, IV: 4, I: 1
6
+ }
18
7
 
19
8
  def factorial
20
9
  return(1) if zero?
@@ -26,7 +15,7 @@ class Integer
26
15
  end
27
16
 
28
17
  def roman
29
- return(''.freeze) if zero?
18
+ return("") if zero?
30
19
  return("-#{(-self).roman}") if self < 0
31
20
 
32
21
  ROMAN_VALUES.each { |k, v| return("#{k}#{(self - v).roman}") if v <= self }
@@ -36,4 +25,6 @@ class Integer
36
25
  Time.at(self)
37
26
  end
38
27
 
39
- end
28
+ end
29
+
30
+ Integer.send(:include, ActiveObject::Integer) if ActiveObject.configuration.autoload_integer
@@ -1,40 +1,68 @@
1
- class Numeric
1
+ module ActiveObject::Numeric
2
2
 
3
3
  MILLI = 0.001
4
4
  CENTI = MILLI * 10
5
- DECI = CENTI * 10
6
- DECA = 10
5
+ DECI = CENTI * 10
6
+ DECA = 10
7
7
  HECTO = DECA * 10
8
- KILO = HECTO * 10
9
-
10
- unless defined?(Rails)
11
- KILOBYTE = 1024
12
- MEGABYTE = KILOBYTE * 1024
13
- GIGABYTE = MEGABYTE * 1024
14
- TERABYTE = GIGABYTE * 1024
15
- PETABYTE = TERABYTE * 1024
16
- EXABYTE = PETABYTE * 1024
17
- end
18
-
19
- FEET = 12
20
- YARD = FEET * 3
21
- MILE = YARD * 1760
8
+ KILO = HECTO * 10
9
+
10
+ KILOBYTE = 1024
11
+ MEGABYTE = KILOBYTE * 1024
12
+ GIGABYTE = MEGABYTE * 1024
13
+ TERABYTE = GIGABYTE * 1024
14
+ PETABYTE = TERABYTE * 1024
15
+ EXABYTE = PETABYTE * 1024
16
+
17
+ FEET = 12
18
+ YARD = FEET * 3
19
+ MILE = YARD * 1760
22
20
  NAUTICAL_MILE = MILE * 1.15078
23
21
 
24
22
  METRIC_TON = KILO * 1000
25
- POUND = 16
26
- STONE = POUND * 14
27
- TON = POUND * 2000
28
-
29
- MINUTE = 60
30
- HOUR = MINUTE * 60
31
- DAY = HOUR * 24
32
- WEEK = DAY * 7
33
- YEAR = DAY * 365.25
34
- DECADE = YEAR * 10
35
- CENTURY = DECADE * 10
23
+ POUND = 16
24
+ STONE = POUND * 14
25
+ TON = POUND * 2000
26
+
27
+ MINUTE = 60
28
+ HOUR = MINUTE * 60
29
+ DAY = HOUR * 24
30
+ WEEK = DAY * 7
31
+ YEAR = DAY * 365.25
32
+ DECADE = YEAR * 10
33
+ CENTURY = DECADE * 10
36
34
  MILLENNIUM = CENTURY * 10
37
35
 
36
+ BYTE_KEYS = [
37
+ :byte, :bytes, :kilobyte, :kilobytes, :megabyte, :megabytes, :gigabyte,
38
+ :gigabytes, :terabyte, :terabytes, :petabyte, :petabytes, :exabyte, :exabytes
39
+ ]
40
+ LENGTH_KEYS = {
41
+ metric: [
42
+ :meter, :meters, :millimeter, :millimeters, :centimeter, :centimeters,
43
+ :decimeter, :decimeters, :decameter, :decameters, :hectometer, :hectometers,
44
+ :kilometer, :kilometers
45
+ ],
46
+ imperical: [
47
+ :inch, :inches, :foot, :feet, :yard, :yards, :mile, :miles,
48
+ :nautical_mile, :nautical_miles
49
+ ]
50
+ }
51
+ MASS_KEYS = {
52
+ metric: [
53
+ :gram, :grams, :milligram, :milligrams, :centigram, :centigrams,
54
+ :decigram, :decigrams, :decagram, :decagrams, :hectogram, :hectograms,
55
+ :kilogram, :kilograms, :metric_ton, :metric_tons
56
+ ],
57
+ imperical: [:ounce, :ounces, :pound, :pounds, :stone, :stones, :ton, :tons]
58
+ }
59
+ TEMPERATURE_KEYS = [:celsius, :fahrenheit, :kelvin]
60
+ TIME_KEYS = [
61
+ :second, :seconds, :minute, :minutes, :hour, :hours, :day, :days,
62
+ :week, :weeks, :year, :years, :decade, :decades, :century, :centuries,
63
+ :millennium, :millenniums
64
+ ]
65
+
38
66
  def add(n)
39
67
  self + n
40
68
  end
@@ -63,6 +91,14 @@ class Numeric
63
91
 
64
92
  alias_method :century_in_seconds, :centuries_in_seconds
65
93
 
94
+ def clamp(min, max=nil)
95
+ if max.nil? && min.is_a?(Range)
96
+ self < min.min ? min.min : self > min.max ? min.max : self
97
+ else
98
+ self < min ? min : self > max ? max : self
99
+ end
100
+ end
101
+
66
102
  def days_in_seconds
67
103
  self * DAY
68
104
  end
@@ -99,6 +135,16 @@ class Numeric
99
135
 
100
136
  alias_method :decimeter_in_meters, :decimeters_in_meters
101
137
 
138
+ def decrement(amount=1.0)
139
+ self + amount
140
+ end
141
+
142
+ def degrees_to_radians
143
+ self * Math::PI / 180.0
144
+ end
145
+
146
+ alias_method :degree_to_radians, :degrees_to_radians
147
+
102
148
  def distance(n)
103
149
  (self - n).abs
104
150
  end
@@ -163,6 +209,10 @@ class Numeric
163
209
 
164
210
  alias_method :inch_in_inches, :inches_in_inches
165
211
 
212
+ def increment(amount=1.0)
213
+ self + amount
214
+ end
215
+
166
216
  def inside?(start, finish)
167
217
  (start < self) && (self < finish)
168
218
  end
@@ -245,10 +295,8 @@ class Numeric
245
295
  self * n
246
296
  end
247
297
 
248
- unless defined?(Rails)
249
- def multiple_of?(number)
250
- number != 0 ? modulo(number).zero? : zero?
251
- end
298
+ def multiple_of?(number)
299
+ number != 0 ? modulo(number).zero? : zero?
252
300
  end
253
301
 
254
302
  def nautical_miles_in_inches
@@ -261,27 +309,23 @@ class Numeric
261
309
  self < 0
262
310
  end
263
311
 
264
- unless defined?(Rails)
265
- def ordinal
266
- abs_number = abs
312
+ def ordinal
313
+ abs_number = abs
267
314
 
268
- if (11..13).cover?(abs_number % 100)
269
- 'th'.freeze
270
- else
271
- case abs_number % 10
272
- when 1; 'st'.freeze
273
- when 2; 'nd'.freeze
274
- when 3; 'rd'.freeze
275
- else 'th'.freeze
276
- end
315
+ if (11..13).cover?(abs_number % 100)
316
+ "th"
317
+ else
318
+ case abs_number % 10
319
+ when 1; "st"
320
+ when 2; "nd"
321
+ when 3; "rd"
322
+ else "th"
277
323
  end
278
324
  end
279
325
  end
280
326
 
281
- unless defined?(Rails)
282
- def ordinalize
283
- "#{self}#{self.ordinal}"
284
- end
327
+ def ordinalize
328
+ "#{self}#{self.ordinal}"
285
329
  end
286
330
 
287
331
  def ounces_in_ounces
@@ -296,21 +340,21 @@ class Numeric
296
340
 
297
341
  def pad(options={})
298
342
  pad_number = options.fetch(:pad_number, 0)
299
- precision = options.fetch(:precision, 3)
343
+ precision = options.fetch(:precision, 3)
300
344
 
301
345
  to_s.rjust(precision, pad_number.to_s)
302
346
  end
303
347
 
304
348
  def pad_precision(options={})
305
349
  pad_number = options.fetch(:pad_number, 0)
306
- precision = options.fetch(:precision, 2)
307
- separator = options.fetch(:separator, '.'.freeze)
308
- string = to_s
350
+ precision = options.fetch(:precision, 2)
351
+ separator = options.fetch(:separator, ".")
352
+ string = to_s
309
353
 
310
- string << separator unless string.include?(separator)
354
+ string << separator unless string.include?(separator)
311
355
  ljust_count = string.split(separator).first.length
312
356
  ljust_count += (string.count(separator) + precision) if precision > 0
313
- num_count = string.length
357
+ num_count = string.length
314
358
  ljust_count >= num_count ? string.ljust(ljust_count, pad_number.to_s) : string[0..(ljust_count - 1)]
315
359
  end
316
360
 
@@ -361,62 +405,40 @@ class Numeric
361
405
  alias_method :terabyte_in_bytes, :terabytes_in_bytes
362
406
 
363
407
  def to_byte(from, to)
364
- valid_keys = [
365
- :byte, :bytes,
366
- :kilobyte, :kilobytes,
367
- :megabyte, :megabytes,
368
- :gigabyte, :gigabytes,
369
- :terabyte, :terabytes,
370
- :petabyte, :petabytes,
371
- :exabyte, :exabytes
372
- ].freeze
373
-
374
- unless valid_keys.include?(from) && valid_keys.include?(to)
408
+ unless BYTE_KEYS.include?(from) && BYTE_KEYS.include?(to)
375
409
  raise ArgumentError,
376
- "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
410
+ "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{BYTE_KEYS.map(&:inspect).join(', ')}"
377
411
  end
378
412
 
379
413
  to_f * 1.send("#{from}_in_bytes").to_f / 1.send("#{to}_in_bytes").to_f
380
414
  end
381
415
 
382
416
  def to_currency(options={})
383
- unit = options.fetch(:unit, '$'.freeze)
417
+ unit = options.fetch(:unit, "$")
384
418
 
385
419
  "#{unit}#{pad_precision(options.only(:precision))}"
386
420
  end
387
421
 
388
422
  def to_length(from, to)
389
- valid_keys = [
390
- :meter, :meters,
391
- :millimeter, :millimeters,
392
- :centimeter, :centimeters,
393
- :decimeter, :decimeters,
394
- :decameter, :decameters,
395
- :hectometer, :hectometers,
396
- :kilometer, :kilometers,
397
- :inch, :inches,
398
- :foot, :feet,
399
- :yard, :yards,
400
- :mile, :miles,
401
- :nautical_mile, :nautical_miles
402
- ].freeze
423
+ metric_keys = LENGTH_KEYS.fetch(:metric)
424
+ valid_keys = LENGTH_KEYS.collect { |k, v| v }.flatten
403
425
 
404
426
  unless valid_keys.include?(from) && valid_keys.include?(to)
405
427
  raise ArgumentError,
406
- "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
428
+ "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
407
429
  end
408
430
 
409
431
  case to
410
432
  when from
411
433
  self
412
434
  when :meter, :meters, :millimeter, :millimeters, :centimeter, :centimeters, :decimeter, :decimeters, :decameter, :decameters, :hectometer, :hectometers, :kilometer, :kilometers
413
- if valid_keys.first(14).include?(from)
435
+ if metric_keys.include?(from)
414
436
  to_f * 1.send("#{from}_in_meters").to_f / 1.send("#{to}_in_meters").to_f
415
437
  else
416
438
  to_f * ((1.send("#{from}_in_inches").to_f * 0.0254) / 1.send("#{to}_in_meters").to_f)
417
439
  end
418
440
  when :inch, :inches, :foot, :feet, :yard, :yards, :mile, :miles, :nautical_mile, :nautical_miles
419
- if valid_keys.first(14).include?(from)
441
+ if metric_keys.include?(from)
420
442
  to_f * ((1.send("#{from}_in_meters").to_f * 39.3701) / 1.send("#{to}_in_inches").to_f)
421
443
  else
422
444
  to_f * 1.send("#{from}_in_inches").to_f / 1.send("#{to}_in_inches").to_f
@@ -425,37 +447,25 @@ class Numeric
425
447
  end
426
448
 
427
449
  def to_mass(from, to)
428
- valid_keys = [
429
- :gram, :grams,
430
- :milligram, :milligrams,
431
- :centigram, :centigrams,
432
- :decigram, :decigrams,
433
- :decagram, :decagrams,
434
- :hectogram, :hectograms,
435
- :kilogram, :kilograms,
436
- :metric_ton, :metric_tons,
437
- :ounce, :ounces,
438
- :pound, :pounds,
439
- :stone, :stones,
440
- :ton, :tons
441
- ].freeze
450
+ metric_keys = MASS_KEYS.fetch(:metric)
451
+ valid_keys = MASS_KEYS.collect { |k, v| v }.flatten
442
452
 
443
453
  unless valid_keys.include?(from) && valid_keys.include?(to)
444
454
  raise ArgumentError,
445
- "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
455
+ "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
446
456
  end
447
457
 
448
458
  case to
449
459
  when from
450
460
  self
451
461
  when :gram, :grams, :milligram, :milligrams, :centigram, :centigrams, :decigram, :decigrams, :decagram, :decagrams, :hectogram, :hectograms, :kilogram, :kilograms, :metric_ton, :metric_tons
452
- if valid_keys.first(16).include?(from)
462
+ if metric_keys.include?(from)
453
463
  to_f * 1.send("#{from}_in_grams").to_f / 1.send("#{to}_in_grams").to_f
454
464
  else
455
465
  to_f * ((1.send("#{from}_in_ounces") * 28.3495).to_f / 1.send("#{to}_in_grams").to_f)
456
466
  end
457
467
  when :ounce, :ounces, :pound, :pounds, :stone, :stones, :ton, :tons
458
- if valid_keys.first(16).include?(from)
468
+ if metric_keys.include?(from)
459
469
  to_f * ((1.send("#{from}_in_grams") * 0.035274).to_f / 1.send("#{to}_in_ounces").to_f)
460
470
  else
461
471
  to_f * 1.send("#{from}_in_ounces").to_f / 1.send("#{to}_in_ounces").to_f
@@ -466,13 +476,13 @@ class Numeric
466
476
  def to_nearest_value(values=[])
467
477
  return(self) if values.length.zero?
468
478
 
469
- value = values.first
479
+ value = values.first
470
480
  difference = (self - value).abs
471
481
 
472
482
  values.each do |v|
473
483
  if (self - v).abs < difference
474
484
  difference = (self - v).abs
475
- value = v
485
+ value = v
476
486
  end
477
487
  end
478
488
 
@@ -480,52 +490,36 @@ class Numeric
480
490
  end
481
491
 
482
492
  def to_percentage(options={})
483
- unit = options.fetch(:unit, '%'.freeze)
493
+ unit = options.fetch(:unit, "%")
484
494
 
485
495
  "#{pad_precision(options.only(:precision))}#{unit}"
486
496
  end
487
497
 
488
498
  def to_temperature(from, to)
489
- valid_keys = [:celsius, :fahrenheit, :kelvin].freeze
490
-
491
- unless valid_keys.include?(from) && valid_keys.include?(to)
499
+ unless TEMPERATURE_KEYS.include?(from) && TEMPERATURE_KEYS.include?(to)
492
500
  raise ArgumentError,
493
- "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
501
+ "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{TEMPERATURE_KEYS.map(&:inspect).join(', ')}"
494
502
  end
495
503
 
496
- number = to_f
497
-
498
504
  case to
499
505
  when from
500
506
  self
501
507
  when :celsius
502
- from == :kelvin ? (number - 273.15) : ((number - 32.0) * 5.0 / 9.0)
508
+ from == :kelvin ? (self - 273.15) : ((self - 32.0) * 5.0 / 9.0)
503
509
  when :fahrenheit
504
- from == :kelvin ? (1.8 * (number - 273.15) + 32.0) : ((number * 9.0 / 5.0) + 32.0)
510
+ from == :kelvin ? (1.8 * (self - 273.15) + 32.0) : ((self * 9.0 / 5.0) + 32.0)
505
511
  when :kelvin
506
- from == :celsius ? (number + 273.15) : (((number - 32.0) * 5.0 / 9.0) + 273.15)
512
+ from == :celsius ? (self + 273.15) : (((self - 32.0) * 5.0 / 9.0) + 273.15)
507
513
  end
508
514
  end
509
515
 
510
516
  def to_time(from, to)
511
- valid_keys = [
512
- :second, :seconds,
513
- :minute, :minutes,
514
- :hour, :hours,
515
- :day, :days,
516
- :week, :weeks,
517
- :year, :years,
518
- :decade, :decades,
519
- :century, :centuries,
520
- :millennium, :millenniums
521
- ].freeze
522
-
523
- unless valid_keys.include?(from) && valid_keys.include?(to)
517
+ unless TIME_KEYS.include?(from) && TIME_KEYS.include?(to)
524
518
  raise ArgumentError,
525
- "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', '.freeze)}"
519
+ "Unknown key(s): from: #{from.inspect} and to: #{to.inspect}. Valid keys are: #{TIME_KEYS.map(&:inspect).join(', ')}"
526
520
  end
527
521
 
528
- to_f * 1.send("#{from}_in_seconds").to_f / 1.send("#{to}_in_seconds").to_f
522
+ (to_f * 1.send("#{from}_in_seconds").to_f) / 1.send("#{to}_in_seconds").to_f
529
523
  end
530
524
 
531
525
  def tons_in_ounces
@@ -560,4 +554,6 @@ class Numeric
560
554
 
561
555
  alias_method :year_in_seconds, :years_in_seconds
562
556
 
563
- end
557
+ end
558
+
559
+ Numeric.send(:include, ActiveObject::Numeric) if ActiveObject.configuration.autoload_numeric