third_base 1.1.1 → 1.2.0

data/README

@@ -3,7 +3,7 @@
 ThirdBase differs from Ruby's standard Date/DateTime class in the following
 ways:
 
-- ThirdBase is roughly 2-12 times faster depending on usage
+- ThirdBase is roughly 2-10 times faster depending on usage
 - ThirdBase has a lower memory footprint
 - ThirdBase supports pluggable parsers
 - ThirdBase doesn't depend on Ruby's Rational class
@@ -150,17 +150,17 @@ To add a parser type:
   Date.add_parser_type(:mine)
   DateTime.add_parser_type(:mine)
 
-=== Adding Parsers to Parser Types
+=== Adding Regexp Parsers to Parser Types
 
-A ThirdBase Date/Datetime parser consists of two parts, a regular
-expression, and a proc that takes a MatchData object and returns a hash
-passed to Date/DateTime.new!.  The proc is only called if the regular
-expression matches the string to be parsed, and it can return nil if it
-is not able to successfully parse the string (even if the string matches
-the regular expression).  To add a parser, you use the add_parser class
-method, which takes an argument specifying which parser family to
-use, the regular expression, and a block that is used as a proc for the
-parser:
+A ThirdBase Date/Datetime regexp parser consists of two parts, a regular
+expression, and a block that takes a MatchData object and returns a 
+Date/DateTime instance or a hash to be passed to Date/DateTime.new!.  The
+block is only called if the regular expression matches the string to be
+parsed, and it can return nil if it is not able to successfully parse the
+string (even if the string matches the regular expression).  To add a
+parser, you use the add_parser class method, which takes an argument
+specifying which parser family to use, the regular expression, and a block
+that is used as a proc for the parser:
 
 To add a parser to a parser type:
 
@@ -195,6 +195,15 @@ Adding a parser to a parser type adds it to the front of the array of parsers
 for that type, so it will be tried before other parsers for that type.  It is
 an error to add a parser to a parser type that doesn't exist.
 
+=== Adding strptime Parsers to Parser Types (New in 1.2.0)
+
+ThirdBase 1.2.0 added the ability to more easily create common parsers
+using the strptime format string syntax.  These are created similar to regexp
+parsers, but use a format string, and the block is then optional (and should
+be omitted unless you know what you are doing):
+
+  DateTime.add_parser(:mine, '%Z %m~%Y~%d %S`%M`%H')
+
 === Modifying the Order of Parsers Types
 
 You can change the order in which parsers types are tried by using the

data/lib/third_base/compat.rb

@@ -42,7 +42,7 @@ module ThirdBase
     # * :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.offset, :mday=>d.day, :min=>d.min, :sec_fraction=>d.usec/1000000.0}.reject{|k, v| d.not_parsed.include?(k)}
+      {: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)

data/lib/third_base/date.rb

@@ -43,7 +43,8 @@ module ThirdBase
       [%r{\A#{MONTHNAME_RE_PATTERN}[-./ ](\d\d?)(?:st|nd|rd|th)?,?(?:[-./ ](-?(?:\d\d(?:\d\d)?)))?\z}io, proc{|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})\z}io, proc{|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)?\z}io, proc{|m| {:civil=>[m[1].to_i, MONTH_NUM_MAP[m[2].downcase], m[3].to_i]}}],
-      [%r{\A#{MONTHNAME_RE_PATTERN}[-./ ](-?\d{4})\z}io, proc{|m| {:civil=>[m[2].to_i, MONTH_NUM_MAP[m[1].downcase], 1]}}]]
+      [%r{\A#{MONTHNAME_RE_PATTERN}[-./ ](-?\d{4})\z}io, proc{|m| {:civil=>[m[2].to_i, MONTH_NUM_MAP[m[1].downcase], 1]}}],
+      [%r{\A#{ABBR_DAYNAME_RE_PATTERN} #{ABBR_MONTHNAME_RE_PATTERN} (\d\d?) (-?\d{4})\z}io, proc{|m| {:civil=>[m[4].to_i, MONTH_NUM_MAP[m[2].downcase], m[3].to_i]}}]]
     DEFAULT_PARSERS[:eu] = [[%r{\A(\d\d?)[-./ ](\d\d?)[-./ ](\d\d\d\d)\z}o, proc{|m| {:civil=>[m[3].to_i, m[2].to_i, m[1].to_i]}}],
       [%r{\A(\d\d?)[-./ ](\d?\d)[-./ ](\d?\d)\z}o, proc{|m| {:civil=>[two_digit_year(m[1]), m[2].to_i, m[3].to_i]}}]]
     DEFAULT_PARSERS[:num] = [[%r{\A\d{2,8}\z}o, proc do |m|
@@ -91,13 +92,26 @@ module ThirdBase
       alias new! new
     end
     
-    # Add a parser to the parser type.  re should be
-    # a Regexp, and a block must be provided.  The block
-    # should take a single MatchData argument, a return
-    # either nil specifying it could not parse the string,
-    # or a hash of values to be passed to new!.
-    def self.add_parser(type, re, &block)
-      parser_hash[type].unshift([re, block])
+    # 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:
+    #   * String - A strptime parser regular expression is created using pattern as the format string.
+    #     If a block is given, it is used.  If no block is given, the parser will
+    #     operate identically to strptime.
+    #   * Regexp - The regular expression is used directly.  In this case, a block must be provided,
+    #     or an error is raised.
+    # 
+    # 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)
+      if pattern.is_a?(String)
+        pattern, blk = strptime_pattern_and_block(pattern)
+        block ||= blk
+      else
+        raise(ArgumentError, 'must provide block for Regexp parser') unless block_given?
+      end
+      parser_hash[type].unshift([pattern, block])
     end
     
     # Add a parser type to the list of parser types.
@@ -144,7 +158,7 @@ module ThirdBase
       parsers(opts[:parser_types]) do |pattern, block|
         if m = pattern.match(s)
           if res = block.call(m)
-            return new!(res)
+            return res.is_a?(Hash) ? new!(res) : res
           end
         end
       end
@@ -166,24 +180,15 @@ 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)
-      blocks = []
+      pattern, block = strptime_pattern_and_block(fmt)
       s = str.strip
-      date_hash = {}
-      pattern = Regexp.escape(expand_strptime_format(fmt)).gsub(STRFTIME_RE) do |x|
-        pat, *blks = _strptime_part(x[1..1])
-        blocks += blks
-        pat
-      end
-      if m = /#{pattern}/i.match(s)
-        m.to_a[1..-1].zip(blocks) do |x, blk|
-          blk.call(date_hash, x)
-        end
-        new_from_parts(date_hash)
+      if m = pattern.match(s)
+        block.call(m)
       else
         raise ArgumentError, 'invalid date'
       end
     end
-    
+
     # Returns a date with the current year, month, and date.
     def self.today
       t = Time.now
@@ -283,6 +288,23 @@ module ThirdBase
       '%Y-%m-%d'
     end
     
+    def self.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])
+        blocks += blks
+        pat
+      end
+      block = proc do |m|
+        h = {}
+        m.to_a[1..-1].zip(blocks) do |x, blk|
+          blk.call(h, x)
+        end
+        new_from_parts(h)
+      end
+      [/\A#{pattern}\z/i, block]
+    end
+    
     def self.two_digit_year(y)
       y = if y.length == 2
         y = y.to_i
@@ -292,7 +314,7 @@ module ThirdBase
       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, :two_digit_year
+    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
     
     reset_parsers!
     

data/lib/third_base/datetime.rb

@@ -4,11 +4,16 @@ 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
-    
+    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,
+      'A'=>3600, 'B'=>7200, 'C'=>10800, 'D'=>14400, 'E'=>18000, 'F'=>21600, 'G'=>25200, 'H'=>28800, 'I'=>32400, 'K'=>36000, 'L'=>39600, 'M'=>43200,
+      'N'=>-3600, 'O'=>-7200, 'P'=>-10800, 'Q'=>-14400, 'R'=>-18000, 'S'=>-21600, 'T'=>-25200, 'U'=>-28800, 'V'=>-32400, 'W'=>-36000, 'X'=>-39600, 'Y'=>-43200}
     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)?))?)?'
+    TIME_ZONE_RE_STRING = "(#{TIME_ZONE_SECOND_OFFSETS.keys.sort.join('|')}|[+-](?:\\d\\d:?(?:\\d\\d)?))"
+    TIME_RE_STRING = "(?:[T ]?([\\d ]?\\d):(\\d\\d)(?::(\\d\\d(\\.\\d+)?))?([ap]m?)? ?#{TIME_ZONE_RE_STRING}?)?"
     DEFAULT_PARSERS[:time] = [[%r{\A#{TIME_RE_STRING}\z}io, proc do |m|
         unless m[0] == ''
           t = Time.now
@@ -21,7 +26,8 @@ module ThirdBase
       [%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], :not_parsed=>m[3] ? [] : [:year])}],
       [%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#{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]})}]]
     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|
@@ -58,7 +64,7 @@ module ThirdBase
       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)}
+    STRPTIME_PROC_z = proc{|h,x| h[:offset] = convert_parsed_offset(x)}
     
     # Public Class Methods
     
@@ -102,7 +108,7 @@ module ThirdBase
       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'
+      when '%+' then '%a %b %e %H:%M:%S %Z %Y'
       else super(v)
       end
     end
@@ -115,7 +121,7 @@ module ThirdBase
       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]
+      when 'z', 'Z' then [TIME_ZONE_RE_STRING, STRPTIME_PROC_z]
       else super(v)
       end
     end
@@ -133,8 +139,7 @@ module ThirdBase
       meridian = m[i+4]
       hour = hour_with_meridian(hour, /a/io.match(meridian) ? :am : :pm) if meridian
       offset = if of = m[i+5]
-        x = of.gsub(':','')
-        offset = x == 'Z' ? 0 : x[0..2].to_i*3600 + x[3..4].to_i*60
+        convert_parsed_offset(of)
       else
         not_parsed.concat([:zone, :offset])
         Time.now.utc_offset
@@ -168,11 +173,18 @@ module ThirdBase
     end
     
     def self.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)
+      not_parsed << :mon unless date_hash.has_key?(:month) || date_hash.has_key?(:cweek)
+      not_parsed << :mday unless date_hash.has_key?(:day) || date_hash.has_key?(:cwday)
+      not_parsed << :sec_fraction
+
       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}
+      weights = {:cwyear=>1, :year=>1, :cweek=>2, :cwday=>3, :yday=>3, :month=>2, :day=>3, :hour=>4, :min=>5, :sec=>6, :offset=>7}
       columns = {}
-      min = 7
+      min = 8
       max = 0
       date_hash.each do |k,v|
         if w = weights[k]
@@ -183,21 +195,31 @@ module ThirdBase
       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
+      sec = date_hash[:sec] || (min > 6 ? d.sec : 0)
+      hash = {:parts=>[hour, minute, sec, 0], :offset=>offset.to_i, :not_parsed=>not_parsed}
       if date_hash[:jd]
-        jd(date_hash[:jd], hour, minute, sec, 0, offset)
+        new!(hash.merge!(:jd=>date_hash[:jd]))
       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)
+          new!(hash.merge!(:ordinal=>[date_hash[:year]||d.year, date_hash[:yday]]))
         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)
+          new!(hash.merge!(:civil=>[date_hash[:year]||d.year, date_hash[:month]||(min > 2 ? d.mon : 1), date_hash[:day]||(min > 3 ? d.day : 1)]))
         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)
+        new!(hash.merge!(:commercial=>[date_hash[:cwyear]||d.cwyear, date_hash[:cweek]||(min > 2 ? d.cweek : 1), date_hash[:cwday]||(min > 3 ? d.cwday : 1)]))
       else
         raise ArgumentError, 'invalid date'
       end
     end
+
+    def self.convert_parsed_offset(of)
+      if offset = TIME_ZONE_SECOND_OFFSETS[of.upcase]
+        offset
+      else
+        x = of.gsub(':','')
+        x[0..2].to_i*3600 + x[3..4].to_i*60
+      end
+    end
     
     def self.parser_hash
       PARSERS
@@ -211,7 +233,7 @@ module ThirdBase
       '%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
+    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
     
     reset_parsers!
     
@@ -342,7 +364,7 @@ module ThirdBase
     
     # Return the offset as a time zone string (+/-HHMM).
     def zone
-      strftime('%z')
+      strftime('%Z')
     end
     
     private
@@ -362,9 +384,9 @@ module ThirdBase
       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)
+      when '+' then strftime('%a %b %e %H:%M:%S %Z %Y')
+      when 'Z' then "%+03d:%02d" % (@offset/60).divmod(60)
+      when 'z' then "%+03d%02d" % (@offset/60).divmod(60)
       else super(v)
       end
     end
@@ -385,7 +407,7 @@ module ThirdBase
     end
 
     def strftime_default
-      '%Y-%m-%dT%H:%M:%S%z'
+      '%Y-%m-%dT%H:%M:%S%Z'
     end
     
     def time_parts

data/spec/compat/compat_class_methods_spec.rb

@@ -30,6 +30,35 @@ describe ThirdBase::CompatClassMethods do
     Date._parse('2008-10-20').should == {:year=>2008, :mday=>20, :mon=>10}
     Date._parse('11:12:13').should == {:sec=>13, :hour=>11, :min=>12}
   end
+  
+  it "#_parse should not contain fields in the hash that were guessed when a strptime-parser is used" do
+    DateTime.add_parser(:us, "%m-%d<>%H/%M")
+    Date._parse('10-11<>12/13').should == {:mon=>10, :mday=>11, :hour=>12, :min=>13}
+
+    DateTime.add_parser(:us, "%d")
+    Date._parse('11').should == {:mday=>11}
+
+    DateTime.add_parser(:us, "%m")
+    Date._parse('11').should == {:mon=>11}
+
+    DateTime.add_parser(:us, "%Y")
+    Date._parse('2009').should == {:year=>2009}
+
+    DateTime.add_parser(:us, "%H")
+    Date._parse('11').should == {:hour=>11}
+
+    DateTime.add_parser(:us, "%M")
+    Date._parse('11').should == {:min=>11}
+
+    DateTime.add_parser(:us, "%S")
+    Date._parse('20').should == {:sec=>20}
+
+    DateTime.add_parser(:us, "%Z")
+    Date._parse('UTC').should == {:zone=>'+00:00', :offset=>0}
+    Date._parse('CDT').should == {:zone=>'-05:00', :offset=>-18000}
+
+    DateTime.reset_parsers!
+  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

data/spec/date/parse_spec.rb

@@ -82,6 +82,10 @@ describe :date_parse, :shared => true do
     Date.parse("november#{@sep}5th").should == Date.civil(Date.today.year, 11, 5)
   end
 
+  it "can parse a weekday, month, day, and year into a Date object" do
+    Date.parse("Mon Aug 10 2009").should == Date.civil(2009, 8, 10)
+  end
+
   it "can parse a month name, day and year into a Date object" do
     Date.parse("november#{@sep}5th#{@sep}2005").should == Date.civil(2005, 11, 5)
   end
@@ -209,12 +213,25 @@ describe "Date parser modifications" do
     Date.reset_parsers!
   end
   
-  it "should be able to add a parser to an existing parser type that takes precedence" do
+  it "should raise an ArgumentError if it can't parse a date" do
     proc{Date.parse("today")}.should raise_error(ArgumentError)
+  end
+
+  it "should be able to add a parser to an existing parser type that takes precedence" do
     Date.add_parser(:iso, /today/){t = Time.now; {:civil=>[t.year, t.mon, t.day]}}
     Date.parse("today").should == Date.today
   end
   
+  it "should be able to handle parsers that return Date instances" do
+    Date.add_parser(:iso, /today/){t = Time.now; Date.new(t.year, t.mon, t.day)}
+    Date.parse("today").should == Date.today
+  end
+  
+  it "should be able to specify a strptime format string for a parser" do
+    Date.add_parser(:iso, "%d<<%m<<%Y")
+    Date.parse("03<<02<<2001").should == Date.new(2001, 2, 3)
+  end
+  
   it "should be able to add new parser types" do
     proc{Date.parse("today")}.should raise_error(ArgumentError)
     Date.add_parser_type(:mine)

data/spec/datetime/parse_spec.rb

@@ -22,7 +22,7 @@ describe "DateTime#parse" do
     DateTime.parse("12:02:03p").should == DateTime.civil(DateTime.today.year, DateTime.today.month, DateTime.today.day, 12, 2, 3)
     proc{DateTime.parse("13:02:03p")}.should raise_error(ArgumentError)
     proc{DateTime.parse("00:02:03p")}.should raise_error(ArgumentError)
-    proc{DateTime.parse("00:02:03r")}.should raise_error(ArgumentError)
+    proc{DateTime.parse("00:02:03rsdf")}.should raise_error(ArgumentError)
   end
 
   it "should use the current time offset if no time offset is specified" do
@@ -34,6 +34,50 @@ describe "DateTime#parse" do
     DateTime.parse("01:02:03-01").should == DateTime.civil(DateTime.today.year, DateTime.today.month, DateTime.today.day, 1, 2, 3, 0, -3600)
   end
 
+  it "should parse the time zone abbreviations supported by ruby's Time class" do
+    DateTime.parse("01:02:03 UTC").offset.should == 0
+    DateTime.parse("01:02:03 UT").offset.should == 0
+    DateTime.parse("01:02:03 GMT").offset.should == 0
+    DateTime.parse("01:02:03 EST").offset.should == -5*3600
+    DateTime.parse("01:02:03 EDT").offset.should == -4*3600
+    DateTime.parse("01:02:03 CST").offset.should == -6*3600
+    DateTime.parse("01:02:03 CDT").offset.should == -5*3600
+    DateTime.parse("01:02:03 MST").offset.should == -7*3600
+    DateTime.parse("01:02:03 MDT").offset.should == -6*3600
+    DateTime.parse("01:02:03 PST").offset.should == -8*3600
+    DateTime.parse("01:02:03 PDT").offset.should == -7*3600
+    DateTime.parse("01:02:03 A").offset.should == 1*3600
+    DateTime.parse("01:02:03 B").offset.should == 2*3600
+    DateTime.parse("01:02:03 C").offset.should == 3*3600
+    DateTime.parse("01:02:03 D").offset.should == 4*3600
+    DateTime.parse("01:02:03 E").offset.should == 5*3600
+    DateTime.parse("01:02:03 F").offset.should == 6*3600
+    DateTime.parse("01:02:03 G").offset.should == 7*3600
+    DateTime.parse("01:02:03 H").offset.should == 8*3600
+    DateTime.parse("01:02:03 I").offset.should == 9*3600
+    DateTime.parse("01:02:03 K").offset.should == 10*3600
+    DateTime.parse("01:02:03 L").offset.should == 11*3600
+    DateTime.parse("01:02:03 M").offset.should == 12*3600
+    DateTime.parse("01:02:03 N").offset.should == -1*3600
+    DateTime.parse("01:02:03 O").offset.should == -2*3600
+    DateTime.parse("01:02:03 P").offset.should == -3*3600
+    DateTime.parse("01:02:03 Q").offset.should == -4*3600
+    DateTime.parse("01:02:03 R").offset.should == -5*3600
+    DateTime.parse("01:02:03 S").offset.should == -6*3600
+    DateTime.parse("01:02:03 T").offset.should == -7*3600
+    DateTime.parse("01:02:03 U").offset.should == -8*3600
+    DateTime.parse("01:02:03 V").offset.should == -9*3600
+    DateTime.parse("01:02:03 W").offset.should == -10*3600
+    DateTime.parse("01:02:03 X").offset.should == -11*3600
+    DateTime.parse("01:02:03 Y").offset.should == -12*3600
+    DateTime.parse("01:02:03 Z").offset.should == 0
+  end
+
+  it "should parse the time strings output by ruby's Time class" do
+    proc{DateTime.parse(Time.now.to_s)}.should_not raise_error
+    proc{DateTime.parse(Time.now.strftime('%+'))}.should_not raise_error
+  end
+
   it "can handle DD as month day number" do
     DateTime.parse("10").should == DateTime.civil(DateTime.today.year, DateTime.today.month, 10)
     DateTime.parse("10 01:02:03").should == DateTime.civil(DateTime.today.year, DateTime.today.month, 10, 1, 2, 3)
@@ -318,15 +362,35 @@ describe "DateTime parser modifications" do
     DateTime.reset_parsers!
   end
   
+  it "should raise an ArgumentError if it can't parse a date" do
+    proc{DateTime.parse("today")}.should raise_error(ArgumentError)
+  end
+
   it "should be able to add a parser to an existing parser type that takes precedence" do
     d = DateTime.now
-    proc{DateTime.parse("today")}.should raise_error(ArgumentError)
     DateTime.add_parser(:iso, /\Anow\z/){{:civil=>[d.year, d.mon, d.day], :parts=>[d.hour, d.min, d.sec, d.usec], :offset=>d.offset}}
     DateTime.parse("now").should == d
   end
   
+  it "should be able to handle parsers that return Date instances" do
+    d = DateTime.now
+    DateTime.add_parser(:iso, /\Anow\z/){d}
+    DateTime.parse("now").should == d
+  end
+  
+  it "should be able to specify a strptime format string for a parser" do
+    DateTime.add_parser(:iso, "%Z||%S>>%M>>%H||%d<<%m<<%Y")
+    DateTime.parse("UTC||06>>05>>04||03<<02<<2001").should == DateTime.new(2001,2,3,4,5,6)
+  end
+
+  it "should assume current seconds if just offset is given" do
+    DateTime.add_parser_type(:mine)
+    DateTime.use_parsers(:mine)
+    DateTime.add_parser(:mine, "%Z")
+    DateTime.parse("UTC").sec.should == DateTime.now.sec
+  end
+
   it "should be able to add new parser types" do
-    proc{DateTime.parse("today")}.should raise_error(ArgumentError)
     DateTime.add_parser_type(:mine)
     d = DateTime.now
     DateTime.add_parser(:mine, /\Anow\z/){{:civil=>[d.year, d.mon, d.day], :parts=>[d.hour, d.min, d.sec, d.usec], :offset=>d.offset}}

data/spec/datetime/strftime_spec.rb

@@ -52,17 +52,18 @@ describe "DateTime#strftime" do
     DateTime.civil(2008, 11, 12, 14, 3, 31, 0, -28800).strftime('%s').should == "1226527411"
   end
   
-  it "should be able to print the time zone offset as a Z if the offset is zero" do
-    DateTime.civil(2000, 4, 6, 10, 11, 12).strftime('%Z').should == "Z"
-    DateTime.civil(2000, 4, 6, 10, 11, 12, 0, -43200).strftime('%Z').should == "-12:00"
-  end
-  
   it "should be able to print the time zone offset as a string of hours and minutes" do
-    DateTime.civil(2000, 4, 6, 10, 11, 12).strftime('%z').should == "+00:00"
-    DateTime.civil(2000, 4, 6, 10, 11, 12, 0, -43200).strftime('%z').should == "-12:00"
-    DateTime.civil(2000, 4, 6, 10, 11, 12, 0, 43200).strftime('%z').should == "+12:00"
-    DateTime.civil(2000, 4, 6, 10, 11, 12, 0, -3600).strftime('%z').should == "-01:00"
-    DateTime.civil(2000, 4, 6, 10, 11, 12, 0, 3600).strftime('%z').should == "+01:00"
+    DateTime.civil(2000, 4, 6, 10, 11, 12).strftime('%z').should == "+0000"
+    DateTime.civil(2000, 4, 6, 10, 11, 12, 0, -43200).strftime('%z').should == "-1200"
+    DateTime.civil(2000, 4, 6, 10, 11, 12, 0, 43200).strftime('%z').should == "+1200"
+    DateTime.civil(2000, 4, 6, 10, 11, 12, 0, -3600).strftime('%z').should == "-0100"
+    DateTime.civil(2000, 4, 6, 10, 11, 12, 0, 3600).strftime('%z').should == "+0100"
+    
+    DateTime.civil(2000, 4, 6, 10, 11, 12).strftime('%Z').should == "+00:00"
+    DateTime.civil(2000, 4, 6, 10, 11, 12, 0, -43200).strftime('%Z').should == "-12:00"
+    DateTime.civil(2000, 4, 6, 10, 11, 12, 0, 43200).strftime('%Z').should == "+12:00"
+    DateTime.civil(2000, 4, 6, 10, 11, 12, 0, -3600).strftime('%Z').should == "-01:00"
+    DateTime.civil(2000, 4, 6, 10, 11, 12, 0, 3600).strftime('%Z').should == "+01:00"
   end
   
   ############################
@@ -97,6 +98,6 @@ describe "DateTime#strftime" do
   it "should be able to print the common date and timezone" do
     DateTime.civil(2000, 4, 6, 10, 11, 12).strftime("%+").should == "Thu Apr  6 10:11:12 +00:00 2000"
     DateTime.civil(2000, 4, 6, 10, 11, 12, 0, 43200).strftime("%+").should == "Thu Apr  6 10:11:12 +12:00 2000"
-    DateTime.civil(2000, 4, 6, 10, 11, 12).strftime("%+").should == DateTime.civil(2000, 4, 6, 10, 11, 12).strftime('%a %b %e %H:%M:%S %z %Y')  
+    DateTime.civil(2000, 4, 6, 10, 11, 12).strftime("%+").should == DateTime.civil(2000, 4, 6, 10, 11, 12).strftime('%a %b %e %H:%M:%S %Z %Y')  
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: third_base
 version: !ruby/object:Gem::Version 
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors: 
 - Jeremy Evans
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-09 00:00:00 -07:00
+date: 2009-08-17 00:00:00 -07:00
 default_executable: 
 dependencies: []