ruby-units 1.3.1 → 1.3.2.a

data/CHANGELOG.txt

@@ -1,5 +1,13 @@
 Change Log for Ruby-units
 =========================
+2011-10-17	1.3.2	* deprecate some string helper functions
+					* tighten up some time helper functions so they don't make as many assumptions
+					* time helpers no longer attempt to convert strings to time/date objects
+011-10-09			* Farads are not a base unit
+					* CFM added to default units
+					* multi specs run against ruby-1.9.3
+					* internally change Unit#to to Unit#convert_to, which is the preferred form
+
 2011-04-23  1.3.0.a * Some internal restructuring
                     * Implement specs for core behaviors
                     * fixed several bugs found by specs

data/Gemfile

@@ -5,4 +5,8 @@ group :development do
   gem 'rcov', :platforms => :mri_18
   gem 'jeweler'
   gem 'rspec', '~>2.5'
+  gem 'autotest', :platforms => [:mri_18, :mri_19]
+  gem 'autotest-growl', :platforms => [:mri_18, :mri_19]
+  gem 'autotest-fsevent', :platforms => [:mri_18, :mri_19]
 end
+

data/README.md

@@ -73,7 +73,7 @@ Units can be converted to other units in a couple of ways.
     unit1 === unit2        # true if units and quantity are the same, even if 'equivalent' by <=>
     unit.to('ft')          # convert
     unit1 + unit2 >> "ft"  # converts result of math to 'ft'
-    (unit1 + unit2).to('ft') # converts result to 'ft'
+    (unit1 + unit2).convert_to('ft') # converts result to 'ft'
  
 Any object that defines a 'to_unit' method will be automatically coerced to a unit during calculations.
  
@@ -81,7 +81,7 @@ Any object that defines a 'to_unit' method will be automatically coerced to a un
 Units will display themselves nicely based on the preferred abbreviation for the units and prefixes.
 Since Unit implements a Unit#to_s, all that is needed in most cases is:
     
-    "#{Unit.new('1 mm')}"  #=> "1 mm"
+    "#{Unit('1 mm')}"  #=> "1 mm"
  
 The to_s also accepts some options.
 
@@ -101,7 +101,7 @@ Several helpers have also been defined.
 Note: If you include the 'Chronic' gem, you can specify times in natural
       language.
 
-      'min'.since('9/18/06 3:00pm')
+      Unit('min').since(DateTime.parse('9/18/06 3:00pm'))
       'min'.before('9/18/08 3:00pm')
       'days'.until('1/1/07')
       '5 min'.from(Time.now)

data/RakeFile

@@ -13,6 +13,27 @@ begin
     gem.email = ["kevin.olbrich+ruby_units@gmail.com"]
     gem.homepage = "https://github.com/olbrich/ruby-units"
     gem.files.exclude(".*")
+	gem.post_install_message = <<-EOS
+====================
+Deprecation Warning
+====================
+
+Several convenience methods that ruby-units added to the string class have
+been deprecated in this release.  These methods include String#to, String#from, String#ago, String#before and others.
+If your code relies on these functions, they can be added back by adding this line to your code.
+
+require 'ruby-units/string/extras'
+# note that these methods do not play well with Rails, which is one of the reasons they are being removed.
+
+The extra functions mostly work the same, but will no longer properly handle cases when they are called with strings..
+
+'min'.from("4-1-2011") # => Exception
+
+Pass in a Date, Time, or DateTime object to get the expected result.
+
+They will probably go away completely in an upcoming release, so it would be a good idea to refactor your code
+to avoid using them.  They will also throw deprecation warnings when they are used.
+EOS
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
@@ -33,7 +54,11 @@ begin
   require 'rspec/core/rake_task'
 
   desc "Run specs"
-  RSpec::Core::RakeTask.new
+  RSpec::Core::RakeTask.new do |spec|
+	puts
+	puts %x{rvm current}
+	puts
+  end
   
   desc  "Run all specs with rcov"
   RSpec::Core::RakeTask.new("spec:rcov") do |t|
@@ -57,10 +82,11 @@ task :multitest do
   rubies = %w{
       ruby-1.8.7@ruby-units
       ruby-1.8.7@ruby-units-with-chronic
-      ruby-1.9.2-head@ruby-units
-      ruby-1.9.2-head@ruby-units-with-chronic
-      rbx-head@ruby-units
-      jruby-head@ruby-units
+      ruby-1.9.2@ruby-units
+      ruby-1.9.2@ruby-units-with-chronic
+      ruby-1.9.3@ruby-units
+      rbx@ruby-units
+      jruby-1.6.4@ruby-units
       }
   exec "rvm #{rubies.join(',')} tests"
 end
@@ -70,10 +96,11 @@ task :multispec do
   rubies = %w{
       ruby-1.8.7@ruby-units
       ruby-1.8.7@ruby-units-with-chronic
-      ruby-1.9.2-head@ruby-units
-      ruby-1.9.2-head@ruby-units-with-chronic
-      rbx-head@ruby-units
-      jruby-head@ruby-units
+      ruby-1.9.2@ruby-units
+      ruby-1.9.2@ruby-units-with-chronic
+      ruby-1.9.3@ruby-units
+      rbx@ruby-units
+      jruby-1.6.4@ruby-units
       }
   exec "rvm #{rubies.join(',')} specs"
 end

data/VERSION

@@ -1 +1 @@
-1.3.1
+1.3.2.a

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/lib/ruby_units/array.rb

@@ -2,7 +2,7 @@
 # [1, 'mm'].unit => 1 mm
 class Array
   def to_unit(other = nil)
-    other ? Unit.new(self).to(other) : Unit.new(self)
+    other ? Unit.new(self).convert_to(other) : Unit.new(self)
   end
   alias :unit :to_unit
   alias :u :to_unit

data/lib/ruby_units/date.rb

@@ -8,8 +8,8 @@ class Date
   def +(unit)
     case unit
     when Unit
-      unit = unit.to('d').round if ['y', 'decade', 'century'].include? unit.units 
-      unit_date_add(unit.to('day').scalar)
+      unit = unit.convert_to('d').round if ['y', 'decade', 'century'].include? unit.units 
+      unit_date_add(unit.convert_to('day').scalar)
     else
       unit_date_add(unit)
     end
@@ -20,15 +20,15 @@ class Date
   def -(unit)
     case unit
     when Unit 
-      unit = unit.to('d').round if ['y', 'decade', 'century'].include? unit.units 
-      unit_date_sub(unit.to('day').scalar)
+      unit = unit.convert_to('d').round if ['y', 'decade', 'century'].include? unit.units 
+      unit_date_sub(unit.convert_to('day').scalar)
     else
       unit_date_sub(unit)
     end
   end
   
   def to_unit(other = nil)
-    other ? Unit.new(self).to(other) : Unit.new(self)
+    other ? Unit.new(self).convert_to(other) : Unit.new(self)
   end
   alias :unit :to_unit
   

data/lib/ruby_units/math.rb

@@ -32,42 +32,42 @@ module Math
     
   alias :unit_sin :sin
   def sin(n)
-   Unit === n ? unit_sin(n.to('radian').scalar) : unit_sin(n)
+   Unit === n ? unit_sin(n.convert_to('radian').scalar) : unit_sin(n)
   end
   module_function :unit_sin
   module_function :sin
 
   alias :unit_cos :cos
   def cos(n)
-    Unit === n ? unit_cos(n.to('radian').scalar) : unit_cos(n)
+    Unit === n ? unit_cos(n.convert_to('radian').scalar) : unit_cos(n)
   end
   module_function :unit_cos
   module_function :cos
     
   alias :unit_sinh :sinh
   def sinh(n)
-    Unit === n ? unit_sinh(n.to('radian').scalar) : unit_sinh(n)
+    Unit === n ? unit_sinh(n.convert_to('radian').scalar) : unit_sinh(n)
   end
   module_function :unit_sinh
   module_function :sinh
 
   alias :unit_cosh :cosh
   def cosh(n)
-    Unit === n ? unit_cosh(n.to('radian').scalar) : unit_cosh(n)
+    Unit === n ? unit_cosh(n.convert_to('radian').scalar) : unit_cosh(n)
   end
   module_function :unit_cosh
   module_function :cosh
 
   alias :unit_tan :tan
   def tan(n)
-   Unit === n ? unit_tan(n.to('radian').scalar) : unit_tan(n)
+   Unit === n ? unit_tan(n.convert_to('radian').scalar) : unit_tan(n)
   end
   module_function :tan
   module_function :unit_tan
 
   alias :unit_tanh :tanh
   def tanh(n)
-    Unit === n ? unit_tanh(n.to('radian').scalar) : unit_tanh(n)
+    Unit === n ? unit_tanh(n.convert_to('radian').scalar) : unit_tanh(n)
   end
   module_function :unit_tanh
   module_function :tanh

data/lib/ruby_units/string.rb

@@ -2,7 +2,7 @@ require 'time'
 # make a string into a unit
 class String
   def to_unit(other = nil)
-    other ? Unit.new(self).to(other) : Unit.new(self)
+    other ? Unit.new(self).convert_to(other) : Unit.new(self)
   end
   alias :unit :to_unit
   alias :u :to_unit
@@ -24,103 +24,111 @@ class String
   end
   
   #needed for compatibility with Rails, which defines a String.from method  
-  if self.public_instance_methods.include? 'from'
-    alias :old_from :from
-  end 
+  # if self.public_instance_methods.include? 'from'
+  #   alias :old_from :from
+  # end 
   
-  # "5 min".from("now")
-  def from(time_point = ::Time.now)
-    return old_from(time_point) if self.respond_to?(:old_from) && time_point.instance_of?(Integer)
-    self.unit.from(time_point)
-  end
-  
-  alias :after :from
-
-  def from_now
-    self.from('now')
-  end
-  
-  # "5 min".ago
-  def ago
-    self.unit.ago
-  end
-  
-  def before(time_point = ::Time.now)
-    self.unit.before(time_point)
-  end
-  
-  def before_now
-    self.before('now')
-  end
-  
-  def since(time_point = ::Time.now)
-    self.unit.since(time_point)
-  end
-  
-  def until(time_point = ::Time.now)
-    self.unit.until(time_point)
-  end
-  
-  def to(other)
-    self.unit.to(other)
-  end
-  
-  def time(options = {})
-    self.to_time(options) rescue self.to_datetime(options)
-  end
-  
-  def to_time(options = {})
-    begin
-      #raises exception when Chronic not defined or when it returns a nil (i.e., can't parse the input)
-      r = Chronic.parse(self,options)
-      raise(ArgumentError, 'Invalid Time String') unless r
-      return r
-    rescue
-      case
-      when self == "now"
-        Time.now
-      when Time.respond_to?(:parse)
-        Time.parse(self)
-      else
-        Time.local(*ParseDate.parsedate(self))
-      end
-    end
-  end
-  
-  def to_datetime(options = {})
-    begin
-      # raises an exception if Chronic.parse = nil or if Chronic not defined
-      r = Chronic.parse(self,options).send(:to_datetime)
-    rescue Exception  => e
-      r = case
-      when self.to_s == "now"
-        DateTime.now
-      else
-        DateTime.parse(self)
-      end
-    end
-    raise RuntimeError, "Invalid Time String (#{self.to_s})" if r == DateTime.new      
-    return r
-  end
-  
-  def to_date(options={})
-    begin
-      r = Chronic.parse(self,options).to_date
-    rescue
-      r = case
-      when self == "today" 
-        Date.today
-      when RUBY_VERSION < "1.9"
-        Date.civil(*ParseDate.parsedate(self)[0..5].compact)
-      else
-        Date.parse(self)
-      end
-    end
-    raise RuntimeError, 'Invalid Date String' if r == Date.new
-    return r
-  end
+  # # "5 min".from("now")
+  # def from(time_point = ::Time.now)
+  #   return old_from(time_point) if self.respond_to?(:old_from) && time_point.instance_of?(Integer)
+  #   self.unit.from(time_point)
+  # end
+  # 
+  # alias :after :from
 
-  def datetime(options = {})
-    self.to_datetime(options) rescue self.to_time(options)
+  # def from_now
+  #   self.from('now')
+  # end
+  # 
+  # # "5 min".ago
+  # def ago
+  #   self.unit.ago
+  # end
+  # 
+  # def before(time_point = ::Time.now)
+  #   self.unit.before(time_point)
+  # end
+  # 
+  # def before_now
+  #   self.before('now')
+  # end
+  # 
+  # def since(time_point = ::Time.now)
+  #   self.unit.since(time_point)
+  # end
+  # 
+  # def until(time_point = ::Time.now)
+  #   self.unit.until(time_point)
+  # end
+  # 
+  def convert_to(other)
+    self.unit.convert_to(other)
   end
+  # 
+  # unless String.instance_methods.include?(:to)
+  #   def to(other)
+  #     warn "string.to is deprecated, use string.convert_to if you must, but the best would be Unit('unit').convert_to('target unit')"
+  #     convert_to(other)
+  #   end
+  # end
+  # 
+  # def time(options = {})
+  #   self.to_time(options) rescue self.to_datetime(options)
+  # end
+  # 
+  # def to_time(options = {})
+  #   begin
+  #     #raises exception when Chronic not defined or when it returns a nil (i.e., can't parse the input)
+  #     r = Chronic.parse(self,options)
+  #     raise(ArgumentError, 'Invalid Time String') unless r
+  #     return r
+  #   rescue Exception  => e
+  #     puts e.inspect
+  #     case
+  #     when self == "now"
+  #       Time.now
+  #     when Time.respond_to?(:parse)
+  #       Time.parse(self)
+  #     else
+  #       Time.local(*ParseDate.parsedate(self))
+  #     end
+  #   end
+  # end
+  # 
+  # def to_datetime(options = {})
+  #   begin
+  #     # raises an exception if Chronic.parse = nil or if Chronic not defined
+  #     r = Chronic.parse(self,options).send(:to_datetime)
+  #   rescue NameError  => e
+  #     r = case
+  #     when self.to_s == "now"
+  #       DateTime.now
+  #     else
+  #       DateTime.parse(self)
+  #     end
+  #   end
+  #   raise RuntimeError, "Invalid Time String (#{self.to_s})" if r == DateTime.new      
+  #   return r
+  # end
+  # 
+  # def to_date(options={})
+  #   begin
+  #     r = Chronic.parse(self,options).to_date
+  #   rescue
+  #     r = case
+  #     when self == "today" 
+  #       Date.today
+  #     when RUBY_VERSION < "1.9"
+  #       Date.civil(*ParseDate.parsedate(self)[0..5].compact)
+  #     else
+  #       Date.parse(self)
+  #     end
+  #   end
+  #   raise RuntimeError, 'Invalid Date String' if r == Date.new
+  #   return r
+  # end
+  # 
+  # def datetime(options = {})
+  #   self.to_datetime(options) rescue self.to_time(options)
+  # end
 end

data/lib/ruby_units/string/extra.rb

@@ -0,0 +1,132 @@
+#
+# String Extras
+# 
+# These are some extra string syntax sugar methods.  In some cases they conflict with methods defined in other 
+# gems (notably with Rails).  I could make them more compatilble, but honestly they should not be here in the first place.
+#
+# in most cases it is better to do something like
+#
+# Unit("1 m").convert_to("ft")
+# 
+# instead of
+#
+# "1 m".convert_to("ft")
+#
+# to use these methods:
+# require 'ruby-units/string/extra'
+
+require 'time'
+class String
+  
+  #needed for compatibility with Rails, which defines a String.from method  
+  if self.public_instance_methods.include? 'from'
+    alias :old_from :from
+  end 
+  
+  # "5 min".from("now")
+  def from(time_point = ::Time.now)
+    return old_from(time_point) if self.respond_to?(:old_from) && time_point.instance_of?(Integer)
+    warn Kernel.caller.first + " called ruby-units/string#from, which is deprecated.  Use Unit(string).from(string) instead"
+    self.unit.from(time_point)
+  end
+  
+  alias :after :from
+
+  def from_now
+    warn Kernel.caller.first + " called ruby-units/string#from_now, which is deprecated.  Use Unit(string).from(Time.now) instead"
+    self.from(Time.now)
+  end
+  
+  # "5 min".ago
+  def ago
+    warn Kernel.caller.first + " called ruby-units/string#ago, which is deprecated.  Use Unit(string).ago instead"
+    self.unit.ago
+  end
+  
+  def before(time_point = ::Time.now)
+    warn Kernel.caller.first + " called ruby-units/string#before, which is deprecated.  Use Unit(string).before(Time.now) instead"
+    self.unit.before(time_point)
+  end
+  
+  def before_now
+    warn Kernel.caller.first + " called ruby-units/string#before_now, which is deprecated.  Use Unit(string).before(Time.now) instead"
+    self.before(Time.now)
+  end
+  
+  def since(time_point = ::Time.now)
+    warn Kernel.caller.first + " called ruby-units/string#since, which is deprecated.  Use Unit(string).since(Time.now) instead"
+    self.unit.since(time_point)
+  end
+  
+  def until(time_point = ::Time.now)
+    warn Kernel.caller.first + " called ruby-units/string#until, which is deprecated.  Use Unit(string).until(Time.now) instead"
+    self.unit.until(time_point)
+  end
+  
+  
+  unless String.instance_methods.include?(:to)
+    def to(other)
+      warn "string.to is deprecated, use string.convert_to if you must, but the best would be Unit('unit').convert_to('target unit')"
+      convert_to(other)
+    end
+  end
+  
+  def time(options = {})
+    self.to_time(options) rescue self.to_datetime(options)
+  end
+  
+  def to_time(options = {})
+    begin
+      #raises exception when Chronic not defined or when it returns a nil (i.e., can't parse the input)
+      r = Chronic.parse(self,options)
+      raise(ArgumentError, 'Invalid Time String') unless r
+      return r
+    rescue 
+      case
+      when self == "now"
+        Time.now
+      when Time.respond_to?(:parse)
+        Time.parse(self)
+      else
+        Time.local(*ParseDate.parsedate(self))
+      end
+    end
+  end
+  
+  def to_datetime(options = {})
+    begin
+      # raises an exception if Chronic.parse = nil or if Chronic not defined
+      r = Chronic.parse(self,options).send(:to_datetime)
+    rescue NameError  => e
+      r = case
+      when self.to_s == "now"
+        DateTime.now
+      else
+        DateTime.parse(self)
+      end
+    end
+    raise RuntimeError, "Invalid Time String (#{self.to_s})" if r == DateTime.new      
+    return r
+  end
+  
+  def to_date(options={})
+    begin
+      r = Chronic.parse(self,options).to_date
+    rescue
+      r = case
+      when self == "today" 
+        Date.today
+      when RUBY_VERSION < "1.9"
+        Date.civil(*ParseDate.parsedate(self)[0..5].compact)
+      else
+        Date.parse(self)
+      end
+    end
+    raise RuntimeError, 'Invalid Date String' if r == Date.new
+    return r
+  end
+  
+  def datetime(options = {})
+    self.to_datetime(options) rescue self.to_time(options)
+  end
+end