third_base 1.0.0

data/lib/third_base/datetime.rb

@@ -0,0 +1,385 @@
+require 'third_base/date'
+
+module ThirdBase
+  # ThirdBase's DateTime class, which builds on the Date class and adds a time component of
+  # hours, minutes, seconds, microseconds, and an offset from UTC.
+  class DateTime < Date
+    
+    PARSER_LIST = []
+    DEFAULT_PARSER_LIST = [:time, :iso, :us, :num]
+    DEFAULT_PARSERS = {}
+    TIME_RE_STRING = '(?:[T ]?([\d ]?\d):(\d\d)(?::(\d\d(\.\d+)?))?([ap]m?)? ?(Z|[+-](?:\d\d:?(?:\d\d)?))?)?'
+    DEFAULT_PARSERS[:time] = [[%r{\A#{TIME_RE_STRING}\z}io, proc do |m|
+        unless m[0] == ''
+          t = Time.now
+          add_parsed_time_parts(m, {:civil=>[t.year, t.mon, t.day]}, 1)
+        end
+      end]]
+    DEFAULT_PARSERS[:iso] = [[%r{\A(-?\d{4})[-./ ](\d\d)[-./ ](\d\d)#{TIME_RE_STRING}\z}io, proc{|m| add_parsed_time_parts(m, :civil=>[m[1].to_i, m[2].to_i, m[3].to_i])}]]
+    DEFAULT_PARSERS[:us] = [[%r{\A(\d\d?)[-./ ](\d\d?)[-./ ](\d\d(?:\d\d)?)#{TIME_RE_STRING}\z}io, proc{|m| add_parsed_time_parts(m, :civil=>[two_digit_year(m[3]), m[1].to_i, m[2].to_i])}],
+      [%r{\A(\d\d?)/(\d?\d)#{TIME_RE_STRING}\z}o, proc{|m| add_parsed_time_parts(m, {:civil=>[Time.now.year, m[1].to_i, m[2].to_i]}, 3)}],
+      [%r{\A#{MONTHNAME_RE_PATTERN}[-./ ](\d\d?)(?:st|nd|rd|th)?,?(?:[-./ ](-?(?:\d\d(?:\d\d)?)))?#{TIME_RE_STRING}\z}io, proc{|m| add_parsed_time_parts(m, :civil=>[m[3] ? two_digit_year(m[3]) : Time.now.year, MONTH_NUM_MAP[m[1].downcase], m[2].to_i])}],
+      [%r{\A(\d\d?)(?:st|nd|rd|th)?[-./ ]#{MONTHNAME_RE_PATTERN}[-./ ](-?\d{4})#{TIME_RE_STRING}\z}io, proc{|m| add_parsed_time_parts(m, :civil=>[m[3].to_i, MONTH_NUM_MAP[m[2].downcase], m[1].to_i])}],
+      [%r{\A(-?\d{4})[-./ ]#{MONTHNAME_RE_PATTERN}[-./ ](\d\d?)(?:st|nd|rd|th)?#{TIME_RE_STRING}\z}io, proc{|m| add_parsed_time_parts(m, :civil=>[m[1].to_i, MONTH_NUM_MAP[m[2].downcase], m[3].to_i])}],
+      [%r{\A#{MONTHNAME_RE_PATTERN}[-./ ](-?\d{4})#{TIME_RE_STRING}\z}io, proc{|m| add_parsed_time_parts(m, {:civil=>[m[2].to_i, MONTH_NUM_MAP[m[1].downcase], 1]}, 3)}]]
+    DEFAULT_PARSERS[:eu] = [[%r{\A(\d\d?)[-./ ](\d\d?)[-./ ](\d{4})#{TIME_RE_STRING}\z}io, proc{|m| add_parsed_time_parts(m, :civil=>[m[3].to_i, m[2].to_i, m[1].to_i])}],
+      [%r{\A(\d\d?)[-./ ](\d?\d)[-./ ](\d?\d)#{TIME_RE_STRING}\z}io, proc{|m| add_parsed_time_parts(m, :civil=>[two_digit_year(m[1]), m[2].to_i, m[3].to_i])}]]
+    DEFAULT_PARSERS[:num] = [[%r{\A(\d{2,8})#{TIME_RE_STRING}\z}io, proc do |n|
+        m = n[1]
+        add_parsed_time_parts(n, (
+        case m.length
+        when 2
+          t = Time.now
+          {:civil=>[t.year, t.mon, m.to_i]}
+        when 3
+          {:ordinal=>[Time.now.year, m.to_i]}
+        when 4
+          {:civil=>[Time.now.year, m[0..1].to_i, m[2..3].to_i]}
+        when 5
+          {:ordinal=>[two_digit_year(m[0..1]), m[2..4].to_i]}
+        when 6
+          {:civil=>[two_digit_year(m[0..1]), m[2..3].to_i, m[4..5].to_i]}
+        when 7
+          {:ordinal=>[m[0..3].to_i, m[4..6].to_i]}
+        when 8
+          {:civil=>[m[0..3].to_i, m[4..5].to_i, m[6..7].to_i]}
+        end
+        ), 2)
+      end
+      ]]
+    
+    STRPTIME_PROC_H = proc{|h,x| h[:hour] = x.to_i}
+    STRPTIME_PROC_M = proc{|h,x| h[:min] = x.to_i}
+    STRPTIME_PROC_P = proc{|h,x| h[:meridian] = x.downcase == 'pm' ? :pm : :am}
+    STRPTIME_PROC_S = proc{|h,x| h[:sec] = x.to_i}
+    STRPTIME_PROC_s = proc do |h,x|
+      j, i = x.to_i.divmod(86400)
+      hours, i = i.divmod(3600)
+      minutes, seconds = i.divmod(60)
+      h.merge!(:jd=>j+UNIXEPOCH, :hour=>hours, :min=>minutes, :sec=>seconds)
+    end
+    STRPTIME_PROC_z = proc{|h,x| x=x.gsub(':',''); h[:offset] = (x == 'Z' ? 0 : x[0..2].to_i*3600 + x[3..4].to_i*60)}
+    
+    # Public Class Methods
+    
+    # Create a new DateTime with the given year, month, day of month, hour, minute, second, microsecond and offset.
+    def self.civil(year, mon, day, hour=0, min=0, sec=0, usec=0, offset=0)
+      new!(:civil=>[year, mon, day], :parts=>[hour, min, sec, usec], :offset=>offset)
+    end
+    
+    # Create a new DateTime with the given commercial week year, commercial week, commercial week day, hour, minute
+    # second, microsecond, and offset.
+    def self.commercial(cwyear, cweek, cwday=5, hour=0, min=0, sec=0, usec=0, offset=0)
+      new!(:commercial=>[cwyear, cweek, cwday], :parts=>[hour, min, sec, usec], :offset=>offset)
+    end
+    
+    # Create a new DateTime with the given julian date, hour, minute, second, microsecond, and offset.
+    def self.jd(jd, hour=0, min=0, sec=0, usec=0, offset=0)
+      new!(:jd=>jd, :parts=>[hour, min, sec, usec], :offset=>offset)
+    end
+    
+    # Create a new DateTime with the given julian day, fraction of the day (0.5 is Noon), and offset.
+    def self.jd_fract(jd, fract=0.0, offset=0)
+      new!(:jd=>jd, :fract=>fract, :offset=>offset)
+    end
+    
+    # Create a new DateTime with the current date and time.
+    def self.now
+      t = Time.now
+      new!(:civil=>[t.year, t.mon, t.day], :parts=>[t.hour, t.min, t.sec, t.usec], :offset=>t.utc_offset)
+    end
+    
+    # Create a new DateTime with the given year, day of year, hour, minute, second, microsecond, and offset.
+    def self.ordinal(year, yday, hour=0, min=0, sec=0, usec=0, offset=0)
+      new!(:ordinal=>[year, yday], :parts=>[hour, min, sec, usec], :offset=>offset)
+    end
+    
+    # Private Class Methods
+    
+    def self._expand_strptime_format(v)
+      case v
+      when '%c' then '%a %b %e %H:%M:%S %Y'
+      when '%T', '%X' then '%H:%M:%S'
+      when '%R' then '%H:%M'
+      when '%r' then '%I:%M:%S %p'
+      when '%+' then '%a %b %e %H:%M:%S %z %Y'
+      else super(v)
+      end
+    end
+    
+    def self._strptime_part(v)
+      case v
+      when 'H', 'I' then ['(\d\d)', STRPTIME_PROC_H]
+      when 'k', 'l' then ['(\d?\d)', STRPTIME_PROC_H]
+      when 'M' then ['(\d\d)', STRPTIME_PROC_M]
+      when 'P', 'p' then ['([ap]m)', STRPTIME_PROC_P]
+      when 'S' then ['(\d\d)', STRPTIME_PROC_S]
+      when 's' then ['(\d+)', STRPTIME_PROC_s]
+      when 'z', 'Z' then ['(Z|[+-](?:\d{4}|\d\d:\d\d))', STRPTIME_PROC_z]
+      else super(v)
+      end
+    end
+    
+    # m:
+    # * i + 0 : hour
+    # * i + 1 : minute
+    # * i + 2 : second
+    # * i + 3 : sec fraction
+    # * i + 4 : meridian indicator
+    # * i + 5 : time zone
+    def self.add_parsed_time_parts(m, h, i=4)
+      hour = m[i].to_i
+      meridian = m[i+4]
+      hour = hour_with_meridian(hour, /a/io.match(meridian) ? :am : :pm) if meridian
+      offset = if m[i+5]
+        x = m[i+5].gsub(':','')
+        x == 'Z' ? 0 : x[0..2].to_i*3600 + x[3..4].to_i*60
+      else
+        Time.now.utc_offset
+      end
+      h.merge!(:parts=>[hour, m[i+1].to_i, m[i+2].to_i, (m[i+3].to_f/0.000001).to_i], :offset=>offset)
+      h
+    end
+    
+    def self.default_parser_hash
+      DEFAULT_PARSERS
+    end
+    
+    def self.default_parser_list
+      DEFAULT_PARSER_LIST
+    end
+
+    def self.hour_with_meridian(hour, meridian)
+      raise(ArgumentError, 'invalid date') unless hour and hour >= 1 and hour <= 12
+      if meridian == :am
+        hour == 12 ? 0 : hour
+      else
+        hour < 12 ? hour + 12 : hour 
+      end
+    end
+    
+    def self.new_from_parts(date_hash)
+      date_hash[:hour] = hour_with_meridian(date_hash[:hour], date_hash[:meridian]) if date_hash[:meridian]
+      d = now
+      weights = {:cwyear=>1, :year=>1, :cweek=>2, :cwday=>3, :yday=>3, :month=>2, :day=>3, :hour=>4, :min=>5, :sec=>6}
+      columns = {}
+      min = 7
+      max = 0
+      date_hash.each do |k,v|
+        if w = weights[k]
+          min = w if w < min
+          max = w if w > max
+        end
+      end
+      offset = date_hash[:offset] || d.offset
+      hour = date_hash[:hour] || (min > 4 ? d.hour : 0)
+      minute = date_hash[:min] || (min > 5 ? d.min : 0)
+      sec = date_hash[:sec] || 0
+      if date_hash[:jd]
+        jd(date_hash[:jd], hour, minute, sec, 0, offset)
+      elsif date_hash[:year] || date_hash[:yday] || date_hash[:month] || date_hash[:day] || !(date_hash[:cwyear] || date_hash[:cweek])
+        if date_hash[:yday]
+          ordinal(date_hash[:year]||d.year, date_hash[:yday], hour, minute, sec, 0, offset)
+        else
+          civil(date_hash[:year]||d.year, date_hash[:month]||(min > 2 ? d.mon : 1), date_hash[:day]||(min > 3 ? d.day : 1), hour, minute, sec, 0, offset)
+        end
+      elsif date_hash[:cwyear] || date_hash[:cweek] || date_hash[:cwday]
+        commercial(date_hash[:cwyear]||d.cwyear, date_hash[:cweek]||(min > 2 ? d.cweek : 1), date_hash[:cwday]||(min > 3 ? d.cwday : 1), hour, minute, sec, 0, offset)
+      else
+        raise ArgumentError, 'invalid date'
+      end
+    end
+    
+    def self.parser_hash
+      PARSERS
+    end
+    
+    def self.parser_list
+      PARSER_LIST
+    end
+    
+    def self.strptime_default
+      '%Y-%m-%dT%H:%M:%S'
+    end
+    
+    private_class_method :_expand_strptime_format, :_strptime_part, :add_parsed_time_parts, :default_parser_hash, :default_parser_list, :new_from_parts, :parser_hash, :parser_list, :strptime_default
+    
+    reset_parsers!
+    
+    # Instance Methods
+    
+    # This datetime's offset from UTC, in seconds.
+    attr_reader :offset
+    alias utc_offset offset
+    
+    # Called by DateTime.new!, should be a hash with the following possible keys:
+    #
+    # * :civil, :commericial, :jd, :ordinal : See ThirdBase::Date#initialize
+    # * :fract : The fraction of the day (0.5 is Noon)
+    # * :offset : offset from UTC, in seconds.
+    # * :parts : an array with 4 elements, hour, minute, second, and microsecond
+    #
+    # Raises an ArgumentError if an invalid date is used.  DateTime objects are immutable once created.
+    def initialize(opts)
+      @offset = opts[:offset]
+      raise(ArgumentError, 'invalid datetime') unless @offset.is_a?(Integer) and @offset <= 43200 and @offset >= -43200
+      if opts[:parts]
+        @hour, @min, @sec, @usec = opts[:parts]
+        raise(ArgumentError, 'invalid datetime') unless @hour.is_a?(Integer) and @min.is_a?(Integer) and @sec.is_a?(Integer) and @usec.is_a?(Integer)
+      elsif opts[:fract]
+        @fract = opts[:fract]
+        raise(ArgumentError, 'invalid datetime') unless @fract.is_a?(Float) and @fract < 1.0 and @fract >= 0.0
+      else
+        raise(ArgumentError, 'invalid datetime')
+      end
+      super(opts)
+    end
+    
+    # Return a new datetune with the given number of days added to this datetime.  If d is a Float
+    # adds a fractional date, with possible loss of precision.  If d is an integer, 
+    # the returned date has the same time components as the current date. In both
+    # cases, the offset for the new date is the same as for this date.
+    def +(d)
+      case d
+      when Float
+        d, f = d.to_f.divmod(1)
+        f = fract + f
+        m, f = f.divmod(1)
+        self.class.jd_fract(jd+d+m, f, @offset)
+      when Integer
+        new_jd(jd+d)
+      else
+        raise(TypeError, "d must be a Float or Integer")
+      end
+    end
+    
+    # Return a new datetune with the given number of days subtracted from this datetime.
+    # If d is a DateTime, returns the difference between the two datetimes as a Float,
+    # considering both datetimes date, time, and offest.
+    def -(d)
+      case d
+      when self.class
+        (jd - d.jd) + (fract - d.fract) + (@offset - d.offset)/86400.0
+      when Integer, Float
+        self + -d
+      else
+        raise TypeError, "d should be #{self.class}, Float, or Integer"
+      end
+    end
+    
+    # Compares two datetimes.  If the given datetime is an Integer, returns 1 unless
+    # this datetime's time components are all 0, in which case it returns 0.
+    # If the given datetime is a Float, calculates this date's julian date plus the
+    # date fraction and compares it to the given datetime, and returns 0 only if the
+    # two are very close together. This code does not take into account time offsets.
+    def <=>(datetime)
+      case datetime
+      when Integer
+        if ((d = (jd <=> datetime)) == 0)
+          (hour == 0 and min == 0 and sec == 0 and usec == 0) ? 0 : 1
+        else
+          d
+        end
+      when Float
+        diff = jd+fract - datetime
+        if diff.abs <= 1.15740740740741e-011
+          0
+        else
+          diff > 0.0 ? 1 : -1
+        end
+      when self.class
+        ((d = super) == 0) && ((d = (hour <=> datetime.hour)) == 0) && ((d = (min <=> datetime.min)) == 0) && ((d = (sec <=> datetime.sec)) == 0) && ((d = (usec <=> datetime.usec)) == 0)
+        d
+      else
+        raise TypeError, "d should be #{self.class}, Float, or Integer"
+      end
+    end
+    
+    # Two DateTimes are equal only if their dates and time components are the same, not counting the offset.
+    def ==(datetime)
+      return false unless DateTime === datetime
+      super and hour == datetime.hour and min == datetime.min and sec == datetime.sec and usec == datetime.usec 
+    end
+    alias_method :eql?, :==
+    
+    # Returns the fraction of the day for this datetime (Noon is 0.5)
+    def fract
+      @fract ||= (@hour*3600+@min*60+@sec+@usec/1000000.0)/86400.0
+    end
+    
+    # Returns the hour of this datetime.
+    def hour
+      @hour ||= time_parts[0]
+    end
+    
+    # Returns the minute of this datetime.
+    def min
+      @min ||= time_parts[1]
+    end
+    
+    # Returns the second of this datetime.
+    def sec
+      @sec ||= time_parts[2]
+    end
+    
+    # Returns the microsecond of this datetime.
+    def usec
+      @usec ||= time_parts[3]
+    end
+    
+    # Return the offset as a time zone string (+/-HHMM).
+    def zone
+      strftime('%z')
+    end
+    
+    private
+
+    def _strftime(v)
+      case v
+      when 'c' then strftime('%a %b %e %H:%M:%S %Y')
+      when 'H' then '%02d' %   hour
+      when 'I' then '%02d' % ((hour % 12).nonzero? or 12)
+      when 'k' then '%2d'  % hour
+      when 'l' then '%2d'  % ((hour % 12).nonzero? or 12)
+      when 'M' then '%02d' % min
+      when 'P' then hour < 12 ? 'am' : 'pm'
+      when 'p' then hour < 12 ? 'AM' : 'PM'
+      when 'R' then strftime('%H:%M')
+      when 'r' then strftime('%I:%M:%S %p')
+      when 'S' then '%02d' % sec
+      when 's' then '%d' % ((jd - UNIXEPOCH)*86400 + hour*3600 + min*60 + sec - @offset)
+      when 'T', 'X' then strftime('%H:%M:%S')
+      when '+' then strftime('%a %b %e %H:%M:%S %z %Y')
+      when 'Z' then @offset == 0 ? 'Z' : _strftime('z')
+      when 'z' then "%+03d:%02d" % (@offset/60).divmod(60)
+      else super(v)
+      end
+    end
+    
+    def fract_to_hmsu(p)
+      hour, p = (p.to_f*24).divmod(1)
+      min, p = (p*60).divmod(1)
+      sec, sec_fract = (p*60).divmod(1)
+      [hour, min, sec, (sec_fract*1000000).to_i]
+    end
+    
+    def new_civil(y, m, d)
+      self.class.new(y, m, d, hour, min, sec, usec, @offset)
+    end
+    
+    def new_jd(j)
+      self.class.jd(j, hour, min, sec, usec, @offset)
+    end
+
+    def strftime_default
+      '%Y-%m-%dT%H:%M:%S%z'
+    end
+    
+    def time_parts
+      unless @hour && @min && @sec && @usec
+        @hour, @min, @sec, @usec = fract_to_hmsu(fract)
+      end
+      [@hour, @min, @sec, @usec]
+    end
+  end
+end

data/lib/third_base.rb

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'third_base/datetime'

data/spec/compat/compat_class_methods_spec.rb

@@ -0,0 +1,208 @@
+require(File.join(File.dirname(__FILE__), '..', 'compat_spec_helper'))
+
+describe ThirdBase::CompatClassMethods do
+  it "#new0 should be the same as new!" do
+    Date.new0(:jd=>2454156).should == Date.new!(:jd=>2454156)
+  end
+
+  it "#new1 should be the same as jd" do
+    Date.new1(2454156).should == Date.jd(2454156)
+  end
+
+  it "#new2 should be the same as ordinal" do
+    Date.new2(2008, 10).should == Date.ordinal(2008, 10)
+  end
+
+  it "#new3 should be the same as new" do
+    Date.new3(2008, 10, 2).should == Date.new(2008, 10, 2)
+  end
+
+  it "#neww should be the same as commercial" do
+    Date.neww(2008, 10, 2).should == Date.commercial(2008, 10, 2)
+  end
+
+  it "#_parse should parse the date string and return a hash" do
+    Date._parse('2008-10-20 11:12:13-08:00').should == {:mon=>10, :zone=>'-08:00', :sec=>13, :sec_fraction=>0.0, :year=>2008, :hour=>11, :offset=>-28800, :mday=>20, :min=>12}
+    Date._parse('2008-10-20 11:12:13-08:00', true).should == {:mon=>10, :zone=>'-08:00', :sec=>13, :sec_fraction=>0.0, :year=>2008, :hour=>11, :offset=>-28800, :mday=>20, :min=>12}
+  end
+
+  it "#ajd_to_amjd should convert a astronomical julian date to a astronomical modified julian date" do
+    Date.ajd_to_amjd(2400002).should == 1
+  end
+
+  it "#ajd_to_amjd should convert a astronomical julian date to a julian date" do
+    Date.ajd_to_jd(1).should == 1
+    Date.ajd_to_jd(1, 1).should == 1
+  end
+
+  it "#amjd_to_amd should convert a astronomical modified julian date to a astronomical julian date" do
+    Date.amjd_to_ajd(1).should == 2400002
+  end
+
+  it "#civil_to_jd should convert a civil date into a Julian day number" do
+    Date.civil_to_jd(2007, 2, 24).should == 2454156
+    Date.civil_to_jd(2007, 2, 24, 1).should == 2454156
+  end
+
+  it "#commercial_to_jd should convert a commercial date (year - week - day of week) into a Julian day number" do
+    Date.commercial_to_jd(2007, 45, 1).should == 2454410
+    Date.commercial_to_jd(2007, 45, 1, 1).should == 2454410
+  end
+
+  it "#day_fraction_to_time should convert a fraction of a day to an array of time parts" do
+    Date.day_fraction_to_time(0.5).should == [12, 0, 0, 0.0]
+  end
+
+  it "#gregorian? should return whether the first argument is greater than the second" do
+    Date.gregorian?(1, 1).should == false
+    Date.gregorian?(2, 1).should == true
+  end
+
+  it "#ns? should be the same as gregorian?" do
+    Date.ns?(2, 1).should == Date.gregorian?(2, 1)
+  end
+
+  it "#leap? should determine whether a year is a leap year" do
+    Date.leap?(1900).should == false
+    Date.leap?(1901).should == false
+    Date.leap?(1899).should == false
+    Date.leap?(1904).should == true
+    Date.leap?(1896).should == true
+    Date.leap?(1999).should == false
+    Date.leap?(2001).should == false
+    Date.leap?(2000).should == true
+  end
+
+  it "#gregorian_leap? should be the same as leap?" do
+    Date.gregorian_leap?(2000).should == Date.leap?(2000)
+  end
+
+  it "#jd_to_ajd should convert a Julian day into a astronomical julian date" do
+    Date.jd_to_ajd(2454156, 0).should == 2454156
+    Date.jd_to_ajd(2454156, 1, 1).should == 2454156
+  end
+
+  it "#jd_to_civil should convert a Julian day into a civil date" do
+    Date.jd_to_civil(2454156).should == [2007, 2, 24]
+    Date.jd_to_civil(2454156, 1).should == [2007, 2, 24]
+  end
+
+  it "#jd_to_commercial should convert a Julian day number into a commercial date" do
+    Date.jd_to_commercial(2454410).should == [2007, 45, 1]
+    Date.jd_to_commercial(2454410, 1).should == [2007, 45, 1]
+  end
+
+  it "#jd_to_ld should convert a Julian day into a number of days since italian calendar reform day" do
+    Date.jd_to_ld(2299161).should == 1
+  end
+
+  it "#jd_to_mjd should convert a Julian day into a modified julian date" do
+    Date.jd_to_mjd(2400002).should == 1
+  end
+
+  it "#jd_to_ordinal should convert a Julian day number into an ordinal date" do
+    Date.jd_to_ordinal(2454156).should == [2007, 55]
+    Date.jd_to_ordinal(2454156, 1).should == [2007, 55]
+  end
+
+  it "#jd_to_wday should be able to convert a Julian day number into a week day number" do
+    Date.jd_to_wday(2454482).should == 3
+  end
+
+  it "#julian? should return whether the first argument is less than the second" do
+    Date.julian?(1, 1).should == false
+    Date.julian?(1, 2).should == true
+  end
+
+  it "#os? should be the same as julian?" do
+    Date.os?(1, 2).should == Date.julian?(1, 2)
+  end
+
+  it "#julian leap? should determine whether a year is a leap year in the julian calendar" do
+    Date.julian_leap?(1900).should == true
+    Date.julian_leap?(1901).should == false
+    Date.julian_leap?(1899).should == false
+    Date.julian_leap?(1904).should == true
+    Date.julian_leap?(1896).should == true
+    Date.julian_leap?(1999).should == false
+    Date.julian_leap?(2001).should == false
+    Date.julian_leap?(2000).should == true
+  end
+
+  it "#ld_to_jd should convert a number of days since italian calendar reform day to a julian date" do
+    Date.ld_to_jd(1).should == 2299161
+  end
+
+  it "#mjd_to_jd should convert a modified julian date into a julian date" do
+    Date.mjd_to_jd(1).should == 2400002
+  end
+
+  it "#ordinal_to_jd should convert an ordinal date (year-day) to a Julian day number" do
+    Date.ordinal_to_jd(2007, 55).should == 2454156
+  end
+
+  it "#time_to_day_fraction should convert time parts to a fraction" do
+    Date.time_to_day_fraction(12, 0, 0).should == 0.5
+  end
+
+  it "#valid_civil? should return corresponding julian date if valid and nil if not" do
+    Date.valid_civil?(2007, 2, 24).should == 2454156
+    Date.valid_civil?(2007, 2, 24, 1).should == 2454156
+    Date.valid_civil?(2007, 2, 30, 1).should == nil
+  end
+
+  it "#valid_date? should be the same as valid_civil?" do
+    Date.valid_date?(2007, 2, 24, 1).should == Date.valid_civil?(2007, 2, 24, 1)
+  end
+
+  it "#exist? should be the same as valid_date?" do
+    Date.exist?(2007, 2, 24, 1).should == Date.valid_date?(2007, 2, 24, 1)
+  end
+
+  it "#exist3? should be the same as valid_date?" do
+    Date.exist3?(2007, 2, 24, 1).should == Date.valid_date?(2007, 2, 24, 1)
+  end
+
+  it "#valid_commercial? should return corresponding julian date if valid and nil if not" do
+    Date.valid_commercial?(2007, 45, 1).should == 2454410
+    Date.valid_commercial?(2007, 45, 1, 1).should == 2454410
+    Date.valid_commercial?(2007, 54, 1, 1).should == nil
+  end
+
+  it "#existw? should be the same as valid_date?" do
+    Date.existw?(2007, 45, 1, 1).should == Date.valid_commercial?(2007, 45, 1, 1)
+  end
+
+  it "#valid_jd? should return the given julian date" do
+    Date.valid_jd?(2454156).should == 2454156
+    Date.valid_jd?(2454156, 1).should == 2454156
+  end
+
+  it "#exist1? should be the same as valid_jd?" do
+    Date.exist1?(2454156, 1).should == Date.valid_jd?(2454156, 1)
+  end
+
+  it "#valid_ordinal? should return corresponding julian date if valid and nil if not" do
+    Date.valid_ordinal?(2007, 55).should == 2454156
+    Date.valid_ordinal?(2007, 55, 1).should == 2454156
+    Date.valid_ordinal?(2007, 367, 1).should == nil
+  end
+
+  it "#exist2? should be the same as valid_ordinal?" do
+    Date.exist2?(2007, 55, 1).should == Date.valid_ordinal?(2007, 55)
+  end
+
+  it "#valid_time? should return corresponding day fraction if valid and nil if not" do
+    Date.valid_time?(12, 0, 0).should == 0.5
+    Date.valid_time?(25, 0, 0).should == nil
+    Date.valid_time?(12, 61, 0).should == nil
+    Date.valid_time?(12, 0, 61).should == nil
+  end
+
+  it "#zone_to_diff? should return the offset in seconds if a valid time zone, or 0 if not" do
+    Date.zone_to_diff('-0800').should == -28800
+    Date.zone_to_diff('+08:00').should == 28800
+    Date.zone_to_diff('YY').should == 0
+  end
+
+end

data/spec/compat/compat_instance_methods_spec.rb

@@ -0,0 +1,54 @@
+require(File.join(File.dirname(__FILE__), '..', 'compat_spec_helper'))
+
+describe ThirdBase::CompatInstanceMethods do
+  before do
+    @d = Date.civil(2008, 10, 11)
+  end
+
+  it "#ajd should be the same as jd" do
+    @d.ajd.should == @d.jd
+  end
+
+  it "#amjd should be the astronomical modified julian date" do
+    @d.amjd.should == 54750
+  end
+
+  it "#gregorian, #england, #julian, #italy, #new_start, and #newsg should be the same as self" do
+    @d.gregorian.should == @d
+    @d.england.should == @d
+    @d.julian.should == @d
+    @d.italy.should == @d
+    @d.new_start.should == @d
+    @d.newsg.should == @d
+    @d.new_start(1).should == @d
+    @d.newsg(1).should == @d
+  end
+
+  it "#gregorian? and ns? should be true" do
+    @d.gregorian?.should == true
+    @d.ns?.should == true
+  end
+
+  it "#julian? and os? should be false" do
+    @d.julian?.should == false
+    @d.os?.should == false
+  end
+
+  it "#ld should be the days since italian calendar reform day" do
+    @d.ld.should == 155591
+  end
+
+  it "#mday should be the same as day" do
+    @d.mday.should == @d.day
+  end
+
+  it "#mjd should be the modified julian date" do
+    @d.mjd.should == 54750
+  end
+
+  it "#start and #sg should equal 0" do
+    @d.start.should == 0
+    @d.sg.should == 0
+  end
+
+end