third_base 1.2.0 → 1.3.0

data/lib/third_base/compat.rb

@@ -1,402 +1,13 @@
 #!/usr/bin/env ruby
-require 'third_base'
 
 Object.send(:remove_const, :Date) if Object.const_get(:Date) rescue nil
 Object.send(:remove_const, :DateTime) if Object.const_get(:DateTime) rescue nil
   
-module ThirdBase
-  MJD_JD    =  2400001 
-  LD_JD     =  2299160
-  ITALY     =  2299161
-  ENGLAND   =  2361222
-  JULIAN    = -100000000000000000000000000000000000
-  GREGORIAN =  100000000000000000000000000000000000
-  
-  # Compatibility class methods for Date and DateTime, necessary because ruby doesn't
-  # support multiple inheritance.
-  module CompatClassMethods
-    [ %w(os?	julian?),
-      %w(ns?	gregorian?),
-      %w(exist1?	valid_jd?),
-      %w(exist2?	valid_ordinal?),
-      %w(exist3?	valid_date?),
-      %w(exist?	valid_date?),
-      %w(existw?	valid_commercial?),
-      %w(new0	new!),
-      %w(new1	jd),
-      %w(new2	ordinal),
-      %w(new3	new),
-      %w(neww	commercial)
-    ].each{|old, new| module_eval("def #{old}(*args, &block); #{new}(*args, &block); end")}
-    
-    # Return the parts of the parsed date as a hash witht he following keys:
-    #
-    # * :hour : hour
-    # * :mday : day of month
-    # * :min : minute
-    # * :mon : month
-    # * :offset : time zone offset from UTC in seconds
-    # * :sec : second
-    # * :sec_fraction : fraction of a second
-    # * :year : year
-    # * :zone : time zone offset as string
-    def _parse(str, comp=false)
-      d = DateTime.parse(str)
-      {:mon=>d.mon, :zone=>d.zone, :sec=>d.sec, :year=>d.year, :hour=>d.hour, :offset=>d.utc_offset, :mday=>d.day, :min=>d.min, :sec_fraction=>d.usec/1000000.0}.reject{|k, v| d.not_parsed.include?(k)}
-    end
-    
-    # Converts an Astronomical Julian Date to an Astronomical Modified Julian Date (substracts an integer from ajd)
-    def ajd_to_amjd(ajd)
-      ajd - MJD_JD
-    end
-    
-    # Converts an Astronomical Julian Date to a Julian Date (returns ajd, ignores of)
-    def ajd_to_jd(ajd, of=0)
-      ajd
-    end
-    
-    # Converts an Astronomical Modified Julian Date to an Astronomical Julian Date (adds an integer to amjd)
-    def amjd_to_ajd(amjd)
-      amjd + MJD_JD
-    end
-    
-    # Returns the julian date for the given civil date arguments, ignores sg.
-    def civil_to_jd(year, mon, day, sg=nil)
-      civil(year, mon, day).jd
-    end
-    
-    # Returns the julian date for the given commercial date arguments, ignores sg.
-    def commercial_to_jd(cwyear, cweek, cwday, sg=nil)
-      commercial(cwyear, cweek, cwday).jd
-    end
-    
-    # Returns the fraction of the date as an array of hours, minutes, seconds, and fraction on a second.
-    def day_fraction_to_time(fr)
-      hours, fr = (fr * 24).divmod(1)
-      minutes, fr = (fr * 60).divmod(1)
-      seconds, sec_fract = (fr * 60).divmod(1)
-      [hours, minutes, seconds, sec_fract]
-    end
-    
-    # True if jd is greater than sg, false otherwise.
-    def gregorian?(jd, sg)
-      jd > sg
-    end
-    
-    # All years divisible by 4 are leap years in the Gregorian calendar,
-    # except for years divisible by 100 and not by 400.
-    def leap?(y)
-      y % 4 == 0 && y % 100 != 0 || y % 400 == 0
-    end
-    alias gregorian_leap? leap?
-    
-    # Converts a Julian Date to an Astronomical Julian Date (returns j, ignores fr and of)
-    def jd_to_ajd(j, fr, of=0)
-      j
-    end
-    
-    # Returns [year, month, day] for the given julian date, ignores sg.
-    def jd_to_civil(j, sg=nil)
-      jd(j).send(:civil)
-    end
-    
-    # Returns [cwyear, cweek, cwday] for the given julian date, ignores sg.
-    def jd_to_commercial(j, sg=nil)
-      jd(j).send(:commercial)
-    end
-    
-    # Converts a julian date to the number of days since the adoption of
-    # the gregorian calendar in Italy (subtracts an integer from j).
-    def jd_to_ld(j)
-      j - LD_JD
-    end
-    
-    # Convert a Julian Date to a Modified Julian Date (subtracts an integer from j).
-    def jd_to_mjd(j)
-      j - MJD_JD
-    end
-    
-    # Returns [year, yday] for the given julian date, ignores sg.
-    def jd_to_ordinal(j, sg=nil)
-      jd(j).send(:ordinal)
-    end
-    
-    # Returns the day of week for the given julian date.
-    def jd_to_wday(j)
-      jd(j).wday
-    end
-    
-    # Returns true if jd is less than sg, false otherwise.
-    def julian?(jd, sg)
-      jd < sg
-    end
-    
-    # All years divisible by 4 are leap years in the Julian calendar.
-    def julian_leap?(y)
-      y % 4 == 0
-    end
-    
-    # Converts a number of days since the adoption of the gregorian calendar in Italy
-    # to a julian date (adds an integer to ld).
-    def ld_to_jd(ld)
-      ld + LD_JD
-    end
-    
-    # Converts a Modified Julian Date to a Julian Date (adds an integer to mjd).
-    def mjd_to_jd(mjd)
-      mjd + MJD_JD
-    end
-    
-    # Converts the given year and day of year to a julian date, ignores sg.
-    def ordinal_to_jd(year, yday, sg=nil)
-      ordinal(year, yday).jd
-    end
-    
-    # Converts the given hour, minute, and second to a fraction of a day as a Float.
-    def time_to_day_fraction(h, min, s)
-      (h*3600 + min*60 + s)/86400.0
-    end
-    
-    # Return the julian date of the given year, month, and day if valid, or nil if not, ignores sg.
-    def valid_civil?(year, mon, day, sg=nil)
-      civil(year, mon, day).jd rescue nil
-    end
-    alias valid_date? valid_civil?
-    
-    # Return the julian date of the given commercial week year, commercial week, and commercial
-    # week day if valid, or nil if not, ignores sg.
-    def valid_commercial?(cwyear, cweek, cwday, sg=nil)
-      commercial(cwyear, cweek, cwday).jd rescue nil
-    end
-    
-    # Returns the julian date if valid (always returns jd, ignores sg).
-    def valid_jd?(jd, sg=nil)
-      jd
-    end
-    
-    # Return the julian date of the given year and day of year if valid, or nil if not, ignores sg.
-    def valid_ordinal?(year, yday, sg=nil)
-      ordinal(year, yday).jd rescue nil
-    end
-    
-    # Returns the fraction of the day if the time is valid, or nil if the time is not valid.
-    def valid_time?(h, min, s)
-      h   += 24 if h   < 0
-      min += 60 if min < 0
-      s   += 60 if s   < 0
-      return unless ((0..23) === h &&
-                     (0..59) === min &&
-                     (0..59) === s) ||
-                    (24 == h &&
-                      0 == min &&
-                      0 == s)
-      time_to_day_fraction(h, min, s)
-    end
-    
-    # Converts a time zone string to a offset from UTC in seconds.
-    def zone_to_diff(zone)
-      if m = /\A([+-](?:\d{4}|\d\d:\d\d))\z/.match(zone)
-        x = m[1].gsub(':','')
-        x[0..2].to_i*3600 + x[3..4].to_i*60
-      else
-        0
-      end
-    end
-  end
-  
-  # Compatibility instance methods for Date and DateTime, necessary because ruby doesn't
-  # support multiple inheritance.
-  module CompatInstanceMethods
-    # Returns the Astronomical Julian Date for this date (alias for jd)
-    def ajd
-      jd
-    end
-    
-    # Returns the Astronomical Modified Julian Date for this date (jd plus an integer)
-    def amjd
-      jd - MJD_JD
-    end
-    alias mjd amjd
-    
-    # Returns self.
-    def gregorian
-      self
-    end
-    alias england gregorian
-    alias julian gregorian
-    alias italy gregorian
-    
-    # True, since the gregorian calendar is always used.
-    def gregorian?
-      true
-    end
-    alias ns? gregorian?
-    
-    # False, since the gregorian calendar is never used.
-    def julian?
-      false
-    end
-    alias os? julian?
-    
-    # Returns the days since the date of the adoption of the gregorian calendar in Italy
-    # (substracts an integer from jd).
-    def ld
-      jd - LD_JD
-    end
-    
-    # Alias for day.
-    def mday
-      day
-    end
-    
-    # Returns self, ignores sg.
-    def new_start(sg=nil)
-      self
-    end
-    alias newsg new_start
-    
-    # Returns 0, since the gregorian calendar is always used.
-    def start
-      0
-    end
-    alias sg start
-  end
-
-  # ThirdBase's top level Date compatibility class, striving to be as close as possible
-  # to the standard Date class's API.
-  class ::Date < Date
-    extend CompatClassMethods
-    include CompatInstanceMethods
-    
-    # Parse the date using strptime with the given format.
-    def self._strptime(str, fmt='%F')
-      strptime(str, fmt)
-    end
-    
-    # Creates a new Date with the given year, month, and day of month, ignores sg.
-    def self.civil(year=-4712, mon=1, day=1, sg=nil)
-      super(year, mon, day)
-    end
-    
-    # Creates a new Date with the given commercial week year, commercial week, and commercial week day, ignores sg.
-    def self.commercial(cwyear=1582, cweek=41, cwday=5, sg=nil)
-      super(cwyear, cweek, cwday)
-    end
-    
-    # Creates a new Date with the given julian date, ignores sg.
-    def self.jd(j=0, sg=nil)
-      super(j)
-    end
-    
-    # Creates a new Date with the given year and day of year, ignores sg.
-    def self.ordinal(year=-4712, yday=1, sg=nil)
-      super(year, yday)
-    end
-    
-    # Parse given string using ThirdBase::Date's date parser, ignores comp and sg.
-    def self.parse(str="-4712-01-01", comp=false, sg=nil)
-      super(str)
-    end
-    
-    # Parse given string using given format, ignores sg.
-    def self.strptime(str="-4712-01-01", fmt='%F', sg=nil)
-      super(str, fmt)
-    end
-    
-    # Creates a new Date with today's date, ignores sg.
-    def self.today(sg=nil)
-      super()
-    end
-    
-    # Returns a formatted string representing the date.
-    def asctime
-      strftime('%a %b %e 00:00:00 %Y')
-    end
-    alias ctime asctime
-    
-    # Returns 0.0, since Date don't have fractional days.
-    def day_fraction
-      0.0
-    end
-  end
+require 'third_base/make_compat'
 
-  # ThirdBase's top level DateTime compatibility class, striving to be as close as possible
-  # to the standard DateTime class's API.
-  class ::DateTime < DateTime
-    extend CompatClassMethods
-    include CompatInstanceMethods
-    
-    # Parse the datetime using strptime with the given format.
-    def self._strptime(str, fmt='%FT%T%z')
-      strptime(str, fmt)
-    end
-    
-    # Creates a new DateTime with the given year, month, day of month, hour, minute, second, and offset, ignores sg.
-    def self.civil(year=-4712, mon=1, day=1, hour=0, min=0, sec=0, offset=0, sg=nil)
-      super(year, mon, day, hour, min, sec, 0, (offset*86400).to_i)
-    end
-    
-    # Creates a new DateTime with the given commercial week year, commercial week, commercial week day,
-    # hour, minute, second, and offset, ignores sg.
-    def self.commercial(cwyear=1582, cweek=41, cwday=5, hour=0, min=0, sec=0, offset=0, sg=nil)
-      super(cwyear, cweek, cwday, hour, min, sec, 0, (offset*86400).to_i)
-    end
-    
-    # Creates a new DateTime with the given julian date, hour, minute, second, and offset, ignores sg.
-    def self.jd(j=0, hour=0, min=0, sec=0, offset=0, sg=nil)
-      super(j, hour, min, sec, 0, (offset*86400).to_i)
-    end
-    
-    # Creates a new DateTime with the given year, day of year, hour, minute, second, and offset, ignores sg.
-    def self.ordinal(year=-4712, yday=1, hour=0, min=0, sec=0, offset=0, sg=nil)
-      super(year, yday, hour, min, sec, 0, (offset*86400).to_i)
-    end
-    
-    # Parse given string using ThirdBase::DateTime's date parser, ignores comp and sg.
-    def self.parse(str="-4712-01-01T00:00:00+00:00", comp=false, sg=nil)
-      super(str)
-    end
-    
-    # Parse given string using given format, ignores sg.
-    def self.strptime(str="-4712-01-01T00:00:00+00:00", fmt='%FT%T%z', sg=nil)
-      super(str, fmt)
-    end
-    
-    # Creates a new DateTime with the current date and time, ignores sg.
-    def self.now(sg=nil)
-      super()
-    end
-    
-    # Returns a formatted string representing the date.
-    def asctime
-      strftime('%c')
-    end
-    alias ctime asctime
-    
-    alias day_fraction fract
-    
-    # Returns a new DateTime with the same date and time as this datetime, but with a new offset.
-    def new_offset(offset=0)
-      self.class.new!(:civil=>civil, :parts=>time_parts, :offset=>(offset*86400).to_i)
-    end
-    alias newof new_offset
-    
-    # Return the offset as a Float representing the fraction of the day different from UTC.
-    def offset
-      @offset/86400.0
-    end
-    alias of offset
-    
-    # Return the offset as a number of seconds from UTC.
-    def offset_sec
-      @offset
-    end
-
-    # The fraction of a second represented as a fraction of the entire day.
-    def sec_fraction
-      usec/86400000000.0
-    end
-  end
+class Date < ThirdBase::Date
+end
+class DateTime < ThirdBase::DateTime
 end
 
 $:.unshift(File.join(File.dirname(__FILE__), 'compat'))

data/lib/third_base/date.rb

@@ -86,12 +86,11 @@ module ThirdBase
     
     UNIXEPOCH = 2440588
     
-    # Public Class Methods
-    
     class << self
       alias new! new
     end
     
+    module ClassMethods
     # Add a parser to the parser type. Arguments:
     # * type - The parser type to which to add the parser, should be a Symbol.
     # * pattern - Can be either a Regexp or String:
@@ -104,7 +103,7 @@ module ThirdBase
     # The block, if provided, should take a single MatchData argument.  It should return
     # nil if it cannot successfully parse the string, an instance of this class,  or a hash of
     # values to be passed to new!.
-    def self.add_parser(type, pattern, &block)
+    def add_parser(type, pattern, &block)
       if pattern.is_a?(String)
         pattern, blk = strptime_pattern_and_block(pattern)
         block ||= blk
@@ -117,33 +116,33 @@ module ThirdBase
     # Add a parser type to the list of parser types.
     # Should be used if you want to add your own parser
     # types.
-    def self.add_parser_type(type)
+    def add_parser_type(type)
       parser_hash[type] ||= []
     end
     
     # Returns a new Date with the given year, month, and day.
-    def self.civil(year, mon, day)
+    def civil(year, mon, day)
       new!(:civil=>[year, mon, day])
     end
     
     # Returns a new Date with the given commercial week year,
     # commercial week, and commercial week day.
-    def self.commercial(cwyear, cweek, cwday=5)
+    def commercial(cwyear, cweek, cwday=5)
       new!(:commercial=>[cwyear, cweek, cwday])
     end
     
     # Returns a new Date with the given julian date.
-    def self.jd(j)
+    def jd(j)
       new!(:jd=>j)
     end
     
     # Calls civil with the given arguments.
-    def self.new(*args)
+    def new(*args)
       civil(*args)
     end
     
     # Returns a new Date with the given year and day of year.
-    def self.ordinal(year, yday)
+    def ordinal(year, yday)
       new!(:ordinal=>[year, yday])
     end
     
@@ -153,7 +152,7 @@ module ThirdBase
     # * :parser_types : an array of parser types to use,
     #   overriding the default or the ones specified by
     #   use_parsers.
-    def self.parse(str, opts={})
+    def parse(str, opts={})
       s = str.strip
       parsers(opts[:parser_types]) do |pattern, block|
         if m = pattern.match(s)
@@ -166,7 +165,7 @@ module ThirdBase
     end
     
     # Reset the parsers, parser types, and order of parsers used to the default.
-    def self.reset_parsers!
+    def reset_parsers!
       parser_hash.clear
       default_parser_hash.each do |type, parsers|
         add_parser_type(type)
@@ -179,7 +178,7 @@ module ThirdBase
     
     # Parse the string using the provided format (or the default format).
     # Raises an ArgumentError if the format does not match the string.
-    def self.strptime(str, fmt=strptime_default)
+    def strptime(str, fmt=strptime_default)
       pattern, block = strptime_pattern_and_block(fmt)
       s = str.strip
       if m = pattern.match(s)
@@ -190,19 +189,19 @@ module ThirdBase
     end
 
     # Returns a date with the current year, month, and date.
-    def self.today
+    def today
       t = Time.now
       civil(t.year, t.mon, t.day)
     end
     
     # Set the order of parser types to use to the given parser types.
-    def self.use_parsers(*parsers)
+    def use_parsers(*parsers)
       parser_list.replace(parsers)
     end
     
-    # Private Class Methods
+    private
     
-    def self._expand_strptime_format(v)
+    def _expand_strptime_format(v)
       case v
       when '%D', '%x' then '%m/%d/%y'
       when '%F' then '%Y-%m-%d'
@@ -211,7 +210,7 @@ module ThirdBase
       end
     end
 
-    def self._strptime_part(v)
+    def _strptime_part(v)
       case v
       when 'A' then [FULL_DAYNAME_RE_PATTERN, STRPTIME_PROC_A]
       when 'a' then [ABBR_DAYNAME_RE_PATTERN, STRPTIME_PROC_A]
@@ -235,19 +234,19 @@ module ThirdBase
       end
     end
     
-    def self.default_parser_hash
+    def default_parser_hash
       DEFAULT_PARSERS
     end
     
-    def self.default_parser_list
+    def default_parser_list
       DEFAULT_PARSER_LIST
     end
     
-    def self.expand_strptime_format(fmt)
+    def expand_strptime_format(fmt)
       fmt.gsub(STRFTIME_RE){|x| _expand_strptime_format(x)}
     end
     
-    def self.new_from_parts(date_hash)
+    def new_from_parts(date_hash)
       d = today
       if date_hash[:year] || date_hash[:yday] || date_hash[:month] || date_hash[:day]
         if date_hash[:yday]
@@ -262,15 +261,15 @@ module ThirdBase
       end
     end
     
-    def self.parser_hash
+    def parser_hash
       PARSERS
     end
     
-    def self.parser_list
+    def parser_list
       PARSER_LIST
     end
     
-    def self.parsers(parser_families=nil)
+    def parsers(parser_families=nil)
       (parser_families||parser_list).each do |parser_family|
         parsers_for_family(parser_family) do |pattern, block|
           yield(pattern, block)
@@ -278,17 +277,17 @@ module ThirdBase
       end
     end
     
-    def self.parsers_for_family(parser_family)
+    def parsers_for_family(parser_family)
       parser_hash[parser_family].each do |pattern, block|
         yield(pattern, block)
       end
     end
     
-    def self.strptime_default
+    def strptime_default
       '%Y-%m-%d'
     end
     
-    def self.strptime_pattern_and_block(fmt)
+    def strptime_pattern_and_block(fmt)
       blocks = []
       pattern = Regexp.escape(expand_strptime_format(fmt)).gsub(STRFTIME_RE) do |x|
         pat, *blks = _strptime_part(x[1..1])
@@ -305,7 +304,7 @@ module ThirdBase
       [/\A#{pattern}\z/i, block]
     end
     
-    def self.two_digit_year(y)
+    def two_digit_year(y)
       y = if y.length == 2
         y = y.to_i
         (y < 69 ? 2000 : 1900) + y
@@ -313,13 +312,12 @@ module ThirdBase
         y.to_i
       end
     end
-    
-    private_class_method :_expand_strptime_format, :_strptime_part, :default_parser_hash, :default_parser_list, :expand_strptime_format, :new_from_parts, :parser_hash, :parser_list, :parsers, :parsers_for_family, :strptime_default, :strptime_pattern_and_block, :two_digit_year
+    end
+    extend ClassMethods
     
     reset_parsers!
     
-    # Public Instance Methods
-    
+    module InstanceMethods
     # Called by Date.new!, Takes a hash with one of the following keys:
     #
     # * :civil : should be an array with 3 elements, a year, month, and day
@@ -407,7 +405,10 @@ module ThirdBase
       return false unless Date === date
       year == date.year and mon == date.mon and day == date.day
     end
-    alias_method :eql?, :==
+    
+    def eql?(date)
+      self == date
+    end
     
     # If d is a date, only true if it is equal to this date.  If d is Numeric, only true if it equals this date's julian date.
     def ===(d)
@@ -693,4 +694,6 @@ module ThirdBase
       CUMMULATIVE_MONTH_DAYS[mon] + day + ((month > 2 and leap?) ? 1 : 0)
     end
   end
+  include InstanceMethods
+  end
 end

data/lib/third_base/datetime.rb

@@ -4,6 +4,8 @@ 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
+    PARSERS = {}
+    UNIXEPOCH = ThirdBase::Date::UNIXEPOCH
     TIME_ZONE_SECOND_OFFSETS = {
       'UTC'=>0, 'Z'=>0, 'UT'=>0, 'GMT'=>0,
       'EST'=>-18000, 'EDT'=>-14400, 'CST'=>-21600, 'CDT'=>-18000, 'MST'=>-25200, 'MDT'=>-21600, 'PST'=>-28800, 'PDT'=>-25200,
@@ -27,7 +29,7 @@ module ThirdBase
       [%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)}],
-      [%r{\A#{ABBR_DAYNAME_RE_PATTERN} #{ABBR_MONTHNAME_RE_PATTERN} (\d\d?) #{TIME_RE_STRING} (-?\d{4})\z}io, proc{|m| add_parsed_time_parts(m, {:civil=>[m[10].to_i, MONTH_NUM_MAP[m[2].downcase], m[3].to_i]})}]]
+      [%r{\A#{ABBR_DAYNAME_RE_PATTERN} #{ABBR_MONTHNAME_RE_PATTERN} +(\d\d?) #{TIME_RE_STRING} (-?\d{4})\z}io, proc{|m| add_parsed_time_parts(m, {:civil=>[m[10].to_i, MONTH_NUM_MAP[m[2].downcase], m[3].to_i]})}]]
     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|
@@ -66,43 +68,42 @@ module ThirdBase
     end
     STRPTIME_PROC_z = proc{|h,x| h[:offset] = convert_parsed_offset(x)}
     
-    # Public Class Methods
-    
+    module ClassMethods
     # 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)
+    def 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)
+    def 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)
+    def 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)
+    def 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
+    def 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)
+    def 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
+    private
     
-    def self._expand_strptime_format(v)
+    def _expand_strptime_format(v)
       case v
       when '%c' then '%a %b %e %H:%M:%S %Y'
       when '%T', '%X' then '%H:%M:%S'
@@ -113,7 +114,7 @@ module ThirdBase
       end
     end
     
-    def self._strptime_part(v)
+    def _strptime_part(v)
       case v
       when 'H', 'I' then ['(\d\d)', STRPTIME_PROC_H]
       when 'k', 'l' then ['(\d?\d)', STRPTIME_PROC_H]
@@ -133,7 +134,7 @@ module ThirdBase
     # * i + 3 : sec fraction
     # * i + 4 : meridian indicator
     # * i + 5 : time zone
-    def self.add_parsed_time_parts(m, h, i=4)
+    def add_parsed_time_parts(m, h, i=4)
       not_parsed = h[:not_parsed] || []
       hour = m[i].to_i
       meridian = m[i+4]
@@ -155,15 +156,15 @@ module ThirdBase
       h
     end
     
-    def self.default_parser_hash
+    def default_parser_hash
       DEFAULT_PARSERS
     end
     
-    def self.default_parser_list
+    def default_parser_list
       DEFAULT_PARSER_LIST
     end
 
-    def self.hour_with_meridian(hour, meridian)
+    def hour_with_meridian(hour, meridian)
       raise(ArgumentError, 'invalid date') unless hour and hour >= 1 and hour <= 12
       if meridian == :am
         hour == 12 ? 0 : hour
@@ -172,7 +173,7 @@ module ThirdBase
       end
     end
     
-    def self.new_from_parts(date_hash)
+    def new_from_parts(date_hash)
       not_parsed = [:hour, :min, :sec].reject{|x| date_hash.has_key?(x)}
       not_parsed.concat([:zone, :offset]) unless date_hash.has_key?(:offset)
       not_parsed << :year unless date_hash.has_key?(:year) || date_hash.has_key?(:cwyear)
@@ -212,7 +213,7 @@ module ThirdBase
       end
     end
 
-    def self.convert_parsed_offset(of)
+    def convert_parsed_offset(of)
       if offset = TIME_ZONE_SECOND_OFFSETS[of.upcase]
         offset
       else
@@ -221,24 +222,23 @@ module ThirdBase
       end
     end
     
-    def self.parser_hash
+    def parser_hash
       PARSERS
     end
     
-    def self.parser_list
+    def parser_list
       PARSER_LIST
     end
     
-    def self.strptime_default
+    def strptime_default
       '%Y-%m-%dT%H:%M:%S'
     end
-    
-    private_class_method :_expand_strptime_format, :_strptime_part, :add_parsed_time_parts, :convert_parsed_offset, :default_parser_hash, :default_parser_list, :new_from_parts, :parser_hash, :parser_list, :strptime_default
+    end
+    extend ClassMethods
     
     reset_parsers!
     
-    # Instance Methods
-    
+    module InstanceMethods
     # This datetime's offset from UTC, in seconds.
     attr_reader :offset
     alias utc_offset offset
@@ -335,8 +335,11 @@ module ThirdBase
       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?, :==
     
+    def eql?(datetime)
+      self == datetime
+    end
+
     # 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
@@ -417,4 +420,6 @@ module ThirdBase
       [@hour, @min, @sec, @usec]
     end
   end
+  include InstanceMethods
+  end
 end

data/lib/third_base/make_compat.rb

@@ -0,0 +1,411 @@
+#!/usr/bin/env ruby
+require 'third_base'
+
+module ThirdBase
+  MJD_JD    =  2400001 
+  LD_JD     =  2299160
+  ITALY     =  2299161
+  ENGLAND   =  2361222
+  JULIAN    = -100000000000000000000000000000000000
+  GREGORIAN =  100000000000000000000000000000000000
+  
+  # Compatibility class methods for Date and DateTime, necessary because ruby doesn't
+  # support multiple inheritance.
+  module CompatClassMethods
+    [ %w(os?	julian?),
+      %w(ns?	gregorian?),
+      %w(exist1?	valid_jd?),
+      %w(exist2?	valid_ordinal?),
+      %w(exist3?	valid_date?),
+      %w(exist?	valid_date?),
+      %w(existw?	valid_commercial?),
+      %w(new0	new!),
+      %w(new1	jd),
+      %w(new2	ordinal),
+      %w(new3	new),
+      %w(neww	commercial)
+    ].each{|old, new| module_eval("def #{old}(*args, &block); #{new}(*args, &block); end")}
+    
+    # Return the parts of the parsed date as a hash witht he following keys:
+    #
+    # * :hour : hour
+    # * :mday : day of month
+    # * :min : minute
+    # * :mon : month
+    # * :offset : time zone offset from UTC in seconds
+    # * :sec : second
+    # * :sec_fraction : fraction of a second
+    # * :year : year
+    # * :zone : time zone offset as string
+    def _parse(str, comp=false)
+      d = DateTime.parse(str)
+      {:mon=>d.mon, :zone=>d.zone, :sec=>d.sec, :year=>d.year, :hour=>d.hour, :offset=>d.utc_offset, :mday=>d.day, :min=>d.min, :sec_fraction=>d.usec/1000000.0}.reject{|k, v| d.not_parsed.include?(k)}
+    end
+    
+    # Converts an Astronomical Julian Date to an Astronomical Modified Julian Date (substracts an integer from ajd)
+    def ajd_to_amjd(ajd)
+      ajd - MJD_JD
+    end
+    
+    # Converts an Astronomical Julian Date to a Julian Date (returns ajd, ignores of)
+    def ajd_to_jd(ajd, of=0)
+      ajd
+    end
+    
+    # Converts an Astronomical Modified Julian Date to an Astronomical Julian Date (adds an integer to amjd)
+    def amjd_to_ajd(amjd)
+      amjd + MJD_JD
+    end
+    
+    # Returns the julian date for the given civil date arguments, ignores sg.
+    def civil_to_jd(year, mon, day, sg=nil)
+      civil(year, mon, day).jd
+    end
+    
+    # Returns the julian date for the given commercial date arguments, ignores sg.
+    def commercial_to_jd(cwyear, cweek, cwday, sg=nil)
+      commercial(cwyear, cweek, cwday).jd
+    end
+    
+    # Returns the fraction of the date as an array of hours, minutes, seconds, and fraction on a second.
+    def day_fraction_to_time(fr)
+      hours, fr = (fr * 24).divmod(1)
+      minutes, fr = (fr * 60).divmod(1)
+      seconds, sec_fract = (fr * 60).divmod(1)
+      [hours, minutes, seconds, sec_fract]
+    end
+    
+    # True if jd is greater than sg, false otherwise.
+    def gregorian?(jd, sg)
+      jd > sg
+    end
+    
+    # All years divisible by 4 are leap years in the Gregorian calendar,
+    # except for years divisible by 100 and not by 400.
+    def leap?(y)
+      y % 4 == 0 && y % 100 != 0 || y % 400 == 0
+    end
+    alias gregorian_leap? leap?
+    
+    # Converts a Julian Date to an Astronomical Julian Date (returns j, ignores fr and of)
+    def jd_to_ajd(j, fr, of=0)
+      j
+    end
+    
+    # Returns [year, month, day] for the given julian date, ignores sg.
+    def jd_to_civil(j, sg=nil)
+      jd(j).send(:civil)
+    end
+    
+    # Returns [cwyear, cweek, cwday] for the given julian date, ignores sg.
+    def jd_to_commercial(j, sg=nil)
+      jd(j).send(:commercial)
+    end
+    
+    # Converts a julian date to the number of days since the adoption of
+    # the gregorian calendar in Italy (subtracts an integer from j).
+    def jd_to_ld(j)
+      j - LD_JD
+    end
+    
+    # Convert a Julian Date to a Modified Julian Date (subtracts an integer from j).
+    def jd_to_mjd(j)
+      j - MJD_JD
+    end
+    
+    # Returns [year, yday] for the given julian date, ignores sg.
+    def jd_to_ordinal(j, sg=nil)
+      jd(j).send(:ordinal)
+    end
+    
+    # Returns the day of week for the given julian date.
+    def jd_to_wday(j)
+      jd(j).wday
+    end
+    
+    # Returns true if jd is less than sg, false otherwise.
+    def julian?(jd, sg)
+      jd < sg
+    end
+    
+    # All years divisible by 4 are leap years in the Julian calendar.
+    def julian_leap?(y)
+      y % 4 == 0
+    end
+    
+    # Converts a number of days since the adoption of the gregorian calendar in Italy
+    # to a julian date (adds an integer to ld).
+    def ld_to_jd(ld)
+      ld + LD_JD
+    end
+    
+    # Converts a Modified Julian Date to a Julian Date (adds an integer to mjd).
+    def mjd_to_jd(mjd)
+      mjd + MJD_JD
+    end
+    
+    # Converts the given year and day of year to a julian date, ignores sg.
+    def ordinal_to_jd(year, yday, sg=nil)
+      ordinal(year, yday).jd
+    end
+    
+    # Converts the given hour, minute, and second to a fraction of a day as a Float.
+    def time_to_day_fraction(h, min, s)
+      (h*3600 + min*60 + s)/86400.0
+    end
+    
+    # Return the julian date of the given year, month, and day if valid, or nil if not, ignores sg.
+    def valid_civil?(year, mon, day, sg=nil)
+      civil(year, mon, day).jd rescue nil
+    end
+    alias valid_date? valid_civil?
+    
+    # Return the julian date of the given commercial week year, commercial week, and commercial
+    # week day if valid, or nil if not, ignores sg.
+    def valid_commercial?(cwyear, cweek, cwday, sg=nil)
+      commercial(cwyear, cweek, cwday).jd rescue nil
+    end
+    
+    # Returns the julian date if valid (always returns jd, ignores sg).
+    def valid_jd?(jd, sg=nil)
+      jd
+    end
+    
+    # Return the julian date of the given year and day of year if valid, or nil if not, ignores sg.
+    def valid_ordinal?(year, yday, sg=nil)
+      ordinal(year, yday).jd rescue nil
+    end
+    
+    # Returns the fraction of the day if the time is valid, or nil if the time is not valid.
+    def valid_time?(h, min, s)
+      h   += 24 if h   < 0
+      min += 60 if min < 0
+      s   += 60 if s   < 0
+      return unless ((0..23) === h &&
+                     (0..59) === min &&
+                     (0..59) === s) ||
+                    (24 == h &&
+                      0 == min &&
+                      0 == s)
+      time_to_day_fraction(h, min, s)
+    end
+    
+    # Converts a time zone string to a offset from UTC in seconds.
+    def zone_to_diff(zone)
+      if m = /\A([+-](?:\d{4}|\d\d:\d\d))\z/.match(zone)
+        x = m[1].gsub(':','')
+        x[0..2].to_i*3600 + x[3..4].to_i*60
+      else
+        0
+      end
+    end
+  end
+  
+  # Compatibility instance methods for Date and DateTime, necessary because ruby doesn't
+  # support multiple inheritance.
+  module CompatInstanceMethods
+    # Returns the Astronomical Julian Date for this date (alias for jd)
+    def ajd
+      jd
+    end
+    
+    # Returns the Astronomical Modified Julian Date for this date (jd plus an integer)
+    def amjd
+      jd - MJD_JD
+    end
+    alias mjd amjd
+    
+    # Returns self.
+    def gregorian
+      self
+    end
+    alias england gregorian
+    alias julian gregorian
+    alias italy gregorian
+    
+    # True, since the gregorian calendar is always used.
+    def gregorian?
+      true
+    end
+    alias ns? gregorian?
+    
+    # False, since the gregorian calendar is never used.
+    def julian?
+      false
+    end
+    alias os? julian?
+    
+    # Returns the days since the date of the adoption of the gregorian calendar in Italy
+    # (substracts an integer from jd).
+    def ld
+      jd - LD_JD
+    end
+    
+    # Alias for day.
+    def mday
+      day
+    end
+    
+    # Returns self, ignores sg.
+    def new_start(sg=nil)
+      self
+    end
+    alias newsg new_start
+    
+    # Returns 0, since the gregorian calendar is always used.
+    def start
+      0
+    end
+    alias sg start
+  end
+
+  # ThirdBase's top level Date compatibility class, striving to be as close as possible
+  # to the standard Date class's API.
+  module DateCompatClassMethods  
+    # Parse the date using strptime with the given format.
+    def _strptime(str, fmt='%F')
+      strptime(str, fmt)
+    end
+    
+    # Creates a new Date with the given year, month, and day of month, ignores sg.
+    def civil(year=-4712, mon=1, day=1, sg=nil)
+      super(year, mon, day)
+    end
+    
+    # Creates a new Date with the given commercial week year, commercial week, and commercial week day, ignores sg.
+    def commercial(cwyear=1582, cweek=41, cwday=5, sg=nil)
+      super(cwyear, cweek, cwday)
+    end
+    
+    # Creates a new Date with the given julian date, ignores sg.
+    def jd(j=0, sg=nil)
+      super(j)
+    end
+    
+    # Creates a new Date with the given year and day of year, ignores sg.
+    def ordinal(year=-4712, yday=1, sg=nil)
+      super(year, yday)
+    end
+    
+    # Parse given string using ThirdBase::Date's date parser, ignores comp and sg.
+    def parse(str="-4712-01-01", comp=false, sg=nil)
+      super(str)
+    end
+    
+    # Parse given string using given format, ignores sg.
+    def strptime(str="-4712-01-01", fmt='%F', sg=nil)
+      super(str, fmt)
+    end
+    
+    # Creates a new Date with today's date, ignores sg.
+    def today(sg=nil)
+      super()
+    end
+  end
+
+  module DateCompatInstanceMethods
+    # Returns a formatted string representing the date.
+    def asctime
+      strftime('%a %b %e 00:00:00 %Y')
+    end
+    alias ctime asctime
+    
+    # Returns 0.0, since Date don't have fractional days.
+    def day_fraction
+      0.0
+    end
+  end
+
+  # ThirdBase's top level DateTime compatibility class, striving to be as close as possible
+  # to the standard DateTime class's API.
+  module DateTimeCompatClassMethods
+    # Parse the datetime using strptime with the given format.
+    def _strptime(str, fmt='%FT%T%z')
+      strptime(str, fmt)
+    end
+    
+    # Creates a new DateTime with the given year, month, day of month, hour, minute, second, and offset, ignores sg.
+    def civil(year=-4712, mon=1, day=1, hour=0, min=0, sec=0, offset=0, sg=nil)
+      super(year, mon, day, hour, min, sec, 0, (offset*86400).to_i)
+    end
+    
+    # Creates a new DateTime with the given commercial week year, commercial week, commercial week day,
+    # hour, minute, second, and offset, ignores sg.
+    def commercial(cwyear=1582, cweek=41, cwday=5, hour=0, min=0, sec=0, offset=0, sg=nil)
+      super(cwyear, cweek, cwday, hour, min, sec, 0, (offset*86400).to_i)
+    end
+    
+    # Creates a new DateTime with the given julian date, hour, minute, second, and offset, ignores sg.
+    def jd(j=0, hour=0, min=0, sec=0, offset=0, sg=nil)
+      super(j, hour, min, sec, 0, (offset*86400).to_i)
+    end
+    
+    # Creates a new DateTime with the given year, day of year, hour, minute, second, and offset, ignores sg.
+    def ordinal(year=-4712, yday=1, hour=0, min=0, sec=0, offset=0, sg=nil)
+      super(year, yday, hour, min, sec, 0, (offset*86400).to_i)
+    end
+    
+    # Parse given string using ThirdBase::DateTime's date parser, ignores comp and sg.
+    def parse(str="-4712-01-01T00:00:00+00:00", comp=false, sg=nil)
+      super(str)
+    end
+    
+    # Parse given string using given format, ignores sg.
+    def strptime(str="-4712-01-01T00:00:00+00:00", fmt='%FT%T%z', sg=nil)
+      super(str, fmt)
+    end
+    
+    # Creates a new DateTime with the current date and time, ignores sg.
+    def now(sg=nil)
+      super()
+    end
+  end
+    
+  module DateTimeCompatInstanceMethods
+    # Returns a formatted string representing the date.
+    def asctime
+      strftime('%c')
+    end
+    alias ctime asctime
+    
+    def day_fraction
+      fract
+    end
+    
+    # Returns a new DateTime with the same date and time as this datetime, but with a new offset.
+    def new_offset(offset=0)
+      self.class.new!(:civil=>civil, :parts=>time_parts, :offset=>(offset*86400).to_i)
+    end
+    alias newof new_offset
+    
+    # Return the offset as a Float representing the fraction of the day different from UTC.
+    def offset
+      @offset/86400.0
+    end
+    alias of offset
+    
+    # Return the offset as a number of seconds from UTC.
+    def offset_sec
+      @offset
+    end
+
+    # The fraction of a second represented as a fraction of the entire day.
+    def sec_fraction
+      usec/86400000000.0
+    end
+  end
+
+  class Date
+    extend CompatClassMethods
+    include CompatInstanceMethods
+    extend DateCompatClassMethods
+    include DateCompatInstanceMethods
+  end
+
+  class DateTime
+    extend CompatClassMethods
+    include CompatInstanceMethods
+    extend DateTimeCompatClassMethods
+    include DateTimeCompatInstanceMethods
+  end
+end

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: third_base
 version: !ruby/object:Gem::Version 
-  version: 1.2.0
+  hash: 27
+  prerelease: false
+  segments: 
+  - 1
+  - 3
+  - 0
+  version: 1.3.0
 platform: ruby
 authors: 
 - Jeremy Evans
@@ -9,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-17 00:00:00 -07:00
+date: 2010-07-06 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -25,19 +31,16 @@ files:
 - LICENSE
 - README
 - bin/third_base
-- lib/third_base.rb
+- lib/third_base/compat/date/format.rb
+- lib/third_base/compat/date.rb
 - lib/third_base/compat.rb
 - lib/third_base/date.rb
 - lib/third_base/datetime.rb
-- lib/third_base/compat/date/format.rb
-- lib/third_base/compat/date.rb
+- lib/third_base/make_compat.rb
+- lib/third_base.rb
 - benchmark/datetime.rb
 - benchmark/date.rb
-- spec/spec_helper.rb
-- spec/date_spec_helper.rb
-- spec/compat_spec_helper.rb
-- spec/datetime_spec_helper.rb
-- spec/date/add_month_spec.rb
+- spec/date/accessor_spec.rb
 - spec/date/add_spec.rb
 - spec/date/boat_spec.rb
 - spec/date/civil_spec.rb
@@ -58,8 +61,8 @@ files:
 - spec/date/upto_spec.rb
 - spec/date/strftime_spec.rb
 - spec/date/strptime_spec.rb
-- spec/date/accessor_spec.rb
-- spec/datetime/add_spec.rb
+- spec/date/add_month_spec.rb
+- spec/datetime/strptime_spec.rb
 - spec/datetime/minus_spec.rb
 - spec/datetime/eql_spec.rb
 - spec/datetime/boat_spec.rb
@@ -68,13 +71,19 @@ files:
 - spec/datetime/constructor_spec.rb
 - spec/datetime/accessor_spec.rb
 - spec/datetime/strftime_spec.rb
-- spec/datetime/strptime_spec.rb
+- spec/datetime/add_spec.rb
 - spec/compat/date_spec.rb
 - spec/compat/compat_class_methods_spec.rb
 - spec/compat/compat_instance_methods_spec.rb
 - spec/compat/datetime_spec.rb
+- spec/spec_helper.rb
+- spec/datetime_spec_helper.rb
+- spec/date_spec_helper.rb
+- spec/compat_spec_helper.rb
 has_rdoc: true
 homepage: http://third-base.rubyforge.org
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --inline-source
@@ -85,23 +94,29 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: third-base
-rubygems_version: 1.3.1
+rubygems_version: 1.3.7
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: A Fast and Easy Date/DateTime Class
 test_files: []