@@ -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 README @@ -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) lib/third_base/compat.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! lib/third_base/date.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 lib/third_base/datetime.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 spec/compat/compat_class_methods_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) spec/date/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}} spec/datetime/parse_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 spec/datetime/strftime_spec.rb @@ -1,6 +1,6 @@ spec = Gem::Specification.new do |s| s.name = "third_base" - s.version = "1.1.1" + s.version = "1.2.0" s.author = "Jeremy Evans" s.email = "code@jeremyevans.net" s.homepage = "http://third-base.rubyforge.org" third_base.gemspec 5ffc2f28dd5ee94462f0ff3a2d1426cdab689d12 Jeremy Evans code@jeremyevans.net http://github.com/jeremyevans/third_base/commit/9b9e13b456b63ce67ad837f3978269251b5463c4 9b9e13b456b63ce67ad837f3978269251b5463c4 2009-08-17T13:21:03-07:00 2009-08-17T13:21:03-07:00 Add strptime based parsers, many bugfixes, bump version to 1.2.0 This is a major update that fixes many bugs and allows the user to more easily create custom parsers using the strptime format string syntax. Example: DateTime.add_parser(:mine, '%Z %m~%Y~%d %S`%M`%H') With a strptime-based parser, you don't need to provide a block, and you probably shouldn't. The following minor improvements are included in this commit: * An additional parser has been added by default, so that the following code will work: DateTime.parse(Time.now.to_s) DateTime.parse(Time.now.strftime('%+')) * You can now have a custom parser return a Date/DateTime object that you create. If you provide a hash, it still creates a Date/DateTime object for you using the hash as parameters. Any object other than a hash that is returned by a parser block is returned directly. * The default parsers all understand the timezones that are used by Time.now.strftime('%+'), so you can use PST, EDT, UTC, A-Z, etc.. * The %z strptime/strftime format string modifier now operates more closely to standard ruby. * A parser where only the offset is parsed will now assume the current seconds instead of 0 seconds. 80b354c92cbacb100bc4e8168de8494bd3b2b67e Jeremy Evans code@jeremyevans.net