rubysl-date 1.0.1 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a79e200c26dce696d67d54ceee32ca7ea7926e3
-  data.tar.gz: d909437349a82b70bc3c1e98701636f19e4d1bd6
+  metadata.gz: ef338a6f69e34ebe197850c7e8f26b5a31b5e9df
+  data.tar.gz: f832b4ac193923f9ae808e3d59443a3098843aad
 SHA512:
-  metadata.gz: 3ae6ba9b9a16f3b949ba2246b5157789e8ff18dc1e9d874f9908e668336ce3dae50c2564e42f463dd7bf08ef9192859bab848f775bd5a750cd0f31aa9abecf32
-  data.tar.gz: ee53807380e45124a257b51fe61f257d1d93956b343acc65d0465dc4df7dbf3557ecf7b7f2030d567c915e1165c4a70457c85431c2f889d25f1806145fb6003e
+  metadata.gz: 69b4b3c1a906551fff012aa639c82ed7e8178f77fd389678e6cab6ca883796b576ab5e2e4f2ae8ba3dbf973a6338fd94128a83671c875bc6b1878a4f9b874b88
+  data.tar.gz: 90cb9b3a4ec7f461abd20fb40bccf45cb70040bbcbf4dc44d6abd0dfc07d578fb17a8dfa70b37c343f50ede0eb452673c28d0b02f3ab6a91c7181bb210c2c022

data/.travis.yml

@@ -1,7 +1,9 @@
 language: ruby
+before_install:
+  - rvm use $RVM --install --binary --fuzzy
+  - gem update --system
+  - gem --version
+  - gem install rubysl-bundler
 env:
-  - RUBYLIB=lib
-script: bundle exec mspec
-rvm:
-  - 1.8.7
-  - rbx-nightly-18mode
+  - RVM=rbx-nightly-d21 RUBYLIB=lib
+script: bundle exec mspec spec

data/lib/date/delta.rb

@@ -0,0 +1,431 @@
+# delta.rb: Written by Tadayoshi Funaba 2004-2009
+
+require 'date'
+require 'date/delta/parser'
+
+class Date
+
+  class Delta
+
+    include Comparable
+
+    UNIT_PREFIXES = {
+      'yotta'      => Rational(10**24),
+      'zetta'      => Rational(10**21),
+      'exa'        => Rational(10**18),
+      'peta'       => Rational(10**15),
+      'tera'       => Rational(10**12),
+      'giga'       => Rational(10**9),
+      'mega'       => Rational(10**6),
+      'kilo'       => Rational(10**3),
+      'hecto'      => Rational(10**2),
+      'deca'       => Rational(10**1),
+      'deka'       => Rational(10**1),
+      'deci'       => Rational(1, 10**1),
+      'centi'      => Rational(1, 10**2),
+      'milli'      => Rational(1, 10**3),
+      'decimilli'  => Rational(1, 10**4),
+      'centimilli' => Rational(1, 10**5),
+      'micro'      => Rational(1, 10**6),
+      'nano'       => Rational(1, 10**9),
+      'millimicro' => Rational(1, 10**9),
+      'pico'       => Rational(1, 10**12),
+      'micromicro' => Rational(1, 10**12),
+      'femto'      => Rational(1, 10**15),
+      'atto'       => Rational(1, 10**18),
+      'zepto'      => Rational(1, 10**21),
+      'yocto'      => Rational(1, 10**24)
+    }
+
+    IUNITS = {
+      'year'       => Complex(0, 12),
+      'month'      => Complex(0, 1)
+    }
+
+    RUNITS = {
+      'day'        => Rational(1),
+      'week'       => Rational(7),
+      'sennight'   => Rational(7),
+      'fortnight'  => Rational(14),
+      'hour'       => Rational(1, 24),
+      'minute'     => Rational(1, 1440),
+      'second'     => Rational(1, 86400)
+    }
+
+    UNIT_PREFIXES.each do |k, v|
+      RUNITS[k + 'second'] = v * RUNITS['second']
+    end
+
+    remove_const :UNIT_PREFIXES
+
+    UNITS = {}
+
+    IUNITS.each do |k, v|
+      UNITS[k] = v
+    end
+
+    RUNITS.each do |k, v|
+      UNITS[k] = v
+    end
+
+    UNITS4KEY = {}
+
+    UNITS.each do |k, v|
+      UNITS4KEY[k] = UNITS4KEY[k + 's'] = v
+    end
+
+    UNITS4KEY['y'] = UNITS4KEY['years']
+    UNITS4KEY['yr'] = UNITS4KEY['years']
+    UNITS4KEY['yrs'] = UNITS4KEY['years']
+    UNITS4KEY['m'] = UNITS4KEY['months']
+    UNITS4KEY['mo'] = UNITS4KEY['months']
+    UNITS4KEY['mon'] = UNITS4KEY['months']
+    UNITS4KEY['mnth'] = UNITS4KEY['months']
+    UNITS4KEY['mnths'] = UNITS4KEY['months']
+    UNITS4KEY['w'] = UNITS4KEY['weeks']
+    UNITS4KEY['wk'] = UNITS4KEY['weeks']
+    UNITS4KEY['d'] = UNITS4KEY['days']
+    UNITS4KEY['dy'] = UNITS4KEY['days']
+    UNITS4KEY['dys'] = UNITS4KEY['days']
+    UNITS4KEY['h'] = UNITS4KEY['hours']
+    UNITS4KEY['hr'] = UNITS4KEY['hours']
+    UNITS4KEY['hrs'] = UNITS4KEY['hours']
+    UNITS4KEY['min'] = UNITS4KEY['minutes']
+    UNITS4KEY['mins'] = UNITS4KEY['minutes']
+    UNITS4KEY['s'] = UNITS4KEY['seconds']
+    UNITS4KEY['sec'] = UNITS4KEY['seconds']
+    UNITS4KEY['secs'] = UNITS4KEY['seconds']
+    UNITS4KEY['ms'] = UNITS4KEY['milliseconds']
+    UNITS4KEY['msec'] = UNITS4KEY['milliseconds']
+    UNITS4KEY['msecs'] = UNITS4KEY['milliseconds']
+    UNITS4KEY['milli'] = UNITS4KEY['milliseconds']
+    UNITS4KEY['us'] = UNITS4KEY['microseconds']
+    UNITS4KEY['usec'] = UNITS4KEY['microseconds']
+    UNITS4KEY['usecs'] = UNITS4KEY['microseconds']
+    UNITS4KEY['micro'] = UNITS4KEY['microseconds']
+    UNITS4KEY['ns'] = UNITS4KEY['nanoseconds']
+    UNITS4KEY['nsec'] = UNITS4KEY['nanoseconds']
+    UNITS4KEY['nsecs'] = UNITS4KEY['nanoseconds']
+    UNITS4KEY['nano'] = UNITS4KEY['nanoseconds']
+
+    def self.delta_to_dhms(delta)
+      fr = delta.imag.abs
+      y,   fr = fr.divmod(12)
+      m,   fr = fr.divmod(1)
+
+      if delta.imag < 0
+	y = -y
+	m = -m
+      end
+
+      fr = delta.real.abs
+      ss,  fr = fr.divmod(SECONDS_IN_DAY) # 4p
+      d,   ss = ss.divmod(86400)
+      h,   ss = ss.divmod(3600)
+      min, s  = ss.divmod(60)
+
+      if delta.real < 0
+	d = -d
+	h = -h
+	min = -min
+	s = -s
+      end
+
+      return y, m, d, h, min, s, fr
+    end
+
+    def self.dhms_to_delta(y, m, d, h, min, s, fr)
+      fr = 0 if fr == 0
+      Complex(0, y.to_i * 12 + m.to_i) +
+	Rational(d * 86400 + h * 3600 + min * 60 + (s + fr), 86400) # 4p
+    end
+
+    def initialize(delta)
+      @delta = delta
+      @__ca__ = {}
+    end
+
+    class << self; alias_method :new!, :new end
+
+    def self.new(arg=0, h=0, min=0, s=0)
+      if Hash === arg
+	d = Complex(0)
+	arg.each do |k, v|
+	  k = k.to_s.downcase
+	  unless UNITS4KEY[k]
+	    raise ArgumentError, "unknown keyword #{k}"
+	  end
+	  d += v * UNITS4KEY[k]
+	end
+      else
+	d = dhms_to_delta(0, 0, arg, h, min, s, 0)
+      end
+      new!(d)
+    end
+
+    UNITS.each_key do |k|
+      module_eval <<-"end;"
+	def self.#{k}s(n=1)
+	  new(:d=>n * UNITS['#{k}'])
+	end
+      end;
+    end
+
+    class << self; alias_method :mins, :minutes end
+    class << self; alias_method :secs, :seconds end
+
+    def self.parse(str)
+      d = begin (@@pa ||= Parser.new).parse(str)
+	  rescue Racc::ParseError
+	    raise ArgumentError, 'syntax error'
+	  end
+      new!(d)
+    end
+
+    def self.diff(d1, d2) new(d1.ajd - d2.ajd) end
+
+    class << self
+
+      def once(*ids) # :nodoc: -- restricted
+	for id in ids
+	  module_eval <<-"end;"
+	    alias_method :__#{id.object_id}__, :#{id.to_s}
+	    private :__#{id.object_id}__
+	    def #{id.to_s}(*args)
+	      @__ca__[#{id.object_id}] ||= __#{id.object_id}__(*args)
+	    end
+	  end;
+        end
+      end
+
+      private :once
+
+    end
+
+    def dhms() self.class.delta_to_dhms(@delta) end
+
+    once :dhms
+
+    def delta() @delta end
+
+    protected :delta
+
+    def years() dhms[0] end
+    def months() dhms[1] end
+    def days() dhms[2] end
+    def hours() dhms[3] end
+    def minutes() dhms[4] end
+    def seconds() dhms[5] end
+    def second_fractions() dhms[6] end
+
+    alias_method :mins, :minutes
+    alias_method :secs, :seconds
+    alias_method :sec_fractions, :second_fractions
+
+    RUNITS.each_key do |k|
+      module_eval <<-"end;"
+	def in_#{k}s(u=1)
+	  if @delta.imag != 0
+	    raise ArgumentError, "#{k}: #{self} has month"
+	  end
+	  @delta.real / (u * RUNITS['#{k}'])
+	end
+      end;
+    end # <<dummy
+
+    alias_method :in_mins, :in_minutes
+    alias_method :in_secs, :in_seconds
+
+    def zero?() @delta.zero? end
+    def nonzero?() unless zero? then self end end
+
+    def integer? () @delta.imag == 0 && @delta.real.integer? end
+
+    def -@ () self.class.new!(-@delta) end
+    def +@ () self.class.new!(+@delta) end
+
+    def dx_addsub(m, n)
+      case n
+      when Numeric; return self.class.new!(@delta.__send__(m, n))
+      when Delta; return self.class.new!(@delta.__send__(m, n.delta))
+      else
+	l, r = n.coerce(self)
+	return l.__send__(m, r)
+      end
+    end
+
+    private :dx_addsub
+
+    def + (n) dx_addsub(:+, n) end
+    def - (n) dx_addsub(:-, n) end
+
+    def dx_muldiv(m, n)
+      case n
+      when Numeric
+	return self.class.new!(@delta.__send__(m, n))
+      else
+	l, r = n.coerce(self)
+	return l.__send__(m, r)
+      end
+    end
+
+    private :dx_muldiv
+
+    def * (n) dx_muldiv(:*, n) end
+    def / (n) dx_muldiv(:/, n) end
+
+    def dx_conv1(m, n)
+      if @delta.imag != 0
+	raise ArgumentError, "#{m}: #{self} has month"
+      end
+      case n
+      when Numeric
+	return self.class.new!(Complex(@delta.real.__send__(m, n), 0))
+      else
+	l, r = n.coerce(self)
+	return l.__send__(m, r)
+      end
+    end
+
+    private :dx_conv1
+
+    def % (n) dx_conv1(:%, n) end
+
+    def div(n) dx_conv1(:div, n) end
+    def modulo(n) dx_conv1(:modulo, n) end
+    def divmod(n) [div(n), modulo(n)] end
+
+    def quotient(n)
+      if @delta.imag != 0
+	raise ArgumentError, "quotient: #{self} has month"
+      end
+      case n
+      when Numeric
+	return self.class.new!(Complex((@delta.real / n).truncate))
+      else
+	l, r = n.coerce(self)
+	return l.__send__(m, r)
+      end
+    end
+
+    def remainder(n) dx_conv1(:remainder, n) end
+    def quotrem(n) [quotient(n), remainder(n)] end
+
+    def ** (n) dx_conv1(:**, n) end
+    def quo(n) dx_muldiv(:quo, n) end
+
+    def <=> (other)
+      if @delta.imag != 0
+	raise ArgumentError, "<=>: #{self} has month"
+      end
+      case other
+      when Numeric; return @delta.real <=> other
+      when Delta;   return @delta.real <=> other.delta.real
+      else
+	begin
+	  l, r = other.coerce(self)
+	  return l <=> r
+	rescue NoMethodError
+	end
+      end
+      nil
+    end
+
+    def == (other)
+      case other
+      when Numeric; return @delta == other
+      when Delta;   return @delta == other
+      else
+	begin
+	  l, r = other.coerce(self)
+	  return l == r
+	rescue NoMethodError
+	end
+      end
+      nil
+    end
+
+    def coerce(other)
+      case other
+      when Numeric; return other, @delta
+      else
+	super
+      end
+    end
+
+    def eql? (other) Delta === other && self == other end
+    def hash() @delta.hash end
+
+    def dx_conv0(m)
+      if @delta.imag != 0
+	raise ArgumentError, "#{m}: #{self} has month"
+      end
+      @delta.real.__send__(m)
+    end
+
+    private :dx_conv0
+
+    def abs() dx_conv0(:abs) end
+
+    def ceil() dx_conv0(:ceil) end
+    def floor() dx_conv0(:floor) end
+    def round() dx_conv0(:round) end
+    def truncate() dx_conv0(:truncate) end
+
+    def to_i() dx_conv0(:to_i) end
+    def to_f() dx_conv0(:to_f) end
+    def to_r() dx_conv0(:to_r) end
+    def to_c() @delta end
+
+    alias_method :to_int, :to_i
+
+    def inspect() format('#<%s: %s (%s)>', self.class, to_s, @delta) end
+
+    def to_s
+      format(%(%s(%dd %.02d:%02d'%02d"%03d)%s(%dy %dm)), # '
+	     if @delta.real < 0 then '-' else '+' end,
+	     days.abs, hours.abs, mins.abs, secs.abs, sec_fractions.abs * 1000,
+	     if @delta.imag < 0 then '-' else '+' end,
+	     years.abs, months.abs)
+    end
+
+    def marshal_dump() @delta end
+
+    def marshal_load(a)
+      @delta = a
+      @__ca__ = {}
+    end
+
+  end
+
+end
+
+vsave = $VERBOSE
+$VERBOSE = false
+
+class Date
+
+  def + (n)
+    case n
+    when Numeric; return self.class.new!(@ajd + n, @of, @sg)
+    when Delta
+      d = n.__send__(:delta)
+      return (self >> d.imag) + d.real
+    end
+    raise TypeError, 'expected numeric'
+  end
+
+  def - (x)
+    case x
+    when Numeric; return self.class.new!(@ajd - x, @of, @sg)
+    when Date;    return @ajd - x.ajd
+    when Delta
+      d = x.__send__(:delta)
+      return (self << d.imag) - d.real
+    end
+    raise TypeError, 'expected numeric'
+  end
+
+end
+
+$VERBOSE = vsave