rails-units 1.3.1

data/TODO

@@ -0,0 +1,2 @@
+2006-10-02  Currency handling remains to be implemented well
+2011-04-23  Refactor caching

data/VERSION

@@ -0,0 +1 @@
+1.3.1

data/lib/ruby-units.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH << File.dirname(__FILE__)
+require "ruby_units/version"
+require "ruby_units/cache"
+require 'ruby_units/array'
+require 'ruby_units/date'
+require 'ruby_units/time'
+require 'ruby_units/math'
+require 'ruby_units/numeric'
+require 'ruby_units/object'
+require 'ruby_units/string'
+require 'ruby_units/unit_definitions'
+require 'ruby_units/unit'
+require 'ruby_units/fixnum'
+

data/lib/ruby_units.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH << File.dirname(__FILE__)
+require "ruby_units/version"
+require "ruby_units/cache"
+require 'ruby_units/array'
+require 'ruby_units/date'
+require 'ruby_units/time'
+require 'ruby_units/math'
+require 'ruby_units/numeric'
+require 'ruby_units/object'
+require 'ruby_units/string'
+require 'ruby_units/unit_definitions'
+require 'ruby_units/unit'
+require 'ruby_units/fixnum'
+

data/lib/ruby_units/array.rb

@@ -0,0 +1,9 @@
+# make a unit from an array
+# [1, 'mm'].unit => 1 mm
+class Array
+  def to_unit(other = nil)
+    other ? Unit.new(self).to(other) : Unit.new(self)
+  end
+  alias :unit :to_unit
+  alias :u :to_unit
+end

data/lib/ruby_units/cache.rb

@@ -0,0 +1,20 @@
+class Unit < Numeric
+  @@cached_units = {}
+  
+  class Cache
+    def self.get(key = nil)
+      key.nil? ? @@cached_units : @@cached_units[key]
+    end
+  
+    def self.set(key, value)
+      @@cached_units[key] = value
+    end
+
+    def self.clear
+      @@cached_units = {}
+      @@base_unit_cache = {}
+      Unit.new(1)
+    end
+    
+  end
+end

data/lib/ruby_units/date.rb

@@ -0,0 +1,53 @@
+# Allow date objects to do offsets by a time unit
+# Date.today + U"1 week" => gives today+1 week
+
+require 'date'
+
+class Date
+  alias :unit_date_add :+
+  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)
+    else
+      unit_date_add(unit)
+    end
+  end
+
+ 
+  alias :unit_date_sub :-    
+  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)
+    else
+      unit_date_sub(unit)
+    end
+  end
+  
+  def to_unit(other = nil)
+    other ? Unit.new(self).to(other) : Unit.new(self)
+  end
+  alias :unit :to_unit
+  
+  unless Date.instance_methods.include?(:to_time)
+    def to_time
+      Time.local(*ParseDate.parsedate(self.to_s))
+    end
+  end
+  
+  alias :units_datetime_inspect :inspect
+  def inspect(raw = false)
+    return self.units_datetime_inspect if raw
+    self.to_s
+  end
+  
+  unless Date.instance_methods.include?(:to_date)
+    def to_date
+      Date.civil(self.year, self.month, self.day)
+    end
+  end
+  
+end

data/lib/ruby_units/fixnum.rb

@@ -0,0 +1,20 @@
+# this patch is necessary for ruby 1.8 because cases where
+# Integers are divided by Units don't work quite right
+
+if RUBY_VERSION < "1.9"
+  class Fixnum
+    alias quo_without_units quo
+  
+    def quo_with_units(other)
+      case other
+      when Unit
+        self * other.inverse
+      else
+        quo_without_units(other)
+      end
+    end
+  
+    alias quo quo_with_units
+    alias / quo_with_units
+  end
+end

data/lib/ruby_units/math.rb

@@ -0,0 +1,101 @@
+# Math will convert unit objects to radians and then attempt to use the value for 
+# trigonometric functions.  
+require 'mathn'
+
+module Math
+
+  alias :unit_sqrt :sqrt
+  def sqrt(n)
+    if Unit === n
+      (n**(Rational(1,2))).to_unit 
+    else
+      unit_sqrt(n)
+    end
+  end
+  module_function :unit_sqrt
+  module_function :sqrt
+
+  #:nocov:
+  if self.respond_to?(:cbrt)
+    alias :unit_cbrt :cbrt
+    def cbrt(n)
+      if Unit === n
+        (n**(Rational(1,3))).to_unit 
+      else
+        unit_cbrt(n)
+      end
+    end
+    module_function :unit_cbrt
+    module_function :cbrt
+  end
+  #:nocov:
+    
+  alias :unit_sin :sin
+  def sin(n)
+   Unit === n ? unit_sin(n.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)
+  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)
+  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)
+  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)
+  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)
+  end
+  module_function :unit_tanh
+  module_function :tanh
+
+  alias :unit_hypot :hypot
+  # Convert parameters to consistent units and perform the function
+  def hypot(x,y)
+    if Unit === x && Unit === y
+      (x**2 + y**2)**(1/2)
+    else
+      unit_hypot(x,y)
+    end
+  end
+  module_function :unit_hypot
+  module_function :hypot
+  
+  alias :unit_atan2 :atan2
+  def atan2(x,y)
+    case
+    when (x.is_a?(Unit) && y.is_a?(Unit)) && (x !~ y)
+      raise ArgumentError, "Incompatible Units"
+    when (x.is_a?(Unit) && y.is_a?(Unit)) && (x =~ y)
+      Math::unit_atan2(x.base_scalar, y.base_scalar)
+    else
+      Math::unit_atan2(x,y)
+    end
+  end
+  module_function :unit_atan2
+  module_function :atan2
+   
+end

data/lib/ruby_units/numeric.rb

@@ -0,0 +1,8 @@
+# make a unitless unit with a given scalar
+class Numeric
+  def to_unit(other = nil)
+    other ? Unit.new(self, other) : Unit.new(self)
+  end
+  alias :unit :to_unit
+  alias :u :to_unit
+end

data/lib/ruby_units/object.rb

@@ -0,0 +1,8 @@
+class Object
+  def Unit(*other)
+    other.to_unit
+  end
+  
+  alias :U :Unit
+  alias :u :Unit
+end

data/lib/ruby_units/string.rb

@@ -0,0 +1,122 @@
+require 'time'
+# make a string into a unit
+class String
+  def to_unit(other = nil)
+    other ? Unit.new(self).to(other) : Unit.new(self)
+  end
+  alias :unit :to_unit
+  alias :u :to_unit
+  alias :unit_format :%
+
+  # format unit output using formating codes '%0.2f' % '1 mm'.unit => '1.00 mm'
+  def %(*args)
+    return "" if self.empty?
+    case
+    when args.first.is_a?(Unit)
+      args.first.to_s(self)
+    when (!defined?(Uncertain).nil? && args.first.is_a?(Uncertain))
+      args.first.to_s(self)
+    when args.first.is_a?(Complex)
+      args.first.to_s
+    else
+      unit_format(*args)
+    end
+  end
+
+  #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)
+    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 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
+
+  def datetime(options = {})
+    self.to_datetime(options) rescue self.to_time(options)
+  end
+end

data/lib/ruby_units/time.rb

@@ -0,0 +1,71 @@
+#
+# Time math is handled slightly differently.  The difference is considered to be an exact duration if
+# the subtracted value is in hours, minutes, or seconds.  It is rounded to the nearest day if the offset
+# is in years, decades, or centuries.  This leads to less precise values, but ones that match the 
+# calendar better.
+class Time
+  
+  class << self
+    alias unit_time_at at
+  end
+  
+  # Convert a duration to a Time value by considering the duration to be the number of seconds since the 
+  # epoch
+  def self.at(arg)
+    case arg
+    when Unit
+      unit_time_at(arg.to("s").scalar)
+    else
+      unit_time_at(arg)
+    end
+  end
+  
+  def to_unit(other = nil)
+    other ? Unit.new(self).to(other) : Unit.new(self)
+  end
+  alias :unit :to_unit
+  alias :u :to_unit
+  alias :unit_add :+
+  
+  unless Time.instance_methods.include?(:to_date)
+    def to_date
+      x=(Date.civil(1970,1,1)+((self.to_f+self.gmt_offset)/86400.0)-0.5)
+      Date.civil(x.year, x.month, x.day)
+    end
+  end
+  
+  def +(other)
+    case other
+    when Unit
+      other = other.to('d').round.to('s') if ['y', 'decade', 'century'].include? other.units  
+      begin
+        unit_add(other.to('s').scalar)
+      rescue RangeError
+        self.to_datetime + other
+      end
+    else
+      unit_add(other)
+    end
+  end
+  
+  # usage: Time.in '5 min'
+  def self.in(duration)
+    Time.now + duration.to_unit
+  end
+  
+  alias :unit_sub :-
+  
+  def -(other)
+    case other
+    when Unit
+      other = other.to('d').round.to('s') if ['y', 'decade', 'century'].include? other.units  
+      begin
+        unit_sub(other.to('s').scalar)
+      rescue RangeError
+        self.send(:to_datetime) - other
+      end
+    else
+      unit_sub(other)
+    end
+  end
+end