opal-activesupport 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 05503ae39c125be204b6e7a30921e5670b75df73
-  data.tar.gz: 878e851f134727580575071d0a687fbdec13fe7f
+  metadata.gz: 1ada2f6b09639af729c6954a460c6863dc05ddba
+  data.tar.gz: b89c1416881f3758ad8abde63d0ad8f806348522
 SHA512:
-  metadata.gz: eac98e9d6353d62a92f0c4e7f05afc7170fffda43f5143ecdece7d2ba3eaa7dcc0ca0b1d81ec5f80976c4434501bce969046b098408fc7e90b508a206a2c3f51
-  data.tar.gz: 3e232e993bf00cc56a3f0154a7a604eb0886cd86cdc88b40dc65155c59892f48239773a1a9b2a8723440ece606ba7f3ae278d034a5f3dfe96d1602ce8a5ebd91
+  metadata.gz: 203f596c22653e4761384135f68ae4ffb918cbc068986cde6007666ed17f2942bcbba8622e474b11d75614947a73845802f28e6592ae43496bcd8c5833ed2901
+  data.tar.gz: 09b672496f995d6a756654425de73b64366b37b9fc50297e3e853402a01785dd537f62fcd3da206384cd4e0c4b7239d02df7b2e8c0f26301a81aeff60feb51f9

data/Gemfile

@@ -1,3 +1,5 @@
 source 'https://rubygems.org'
 
 gemspec
+
+gem 'opal', '~> 0.5.0'

data/Rakefile

@@ -1,7 +1,7 @@
 require 'bundler'
 Bundler.require
 
-require 'opal/spec/rake_task'
-Opal::Spec::RakeTask.new(:default)
+require 'opal/rspec/rake_task'
+Opal::RSpec::RakeTask.new(:default)
 
 require 'bundler/gem_tasks'

data/lib/opal/activesupport/version.rb

@@ -1,5 +1,5 @@
 module Opal
   module Activesupport
-    VERSION = '0.0.4'
+    VERSION = '0.0.5'
   end
 end

data/opal-activesupport.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ['lib']
 
-  gem.add_dependency 'opal', '~> 0.4.2'
-  gem.add_development_dependency 'opal-spec', '~> 0.2.17'
+  gem.add_dependency 'opal'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'opal-rspec'
 end

data/opal/active_support/core_ext/integer.rb

@@ -0,0 +1,3 @@
+# require 'active_support/core_ext/integer/multiple'
+# require 'active_support/core_ext/integer/inflections'
+require 'active_support/core_ext/integer/time'

data/opal/active_support/core_ext/integer/time.rb

@@ -0,0 +1,47 @@
+# require 'active_support/duration'
+require 'active_support/core_ext/numeric/time'
+
+# class Integer
+class Numeric
+  # Enables the use of time calculations and declarations, like <tt>45.minutes +
+  # 2.hours + 4.years</tt>.
+  #
+  # These methods use Time#advance for precise date calculations when using
+  # <tt>from_now</tt>, +ago+, etc. as well as adding or subtracting their
+  # results from a Time object.
+  #
+  #   # equivalent to Time.now.advance(months: 1)
+  #   1.month.from_now
+  #
+  #   # equivalent to Time.now.advance(years: 2)
+  #   2.years.from_now
+  #
+  #   # equivalent to Time.now.advance(months: 4, years: 5)
+  #   (4.months + 5.years).from_now
+  #
+  # While these methods provide precise calculation when used as in the examples
+  # above, care should be taken to note that this is not true if the result of
+  # +months+, +years+, etc is converted before use:
+  #
+  #   # equivalent to 30.days.to_i.from_now
+  #   1.month.to_i.from_now
+  #
+  #   # equivalent to 365.25.days.to_f.from_now
+  #   1.year.to_f.from_now
+  #
+  # In such cases, Ruby's core
+  # Date[http://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
+  # Time[http://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
+  # date and time arithmetic.
+  def months
+    # ActiveSupport::Duration.new(self * 30.days, [[:months, self]])
+    self * 30.days
+  end
+  alias :month :months
+
+  def years
+    # ActiveSupport::Duration.new(self * 365.25.days, [[:years, self]])
+    self * 365.25.days
+  end
+  alias :year :years
+end

data/opal/active_support/core_ext/numeric.rb

@@ -0,0 +1,2 @@
+require 'active_support/core_ext/numeric/time'
+require 'active_support/core_ext/numeric/calculations'

data/opal/active_support/core_ext/numeric/calculations.rb

@@ -0,0 +1,3 @@
+class << Time
+  alias :current :now
+end

data/opal/active_support/core_ext/numeric/time.rb

@@ -0,0 +1,85 @@
+# require 'active_support/duration'
+# require 'active_support/core_ext/time/calculations'
+# require 'active_support/core_ext/time/acts_like'
+
+class Numeric
+  # 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
+  #
+  # While these methods provide precise calculation when used as in the examples above, care
+  # should be taken to note that this is not true if the result of `months', `years', etc is
+  # converted before use:
+  #
+  #   # equivalent to 30.days.to_i.from_now
+  #   1.month.to_i.from_now
+  #
+  #   # equivalent to 365.25.days.to_f.from_now
+  #   1.year.to_f.from_now
+  #
+  # In such cases, Ruby's core
+  # Date[http://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
+  # Time[http://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
+  # date and time arithmetic.
+  def seconds
+    # ActiveSupport::Duration.new(self, [[:seconds, self]])
+    self
+  end
+  alias :second :seconds
+
+  def minutes
+    # ActiveSupport::Duration.new(self * 60, [[:seconds, self * 60]])
+    self * 60
+  end
+  alias :minute :minutes
+
+  def hours
+    # ActiveSupport::Duration.new(self * 3600, [[:seconds, self * 3600]])
+    self * 3600
+  end
+  alias :hour :hours
+
+  def days
+    # ActiveSupport::Duration.new(self * 24.hours, [[:days, self]])
+    self * 24.hours
+  end
+  alias :day :days
+
+  def weeks
+    # ActiveSupport::Duration.new(self * 7.days, [[:days, self * 7]])
+    self * 7.days
+  end
+  alias :week :weeks
+
+  def fortnights
+    # ActiveSupport::Duration.new(self * 2.weeks, [[:days, self * 14]])
+    self * 2.weeks
+  end
+  alias :fortnight :fortnights
+
+  # Reads best without arguments:  10.minutes.ago
+  def ago(time = ::Time.current)
+    time - self
+  end
+
+  # Reads best with argument:  10.minutes.until(time)
+  alias :until :ago
+
+  # Reads best with argument:  10.minutes.since(time)
+  def since(time = ::Time.current)
+    time + self
+  end
+
+  # Reads best without arguments:  10.minutes.from_now
+  alias :from_now :since
+end

data/opal/active_support/core_ext/string.rb

@@ -26,6 +26,16 @@ class String
     `#{self}.replace(/[-\\s]+/g, '_')
     .replace(/([A-Z\\d]+)([A-Z][a-z])/g, '$1_$2')
     .replace(/([a-z\\d])([A-Z])/g, '$1_$2')
+    .replace(/-/g, '_')
     .toLowerCase()`
   end
+
+  def camelize(first_letter = :upper)
+    `#{underscore}.replace(/(^|_)([^_]+)/g, function(match, pre, word, index) {
+      var capitalize = #{first_letter} === #{:upper} || index > 0;
+      return capitalize ? word.substr(0,1).toUpperCase()+word.substr(1) : word;
+    })`
+  end
+  alias_method :camelcase, :camelize
+
 end

data/opal/active_support/time.rb

@@ -0,0 +1,4 @@
+require 'date'
+require 'time'
+require 'active_support/core_ext/integer/time'
+require 'active_support/core_ext/numeric/time'

data/opal/opal-activesupport.rb

@@ -1 +1 @@
-require 'opal/activesupport'
+require 'active_support'

data/spec/core_ext/numeric_spec.rb

@@ -0,0 +1,512 @@
+require 'spec_helper'
+# require 'active_support/time'
+require 'active_support/core_ext/numeric'
+require 'active_support/core_ext/integer'
+
+describe 'Numeric' do
+  before do
+    # @now = Time.local(2005,2,10,15,30,45)
+    @now = Time.mktime(2005,2,10,15,30,45)
+    # @dtnow = DateTime.civil(2005,2,10,15,30,45)
+    @seconds = {
+      1.minute   => 60,
+      10.minutes => 600,
+      1.hour + 15.minutes => 4500,
+      2.days + 4.hours + 30.minutes => 189000,
+      5.years + 1.month + 1.fortnight => 161589600
+    }
+  end
+
+  it 'has time units' do
+    @seconds.each do |actual, expected|
+      actual.should == expected
+    end
+  end
+
+  it 'has intervals' do
+    @seconds.values.each do |seconds|
+      assert_equal seconds.since(@now), @now + seconds
+      assert_equal seconds.until(@now), @now - seconds
+    end
+  end
+end
+
+#   def test_intervals
+#     @seconds.values.each do |seconds|
+#       assert_equal seconds.since(@now), @now + seconds
+#       assert_equal seconds.until(@now), @now - seconds
+#     end
+#   end
+#
+#   # Test intervals based from Time.now
+#   def test_now
+#     @seconds.values.each do |seconds|
+#       now = Time.now
+#       assert seconds.ago >= now - seconds
+#       now = Time.now
+#       assert seconds.from_now >= now + seconds
+#     end
+#   end
+#
+#   def test_irregular_durations
+#     assert_equal @now.advance(:days => 3000), 3000.days.since(@now)
+#     assert_equal @now.advance(:months => 1), 1.month.since(@now)
+#     assert_equal @now.advance(:months => -1), 1.month.until(@now)
+#     assert_equal @now.advance(:years => 20), 20.years.since(@now)
+#     assert_equal @dtnow.advance(:days => 3000), 3000.days.since(@dtnow)
+#     assert_equal @dtnow.advance(:months => 1), 1.month.since(@dtnow)
+#     assert_equal @dtnow.advance(:months => -1), 1.month.until(@dtnow)
+#     assert_equal @dtnow.advance(:years => 20), 20.years.since(@dtnow)
+#   end
+#
+#   def test_duration_addition
+#     assert_equal @now.advance(:days => 1).advance(:months => 1), (1.day + 1.month).since(@now)
+#     assert_equal @now.advance(:days => 7), (1.week + 5.seconds - 5.seconds).since(@now)
+#     assert_equal @now.advance(:years => 2), (4.years - 2.years).since(@now)
+#     assert_equal @dtnow.advance(:days => 1).advance(:months => 1), (1.day + 1.month).since(@dtnow)
+#     assert_equal @dtnow.advance(:days => 7), (1.week + 5.seconds - 5.seconds).since(@dtnow)
+#     assert_equal @dtnow.advance(:years => 2), (4.years - 2.years).since(@dtnow)
+#   end
+#
+#   def test_time_plus_duration
+#     assert_equal @now + 8, @now + 8.seconds
+#     assert_equal @now + 22.9, @now + 22.9.seconds
+#     assert_equal @now.advance(:days => 15), @now + 15.days
+#     assert_equal @now.advance(:months => 1), @now + 1.month
+#     assert_equal @dtnow.since(8), @dtnow + 8.seconds
+#     assert_equal @dtnow.since(22.9), @dtnow + 22.9.seconds
+#     assert_equal @dtnow.advance(:days => 15), @dtnow + 15.days
+#     assert_equal @dtnow.advance(:months => 1), @dtnow + 1.month
+#   end
+#
+#   def test_chaining_duration_operations
+#     assert_equal @now.advance(:days => 2).advance(:months => -3), @now + 2.days - 3.months
+#     assert_equal @now.advance(:days => 1).advance(:months => 2), @now + 1.day + 2.months
+#     assert_equal @dtnow.advance(:days => 2).advance(:months => -3), @dtnow + 2.days - 3.months
+#     assert_equal @dtnow.advance(:days => 1).advance(:months => 2), @dtnow + 1.day + 2.months
+#   end
+#
+#   def test_duration_after_convertion_is_no_longer_accurate
+#     assert_equal 30.days.to_i.since(@now), 1.month.to_i.since(@now)
+#     assert_equal 365.25.days.to_f.since(@now), 1.year.to_f.since(@now)
+#     assert_equal 30.days.to_i.since(@dtnow), 1.month.to_i.since(@dtnow)
+#     assert_equal 365.25.days.to_f.since(@dtnow), 1.year.to_f.since(@dtnow)
+#   end
+#
+#   def test_add_one_year_to_leap_day
+#     assert_equal Time.utc(2005,2,28,15,15,10), Time.utc(2004,2,29,15,15,10) + 1.year
+#     assert_equal DateTime.civil(2005,2,28,15,15,10), DateTime.civil(2004,2,29,15,15,10) + 1.year
+#   end
+#
+#   def test_since_and_ago_anchored_to_time_now_when_time_zone_is_not_set
+#     Time.zone = nil
+#     with_env_tz 'US/Eastern' do
+#       Time.stubs(:now).returns Time.local(2000)
+#       # since
+#       assert_equal false, 5.since.is_a?(ActiveSupport::TimeWithZone)
+#       assert_equal Time.local(2000,1,1,0,0,5), 5.since
+#       # ago
+#       assert_equal false, 5.ago.is_a?(ActiveSupport::TimeWithZone)
+#       assert_equal Time.local(1999,12,31,23,59,55), 5.ago
+#     end
+#   end
+#
+#   def test_since_and_ago_anchored_to_time_zone_now_when_time_zone_is_set
+#     Time.zone = ActiveSupport::TimeZone['Eastern Time (US & Canada)']
+#     with_env_tz 'US/Eastern' do
+#       Time.stubs(:now).returns Time.local(2000)
+#       # since
+#       assert_equal true, 5.since.is_a?(ActiveSupport::TimeWithZone)
+#       assert_equal Time.utc(2000,1,1,0,0,5), 5.since.time
+#       assert_equal 'Eastern Time (US & Canada)', 5.since.time_zone.name
+#       # ago
+#       assert_equal true, 5.ago.is_a?(ActiveSupport::TimeWithZone)
+#       assert_equal Time.utc(1999,12,31,23,59,55), 5.ago.time
+#       assert_equal 'Eastern Time (US & Canada)', 5.ago.time_zone.name
+#     end
+#   ensure
+#     Time.zone = nil
+#   end
+#
+#   protected
+#     def with_env_tz(new_tz = 'US/Eastern')
+#       old_tz, ENV['TZ'] = ENV['TZ'], new_tz
+#       yield
+#     ensure
+#       old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
+#     end
+# end
+#
+# class NumericExtDateTest < ActiveSupport::TestCase
+#   def setup
+#     @today = Date.today
+#   end
+#
+#   def test_date_plus_duration
+#     assert_equal @today + 1, @today + 1.day
+#     assert_equal @today >> 1, @today + 1.month
+#     assert_equal @today.to_time.since(1), @today + 1.second
+#     assert_equal @today.to_time.since(60), @today + 1.minute
+#     assert_equal @today.to_time.since(60*60), @today + 1.hour
+#   end
+#
+#   def test_chaining_duration_operations
+#     assert_equal @today.advance(:days => 2).advance(:months => -3), @today + 2.days - 3.months
+#     assert_equal @today.advance(:days => 1).advance(:months => 2), @today + 1.day + 2.months
+#   end
+#
+#   def test_add_one_year_to_leap_day
+#     assert_equal Date.new(2005,2,28), Date.new(2004,2,29) + 1.year
+#   end
+# end
+#
+# class NumericExtSizeTest < ActiveSupport::TestCase
+#   def test_unit_in_terms_of_another
+#     relationships = {
+#         1024.bytes     =>   1.kilobyte,
+#         1024.kilobytes =>   1.megabyte,
+#       3584.0.kilobytes => 3.5.megabytes,
+#       3584.0.megabytes => 3.5.gigabytes,
+#       1.kilobyte ** 4  =>   1.terabyte,
+#       1024.kilobytes + 2.megabytes =>   3.megabytes,
+#                    2.gigabytes / 4 => 512.megabytes,
+#       256.megabytes * 20 + 5.gigabytes => 10.gigabytes,
+#       1.kilobyte ** 5 => 1.petabyte,
+#       1.kilobyte ** 6 => 1.exabyte
+#     }
+#
+#     relationships.each do |left, right|
+#       assert_equal right, left
+#     end
+#   end
+#
+#   def test_units_as_bytes_independently
+#     assert_equal 3145728, 3.megabytes
+#     assert_equal 3145728, 3.megabyte
+#     assert_equal 3072, 3.kilobytes
+#     assert_equal 3072, 3.kilobyte
+#     assert_equal 3221225472, 3.gigabytes
+#     assert_equal 3221225472, 3.gigabyte
+#     assert_equal 3298534883328, 3.terabytes
+#     assert_equal 3298534883328, 3.terabyte
+#     assert_equal 3377699720527872, 3.petabytes
+#     assert_equal 3377699720527872, 3.petabyte
+#     assert_equal 3458764513820540928, 3.exabytes
+#     assert_equal 3458764513820540928, 3.exabyte
+#   end
+# end
+#
+# class NumericExtFormattingTest < ActiveSupport::TestCase
+#   def kilobytes(number)
+#     number * 1024
+#   end
+#
+#   def megabytes(number)
+#     kilobytes(number) * 1024
+#   end
+#
+#   def gigabytes(number)
+#     megabytes(number) * 1024
+#   end
+#
+#   def terabytes(number)
+#     gigabytes(number) * 1024
+#   end
+#
+#   def test_to_s__phone
+#     assert_equal("555-1234", 5551234.to_s(:phone))
+#     assert_equal("800-555-1212", 8005551212.to_s(:phone))
+#     assert_equal("(800) 555-1212", 8005551212.to_s(:phone, :area_code => true))
+#     assert_equal("800 555 1212", 8005551212.to_s(:phone, :delimiter => " "))
+#     assert_equal("(800) 555-1212 x 123", 8005551212.to_s(:phone, :area_code => true, :extension => 123))
+#     assert_equal("800-555-1212", 8005551212.to_s(:phone, :extension => "  "))
+#     assert_equal("555.1212", 5551212.to_s(:phone, :delimiter => '.'))
+#     assert_equal("+1-800-555-1212", 8005551212.to_s(:phone, :country_code => 1))
+#     assert_equal("+18005551212", 8005551212.to_s(:phone, :country_code => 1, :delimiter => ''))
+#     assert_equal("22-555-1212", 225551212.to_s(:phone))
+#     assert_equal("+45-22-555-1212", 225551212.to_s(:phone, :country_code => 45))
+#   end
+#
+#   def test_to_s__currency
+#     assert_equal("$1,234,567,890.50", 1234567890.50.to_s(:currency))
+#     assert_equal("$1,234,567,890.51", 1234567890.506.to_s(:currency))
+#     assert_equal("-$1,234,567,890.50", -1234567890.50.to_s(:currency))
+#     assert_equal("-$ 1,234,567,890.50", -1234567890.50.to_s(:currency, :format => "%u %n"))
+#     assert_equal("($1,234,567,890.50)", -1234567890.50.to_s(:currency, :negative_format => "(%u%n)"))
+#     assert_equal("$1,234,567,892", 1234567891.50.to_s(:currency, :precision => 0))
+#     assert_equal("$1,234,567,890.5", 1234567890.50.to_s(:currency, :precision => 1))
+#     assert_equal("&pound;1234567890,50", 1234567890.50.to_s(:currency, :unit => "&pound;", :separator => ",", :delimiter => ""))
+#   end
+#
+#
+#   def test_to_s__rounded
+#     assert_equal("-111.235", -111.2346.to_s(:rounded))
+#     assert_equal("111.235", 111.2346.to_s(:rounded))
+#     assert_equal("31.83", 31.825.to_s(:rounded, :precision => 2))
+#     assert_equal("111.23", 111.2346.to_s(:rounded, :precision => 2))
+#     assert_equal("111.00", 111.to_s(:rounded, :precision => 2))
+#     assert_equal("3268", (32.6751 * 100.00).to_s(:rounded, :precision => 0))
+#     assert_equal("112", 111.50.to_s(:rounded, :precision => 0))
+#     assert_equal("1234567892", 1234567891.50.to_s(:rounded, :precision => 0))
+#     assert_equal("0", 0.to_s(:rounded, :precision => 0))
+#     assert_equal("0.00100", 0.001.to_s(:rounded, :precision => 5))
+#     assert_equal("0.001", 0.00111.to_s(:rounded, :precision => 3))
+#     assert_equal("10.00", 9.995.to_s(:rounded, :precision => 2))
+#     assert_equal("11.00", 10.995.to_s(:rounded, :precision => 2))
+#     assert_equal("0.00", -0.001.to_s(:rounded, :precision => 2))
+#   end
+#
+#   def test_to_s__percentage
+#     assert_equal("100.000%", 100.to_s(:percentage))
+#     assert_equal("100%", 100.to_s(:percentage, :precision => 0))
+#     assert_equal("302.06%", 302.0574.to_s(:percentage, :precision => 2))
+#     assert_equal("123.4%", 123.400.to_s(:percentage, :precision => 3, :strip_insignificant_zeros => true))
+#     assert_equal("1.000,000%", 1000.to_s(:percentage, :delimiter => '.', :separator => ','))
+#     assert_equal("1000.000  %", 1000.to_s(:percentage, :format => "%n  %"))
+#   end
+#
+#   def test_to_s__delimited
+#     assert_equal("12,345,678", 12345678.to_s(:delimited))
+#     assert_equal("0", 0.to_s(:delimited))
+#     assert_equal("123", 123.to_s(:delimited))
+#     assert_equal("123,456", 123456.to_s(:delimited))
+#     assert_equal("123,456.78", 123456.78.to_s(:delimited))
+#     assert_equal("123,456.789", 123456.789.to_s(:delimited))
+#     assert_equal("123,456.78901", 123456.78901.to_s(:delimited))
+#     assert_equal("123,456,789.78901", 123456789.78901.to_s(:delimited))
+#     assert_equal("0.78901", 0.78901.to_s(:delimited))
+#   end
+#
+#   def test_to_s__delimited__with_options_hash
+#     assert_equal '12 345 678', 12345678.to_s(:delimited, :delimiter => ' ')
+#     assert_equal '12,345,678-05', 12345678.05.to_s(:delimited, :separator => '-')
+#     assert_equal '12.345.678,05', 12345678.05.to_s(:delimited, :separator => ',', :delimiter => '.')
+#     assert_equal '12.345.678,05', 12345678.05.to_s(:delimited, :delimiter => '.', :separator => ',')
+#   end
+#
+#
+#   def test_to_s__rounded_with_custom_delimiter_and_separator
+#     assert_equal '31,83',       31.825.to_s(:rounded, :precision => 2, :separator => ',')
+#     assert_equal '1.231,83',    1231.825.to_s(:rounded, :precision => 2, :separator => ',', :delimiter => '.')
+#   end
+#
+#   def test_to_s__rounded__with_significant_digits
+#     assert_equal "124000", 123987.to_s(:rounded, :precision => 3, :significant => true)
+#     assert_equal "120000000", 123987876.to_s(:rounded, :precision => 2, :significant => true )
+#     assert_equal "9775", 9775.to_s(:rounded, :precision => 4, :significant => true )
+#     assert_equal "5.4", 5.3923.to_s(:rounded, :precision => 2, :significant => true )
+#     assert_equal "5", 5.3923.to_s(:rounded, :precision => 1, :significant => true )
+#     assert_equal "1", 1.232.to_s(:rounded, :precision => 1, :significant => true )
+#     assert_equal "7", 7.to_s(:rounded, :precision => 1, :significant => true )
+#     assert_equal "1", 1.to_s(:rounded, :precision => 1, :significant => true )
+#     assert_equal "53", 52.7923.to_s(:rounded, :precision => 2, :significant => true )
+#     assert_equal "9775.00", 9775.to_s(:rounded, :precision => 6, :significant => true )
+#     assert_equal "5.392900", 5.3929.to_s(:rounded, :precision => 7, :significant => true )
+#     assert_equal "0.0", 0.to_s(:rounded, :precision => 2, :significant => true )
+#     assert_equal "0", 0.to_s(:rounded, :precision => 1, :significant => true )
+#     assert_equal "0.0001", 0.0001.to_s(:rounded, :precision => 1, :significant => true )
+#     assert_equal "0.000100", 0.0001.to_s(:rounded, :precision => 3, :significant => true )
+#     assert_equal "0.0001", 0.0001111.to_s(:rounded, :precision => 1, :significant => true )
+#     assert_equal "10.0", 9.995.to_s(:rounded, :precision => 3, :significant => true)
+#     assert_equal "9.99", 9.994.to_s(:rounded, :precision => 3, :significant => true)
+#     assert_equal "11.0", 10.995.to_s(:rounded, :precision => 3, :significant => true)
+#   end
+#
+#   def test_to_s__rounded__with_strip_insignificant_zeros
+#     assert_equal "9775.43", 9775.43.to_s(:rounded, :precision => 4, :strip_insignificant_zeros => true )
+#     assert_equal "9775.2", 9775.2.to_s(:rounded, :precision => 6, :significant => true, :strip_insignificant_zeros => true )
+#     assert_equal "0", 0.to_s(:rounded, :precision => 6, :significant => true, :strip_insignificant_zeros => true )
+#   end
+#
+#   def test_to_s__rounded__with_significant_true_and_zero_precision
+#     # Zero precision with significant is a mistake (would always return zero),
+#     # so we treat it as if significant was false (increases backwards compatibility for number_to_human_size)
+#     assert_equal "124", 123.987.to_s(:rounded, :precision => 0, :significant => true)
+#     assert_equal "12", 12.to_s(:rounded, :precision => 0, :significant => true )
+#   end
+#
+#   def test_to_s__human_size
+#     assert_equal '0 Bytes',   0.to_s(:human_size)
+#     assert_equal '1 Byte',    1.to_s(:human_size)
+#     assert_equal '3 Bytes',   3.14159265.to_s(:human_size)
+#     assert_equal '123 Bytes', 123.0.to_s(:human_size)
+#     assert_equal '123 Bytes', 123.to_s(:human_size)
+#     assert_equal '1.21 KB',   1234.to_s(:human_size)
+#     assert_equal '12.1 KB',   12345.to_s(:human_size)
+#     assert_equal '1.18 MB',   1234567.to_s(:human_size)
+#     assert_equal '1.15 GB',   1234567890.to_s(:human_size)
+#     assert_equal '1.12 TB',   1234567890123.to_s(:human_size)
+#     assert_equal '1030 TB',   terabytes(1026).to_s(:human_size)
+#     assert_equal '444 KB',    kilobytes(444).to_s(:human_size)
+#     assert_equal '1020 MB',   megabytes(1023).to_s(:human_size)
+#     assert_equal '3 TB',      terabytes(3).to_s(:human_size)
+#     assert_equal '1.2 MB',    1234567.to_s(:human_size, :precision => 2)
+#     assert_equal '3 Bytes',   3.14159265.to_s(:human_size, :precision => 4)
+#     assert_equal '1 KB',      kilobytes(1.0123).to_s(:human_size, :precision => 2)
+#     assert_equal '1.01 KB',   kilobytes(1.0100).to_s(:human_size, :precision => 4)
+#     assert_equal '10 KB',     kilobytes(10.000).to_s(:human_size, :precision => 4)
+#     assert_equal '1 Byte',    1.1.to_s(:human_size)
+#     assert_equal '10 Bytes',  10.to_s(:human_size)
+#   end
+#
+#   def test_to_s__human_size_with_si_prefix
+#     assert_equal '3 Bytes',    3.14159265.to_s(:human_size, :prefix => :si)
+#     assert_equal '123 Bytes',  123.0.to_s(:human_size, :prefix => :si)
+#     assert_equal '123 Bytes',  123.to_s(:human_size, :prefix => :si)
+#     assert_equal '1.23 KB',    1234.to_s(:human_size, :prefix => :si)
+#     assert_equal '12.3 KB',    12345.to_s(:human_size, :prefix => :si)
+#     assert_equal '1.23 MB',    1234567.to_s(:human_size, :prefix => :si)
+#     assert_equal '1.23 GB',    1234567890.to_s(:human_size, :prefix => :si)
+#     assert_equal '1.23 TB',    1234567890123.to_s(:human_size, :prefix => :si)
+#   end
+#
+#   def test_to_s__human_size_with_options_hash
+#     assert_equal '1.2 MB',   1234567.to_s(:human_size, :precision => 2)
+#     assert_equal '3 Bytes',  3.14159265.to_s(:human_size, :precision => 4)
+#     assert_equal '1 KB',     kilobytes(1.0123).to_s(:human_size, :precision => 2)
+#     assert_equal '1.01 KB',  kilobytes(1.0100).to_s(:human_size, :precision => 4)
+#     assert_equal '10 KB',    kilobytes(10.000).to_s(:human_size, :precision => 4)
+#     assert_equal '1 TB',     1234567890123.to_s(:human_size, :precision => 1)
+#     assert_equal '500 MB',   524288000.to_s(:human_size, :precision=>3)
+#     assert_equal '10 MB',    9961472.to_s(:human_size, :precision=>0)
+#     assert_equal '40 KB',    41010.to_s(:human_size, :precision => 1)
+#     assert_equal '40 KB',    41100.to_s(:human_size, :precision => 2)
+#     assert_equal '1.0 KB',   kilobytes(1.0123).to_s(:human_size, :precision => 2, :strip_insignificant_zeros => false)
+#     assert_equal '1.012 KB', kilobytes(1.0123).to_s(:human_size, :precision => 3, :significant => false)
+#     assert_equal '1 KB',     kilobytes(1.0123).to_s(:human_size, :precision => 0, :significant => true) #ignores significant it precision is 0
+#   end
+#
+#   def test_to_s__human_size_with_custom_delimiter_and_separator
+#     assert_equal '1,01 KB',     kilobytes(1.0123).to_s(:human_size, :precision => 3, :separator => ',')
+#     assert_equal '1,01 KB',     kilobytes(1.0100).to_s(:human_size, :precision => 4, :separator => ',')
+#     assert_equal '1.000,1 TB',  terabytes(1000.1).to_s(:human_size, :precision => 5, :delimiter => '.', :separator => ',')
+#   end
+#
+#   def test_number_to_human
+#     assert_equal '-123', -123.to_s(:human)
+#     assert_equal '-0.5', -0.5.to_s(:human)
+#     assert_equal '0',   0.to_s(:human)
+#     assert_equal '0.5', 0.5.to_s(:human)
+#     assert_equal '123', 123.to_s(:human)
+#     assert_equal '1.23 Thousand', 1234.to_s(:human)
+#     assert_equal '12.3 Thousand', 12345.to_s(:human)
+#     assert_equal '1.23 Million', 1234567.to_s(:human)
+#     assert_equal '1.23 Billion', 1234567890.to_s(:human)
+#     assert_equal '1.23 Trillion', 1234567890123.to_s(:human)
+#     assert_equal '1.23 Quadrillion', 1234567890123456.to_s(:human)
+#     assert_equal '1230 Quadrillion', 1234567890123456789.to_s(:human)
+#     assert_equal '490 Thousand', 489939.to_s(:human, :precision => 2)
+#     assert_equal '489.9 Thousand', 489939.to_s(:human, :precision => 4)
+#     assert_equal '489 Thousand', 489000.to_s(:human, :precision => 4)
+#     assert_equal '489.0 Thousand', 489000.to_s(:human, :precision => 4, :strip_insignificant_zeros => false)
+#     assert_equal '1.2346 Million', 1234567.to_s(:human, :precision => 4, :significant => false)
+#     assert_equal '1,2 Million', 1234567.to_s(:human, :precision => 1, :significant => false, :separator => ',')
+#     assert_equal '1 Million', 1234567.to_s(:human, :precision => 0, :significant => true, :separator => ',') #significant forced to false
+#   end
+#
+#   def test_number_to_human_with_custom_units
+#     #Only integers
+#     volume = {:unit => "ml", :thousand => "lt", :million => "m3"}
+#     assert_equal '123 lt', 123456.to_s(:human, :units => volume)
+#     assert_equal '12 ml', 12.to_s(:human, :units => volume)
+#     assert_equal '1.23 m3', 1234567.to_s(:human, :units => volume)
+#
+#     #Including fractionals
+#     distance = {:mili => "mm", :centi => "cm", :deci => "dm", :unit => "m", :ten => "dam", :hundred => "hm", :thousand => "km"}
+#     assert_equal '1.23 mm', 0.00123.to_s(:human, :units => distance)
+#     assert_equal '1.23 cm', 0.0123.to_s(:human, :units => distance)
+#     assert_equal '1.23 dm', 0.123.to_s(:human, :units => distance)
+#     assert_equal '1.23 m',  1.23.to_s(:human, :units => distance)
+#     assert_equal '1.23 dam', 12.3.to_s(:human, :units => distance)
+#     assert_equal '1.23 hm', 123.to_s(:human, :units => distance)
+#     assert_equal '1.23 km', 1230.to_s(:human, :units => distance)
+#     assert_equal '1.23 km', 1230.to_s(:human, :units => distance)
+#     assert_equal '1.23 km', 1230.to_s(:human, :units => distance)
+#     assert_equal '12.3 km', 12300.to_s(:human, :units => distance)
+#
+#     #The quantifiers don't need to be a continuous sequence
+#     gangster = {:hundred => "hundred bucks", :million => "thousand quids"}
+#     assert_equal '1 hundred bucks', 100.to_s(:human, :units => gangster)
+#     assert_equal '25 hundred bucks', 2500.to_s(:human, :units => gangster)
+#     assert_equal '25 thousand quids', 25000000.to_s(:human, :units => gangster)
+#     assert_equal '12300 thousand quids', 12345000000.to_s(:human, :units => gangster)
+#
+#     #Spaces are stripped from the resulting string
+#     assert_equal '4', 4.to_s(:human, :units => {:unit => "", :ten => 'tens '})
+#     assert_equal '4.5  tens', 45.to_s(:human, :units => {:unit => "", :ten => ' tens   '})
+#   end
+#
+#   def test_number_to_human_with_custom_format
+#     assert_equal '123 times Thousand', 123456.to_s(:human, :format => "%n times %u")
+#     volume = {:unit => "ml", :thousand => "lt", :million => "m3"}
+#     assert_equal '123.lt', 123456.to_s(:human, :units => volume, :format => "%n.%u")
+#   end
+#
+#   def test_to_s__injected_on_proper_types
+#     assert_equal Fixnum, 1230.class
+#     assert_equal '1.23 Thousand', 1230.to_s(:human)
+#
+#     assert_equal Float, Float(1230).class
+#     assert_equal '1.23 Thousand', Float(1230).to_s(:human)
+#
+#     assert_equal Bignum, (100**10).class
+#     assert_equal '100000 Quadrillion', (100**10).to_s(:human)
+#
+#     assert_equal BigDecimal, BigDecimal("1000010").class
+#     assert_equal '1 Million', BigDecimal("1000010").to_s(:human)
+#   end
+# end
+#
+# class NumericExtBehaviorTest < ActiveSupport::TestCase
+#   def setup
+#     @inf = BigDecimal.new('Infinity')
+#   end
+#
+#   def test_compare_infinity_with_date
+#     assert_equal(-1, -Float::INFINITY <=> Date.today)
+#     assert_equal(1, Float::INFINITY <=> Date.today)
+#     assert_equal(-1, -@inf <=> Date.today)
+#     assert_equal(1, @inf <=> Date.today)
+#   end
+#
+#   def test_compare_infinty_with_infinty
+#     assert_equal(-1, -Float::INFINITY <=> Float::INFINITY)
+#     assert_equal(1, Float::INFINITY <=> -Float::INFINITY)
+#     assert_equal(0, Float::INFINITY <=> Float::INFINITY)
+#     assert_equal(0, -Float::INFINITY <=> -Float::INFINITY)
+#
+#     assert_equal(-1, -Float::INFINITY <=> BigDecimal::INFINITY)
+#     assert_equal(1, Float::INFINITY <=> -BigDecimal::INFINITY)
+#     assert_equal(0, Float::INFINITY <=> BigDecimal::INFINITY)
+#     assert_equal(0, -Float::INFINITY <=> -BigDecimal::INFINITY)
+#
+#     assert_equal(-1, -BigDecimal::INFINITY <=> Float::INFINITY)
+#     assert_equal(1, BigDecimal::INFINITY <=> -Float::INFINITY)
+#     assert_equal(0, BigDecimal::INFINITY <=> Float::INFINITY)
+#     assert_equal(0, -BigDecimal::INFINITY <=> -Float::INFINITY)
+#   end
+#
+#   def test_compare_infinity_with_time
+#     assert_equal(-1, -Float::INFINITY <=> Time.now)
+#     assert_equal(1, Float::INFINITY <=> Time.now)
+#     assert_equal(-1, -@inf <=> Time.now)
+#     assert_equal(1, @inf <=> Time.now)
+#   end
+#
+#   def test_compare_infinity_with_datetime
+#     assert_equal(-1, -Float::INFINITY <=> DateTime.now)
+#     assert_equal(1, Float::INFINITY <=> DateTime.now)
+#     assert_equal(-1, -@inf <=> DateTime.now)
+#     assert_equal(1, @inf <=> DateTime.now)
+#   end
+#
+#   def test_compare_infinity_with_twz
+#     time_zone = ActiveSupport::TimeZone['Eastern Time (US & Canada)']
+#     twz = ActiveSupport::TimeWithZone.new(Time.now, time_zone)
+#
+#     assert_equal(-1, -Float::INFINITY <=> twz)
+#     assert_equal(1, Float::INFINITY <=> twz)
+#     assert_equal(-1, -@inf <=> twz)
+#     assert_equal(1, @inf <=> twz)
+#   end
+# end

data/spec/core_ext/string_spec.rb

@@ -2,7 +2,10 @@ require 'spec_helper'
 require 'active_support/core_ext/string'
 require 'inflector_test_cases'
 
+module InflectorTestCases
 describe 'String' do
+  # include InflectorTestCases
+
   describe "#demodulize" do
     it "removes any preceding module name from the string" do
       "Foo::Bar".demodulize.should == "Bar"
@@ -52,4 +55,17 @@ describe 'String' do
       end
     end
   end
+
+  describe '#camelize' do
+    it 'camelizes' do
+      CamelToUnderscore.each do |camel, underscore|
+        underscore.camelize.should == camel
+      end
+    end
+
+    it 'accepts :lower to keep the first letter lowercase' do
+      'Capital'.camelize(:lower).should == 'capital'
+    end
+  end
+end
 end

data/spec/inflector_test_cases.rb

@@ -1,13 +1,315 @@
-CamelToUnderscore = {
-  "Product"               => "product",
-  "SpecialGuest"          => "special_guest",
-  "ApplicationController" => "application_controller",
-  "Area51Controller"      => "area51_controller"
-}
-
-UnderscoreToLowerCamel = {
-  "product"                => "product",
-  "special_guest"          => "specialGuest",
-  "application_controller" => "applicationController",
-  "area51_controller"      => "area51Controller"
-}
+# encoding: utf-8
+
+module InflectorTestCases
+  SingularToPlural = {
+    "search"      => "searches",
+    "switch"      => "switches",
+    "fix"         => "fixes",
+    "box"         => "boxes",
+    "process"     => "processes",
+    "address"     => "addresses",
+    "case"        => "cases",
+    "stack"       => "stacks",
+    "wish"        => "wishes",
+    "fish"        => "fish",
+    "jeans"       => "jeans",
+    "funky jeans" => "funky jeans",
+    "my money"    => "my money",
+
+    "category"    => "categories",
+    "query"       => "queries",
+    "ability"     => "abilities",
+    "agency"      => "agencies",
+    "movie"       => "movies",
+
+    "archive"     => "archives",
+
+    "index"       => "indices",
+
+    "wife"        => "wives",
+    "safe"        => "saves",
+    "half"        => "halves",
+
+    "move"        => "moves",
+
+    "salesperson" => "salespeople",
+    "person"      => "people",
+
+    "spokesman"   => "spokesmen",
+    "man"         => "men",
+    "woman"       => "women",
+
+    "basis"       => "bases",
+    "diagnosis"   => "diagnoses",
+    "diagnosis_a" => "diagnosis_as",
+
+    "datum"       => "data",
+    "medium"      => "media",
+    "stadium"     => "stadia",
+    "analysis"    => "analyses",
+    "my_analysis" => "my_analyses",
+
+    "node_child"  => "node_children",
+    "child"       => "children",
+
+    "experience"  => "experiences",
+    "day"         => "days",
+
+    "comment"     => "comments",
+    "foobar"      => "foobars",
+    "newsletter"  => "newsletters",
+
+    "old_news"    => "old_news",
+    "news"        => "news",
+
+    "series"      => "series",
+    "species"     => "species",
+
+    "quiz"        => "quizzes",
+
+    "perspective" => "perspectives",
+
+    "ox"          => "oxen",
+    "photo"       => "photos",
+    "buffalo"     => "buffaloes",
+    "tomato"      => "tomatoes",
+    "dwarf"       => "dwarves",
+    "elf"         => "elves",
+    "information" => "information",
+    "equipment"   => "equipment",
+    "bus"         => "buses",
+    "status"      => "statuses",
+    "status_code" => "status_codes",
+    "mouse"       => "mice",
+
+    "louse"       => "lice",
+    "house"       => "houses",
+    "octopus"     => "octopi",
+    "virus"       => "viri",
+    "alias"       => "aliases",
+    "portfolio"   => "portfolios",
+
+    "vertex"      => "vertices",
+    "matrix"      => "matrices",
+    "matrix_fu"   => "matrix_fus",
+
+    "axis"        => "axes",
+    "taxi"        => "taxis", # prevents regression
+    "testis"      => "testes",
+    "crisis"      => "crises",
+
+    "rice"        => "rice",
+    "shoe"        => "shoes",
+
+    "horse"       => "horses",
+    "prize"       => "prizes",
+    "edge"        => "edges",
+
+    "cow"         => "kine",
+    "database"    => "databases",
+
+    # regression tests against improper inflection regexes
+    "|ice"        => "|ices",
+    "|ouse"       => "|ouses",
+    "slice"       => "slices",
+    "police"      => "police"
+  }
+
+  CamelToUnderscore = {
+    "Product"               => "product",
+    "SpecialGuest"          => "special_guest",
+    "ApplicationController" => "application_controller",
+    "Area51Controller"      => "area51_controller"
+  }
+
+  UnderscoreToLowerCamel = {
+    "product"                => "product",
+    "special_guest"          => "specialGuest",
+    "application_controller" => "applicationController",
+    "area51_controller"      => "area51Controller"
+  }
+
+  SymbolToLowerCamel = {
+    :product                => 'product',
+    :special_guest          => 'specialGuest',
+    :application_controller => 'applicationController',
+    :area51_controller      => 'area51Controller'
+  }
+
+  CamelToUnderscoreWithoutReverse = {
+    "HTMLTidy"              => "html_tidy",
+    "HTMLTidyGenerator"     => "html_tidy_generator",
+    "FreeBSD"               => "free_bsd",
+    "HTML"                  => "html",
+  }
+
+  CamelWithModuleToUnderscoreWithSlash = {
+    "Admin::Product" => "admin/product",
+    "Users::Commission::Department" => "users/commission/department",
+    "UsersSection::CommissionDepartment" => "users_section/commission_department",
+  }
+
+  ClassNameToForeignKeyWithUnderscore = {
+    "Person" => "person_id",
+    "MyApplication::Billing::Account" => "account_id"
+  }
+
+  ClassNameToForeignKeyWithoutUnderscore = {
+    "Person" => "personid",
+    "MyApplication::Billing::Account" => "accountid"
+  }
+
+  ClassNameToTableName = {
+    "PrimarySpokesman" => "primary_spokesmen",
+    "NodeChild"        => "node_children"
+  }
+
+  StringToParameterized = {
+    "Donald E. Knuth"                     => "donald-e-knuth",
+    "Random text with *(bad)* characters" => "random-text-with-bad-characters",
+    "Allow_Under_Scores"                  => "allow_under_scores",
+    "Trailing bad characters!@#"          => "trailing-bad-characters",
+    "!@#Leading bad characters"           => "leading-bad-characters",
+    "Squeeze   separators"                => "squeeze-separators",
+    "Test with + sign"                    => "test-with-sign",
+    "Test with malformed utf8 \251"       => "test-with-malformed-utf8"
+  }
+
+  StringToParameterizeWithNoSeparator = {
+    "Donald E. Knuth"                     => "donaldeknuth",
+    "With-some-dashes"                    => "with-some-dashes",
+    "Random text with *(bad)* characters" => "randomtextwithbadcharacters",
+    "Trailing bad characters!@#"          => "trailingbadcharacters",
+    "!@#Leading bad characters"           => "leadingbadcharacters",
+    "Squeeze   separators"                => "squeezeseparators",
+    "Test with + sign"                    => "testwithsign",
+    "Test with malformed utf8 \251"       => "testwithmalformedutf8"
+  }
+
+  StringToParameterizeWithUnderscore = {
+    "Donald E. Knuth"                     => "donald_e_knuth",
+    "Random text with *(bad)* characters" => "random_text_with_bad_characters",
+    "With-some-dashes"                    => "with-some-dashes",
+    "Retain_underscore"                   => "retain_underscore",
+    "Trailing bad characters!@#"          => "trailing_bad_characters",
+    "!@#Leading bad characters"           => "leading_bad_characters",
+    "Squeeze   separators"                => "squeeze_separators",
+    "Test with + sign"                    => "test_with_sign",
+    "Test with malformed utf8 \251"       => "test_with_malformed_utf8"
+  }
+
+  StringToParameterizedAndNormalized = {
+    "Malmö"                               => "malmo",
+    "Garçons"                             => "garcons",
+    "Ops\331"                             => "opsu",
+    "Ærøskøbing"                          => "aeroskobing",
+    "Aßlar"                               => "asslar",
+    "Japanese: 日本語"                    => "japanese"
+  }
+
+  UnderscoreToHuman = {
+    "employee_salary" => "Employee salary",
+    "employee_id"     => "Employee",
+    "underground"     => "Underground"
+  }
+
+  MixtureToTitleCase = {
+    'active_record'         => 'Active Record',
+    'ActiveRecord'          => 'Active Record',
+    'action web service'    => 'Action Web Service',
+    'Action Web Service'    => 'Action Web Service',
+    'Action web service'    => 'Action Web Service',
+    'actionwebservice'      => 'Actionwebservice',
+    'Actionwebservice'      => 'Actionwebservice',
+    "david's code"          => "David's Code",
+    "David's code"          => "David's Code",
+    "david's Code"          => "David's Code",
+    "sgt. pepper's"         => "Sgt. Pepper's",
+    "i've just seen a face" => "I've Just Seen A Face",
+    "maybe you'll be there" => "Maybe You'll Be There",
+    "¿por qué?"             => '¿Por Qué?',
+    "Fred’s"                => "Fred’s",
+    "Fred`s"                => "Fred`s"
+  }
+
+  OrdinalNumbers = {
+    "-1" => "-1st",
+    "-2" => "-2nd",
+    "-3" => "-3rd",
+    "-4" => "-4th",
+    "-5" => "-5th",
+    "-6" => "-6th",
+    "-7" => "-7th",
+    "-8" => "-8th",
+    "-9" => "-9th",
+    "-10" => "-10th",
+    "-11" => "-11th",
+    "-12" => "-12th",
+    "-13" => "-13th",
+    "-14" => "-14th",
+    "-20" => "-20th",
+    "-21" => "-21st",
+    "-22" => "-22nd",
+    "-23" => "-23rd",
+    "-24" => "-24th",
+    "-100" => "-100th",
+    "-101" => "-101st",
+    "-102" => "-102nd",
+    "-103" => "-103rd",
+    "-104" => "-104th",
+    "-110" => "-110th",
+    "-111" => "-111th",
+    "-112" => "-112th",
+    "-113" => "-113th",
+    "-1000" => "-1000th",
+    "-1001" => "-1001st",
+    "0" => "0th",
+    "1" => "1st",
+    "2" => "2nd",
+    "3" => "3rd",
+    "4" => "4th",
+    "5" => "5th",
+    "6" => "6th",
+    "7" => "7th",
+    "8" => "8th",
+    "9" => "9th",
+    "10" => "10th",
+    "11" => "11th",
+    "12" => "12th",
+    "13" => "13th",
+    "14" => "14th",
+    "20" => "20th",
+    "21" => "21st",
+    "22" => "22nd",
+    "23" => "23rd",
+    "24" => "24th",
+    "100" => "100th",
+    "101" => "101st",
+    "102" => "102nd",
+    "103" => "103rd",
+    "104" => "104th",
+    "110" => "110th",
+    "111" => "111th",
+    "112" => "112th",
+    "113" => "113th",
+    "1000" => "1000th",
+    "1001" => "1001st"
+  }
+
+  UnderscoresToDashes = {
+    "street"                => "street",
+    "street_address"        => "street-address",
+    "person_street_address" => "person-street-address"
+  }
+
+  Irregularities = {
+    'person' => 'people',
+    'man'    => 'men',
+    'child'  => 'children',
+    'sex'    => 'sexes',
+    'move'   => 'moves',
+    'cow'    => 'kine',
+    'zombie' => 'zombies',
+    'genus'  => 'genera'
+  }
+end

data/spec/spec_helper.rb

@@ -1 +1,13 @@
-require 'opal-spec'
+require 'opal-rspec'
+require 'opal-activesupport'
+
+module TestUnitHelpers
+  def assert_equal actual, expected
+    actual.should == expected
+  end
+end
+
+RSpec.configure do |config|
+  config.include TestUnitHelpers
+end
+

metadata

@@ -1,43 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: opal-activesupport
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Elia Schito
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-04 00:00:00.000000000 Z
+date: 2013-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opal
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 0.4.2
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 0.4.2
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: opal-spec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 0.2.17
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 0.2.17
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: opal-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: The port of the glorious ActiveSupport for Opal
 email:
 - elia@schito.me
@@ -56,10 +70,17 @@ files:
 - opal-activesupport.gemspec
 - opal/active_support.rb
 - opal/active_support/core_ext.rb
+- opal/active_support/core_ext/integer.rb
+- opal/active_support/core_ext/integer/time.rb
+- opal/active_support/core_ext/numeric.rb
+- opal/active_support/core_ext/numeric/calculations.rb
+- opal/active_support/core_ext/numeric/time.rb
 - opal/active_support/core_ext/object.rb
 - opal/active_support/core_ext/object/blank.rb
 - opal/active_support/core_ext/string.rb
+- opal/active_support/time.rb
 - opal/opal-activesupport.rb
+- spec/core_ext/numeric_spec.rb
 - spec/core_ext/object/blank_spec.rb
 - spec/core_ext/string_spec.rb
 - spec/empty_bool.rb
@@ -89,11 +110,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.1.2
 signing_key: 
 specification_version: 4
 summary: The port of the glorious ActiveSupport for Opal
 test_files:
+- spec/core_ext/numeric_spec.rb
 - spec/core_ext/object/blank_spec.rb
 - spec/core_ext/string_spec.rb
 - spec/empty_bool.rb