[前][次][番号順一覧][スレッド一覧]

ruby-changes:15578

From: tadf <ko1@a...>
Date: Sun, 25 Apr 2010 15:37:40 +0900 (JST)
Subject: [ruby-changes:15578] Ruby:r27484 (trunk): * lib/date.rb, lib/date/delta*: reverted experimental r24567 and

tadf	2010-04-25 15:37:18 +0900 (Sun, 25 Apr 2010)

  New Revision: 27484

  http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=rev&revision=27484

  Log:
    * lib/date.rb, lib/date/delta*: reverted experimental r24567 and
      r25393.

  Removed directories:
    trunk/lib/date/delta/
  Removed files:
    trunk/lib/date/delta.rb
  Modified files:
    trunk/ChangeLog
    trunk/lib/date.rb

Index: ChangeLog
===================================================================
--- ChangeLog	(revision 27483)
+++ ChangeLog	(revision 27484)
@@ -1,3 +1,8 @@
+Sun Apr 25 15:34:48 2010  Tadayoshi Funaba  <tadf@d...>
+
+	* lib/date.rb, lib/date/delta*: reverted experimental r24567 and
+	  r25393.
+
 Sun Apr 25 11:02:20 2010  wanabe  <s.wanabe@g...>
 
 	* hash.c (ruby_setenv): putenv on msvcrt.dll can't remove empty value.
Index: lib/date/delta.rb
===================================================================
--- lib/date/delta.rb	(revision 27483)
+++ lib/date/delta.rb	(revision 27484)
@@ -1,431 +0,0 @@
-# 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
-
-    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
Index: lib/date.rb
===================================================================
--- lib/date.rb	(revision 27483)
+++ lib/date.rb	(revision 27484)
@@ -1371,12 +1371,6 @@
     case other
     when Numeric; return @ajd <=> other
     when Date;    return @ajd <=> other.ajd
-    else
-      begin
-        l, r = other.coerce(self)
-        return l <=> r
-      rescue NoMethodError
-      end
     end
     nil
   end
@@ -1391,9 +1385,6 @@
     case other
     when Numeric; return jd == other
     when Date;    return jd == other.jd
-    else
-      l, r = other.coerce(self)
-      return l === r
     end
     false
   end

--
ML: ruby-changes@q...
Info: http://www.atdot.net/~ko1/quickml/

[前][次][番号順一覧][スレッド一覧]