chronic 0.7.0 → 0.8.0

data/HISTORY.md

@@ -1,5 +1,11 @@
-# HEAD
-
+# 0.8.0 / 2012-09-16
+
+* Support parsing "<ordinal> of this month" (#109)
+* Support parsing ISO 8601 format (#115)
+* Support parsing "on <day>" without a timestamp (#117)
+* Fix time parsing regexp (#125)
+* Support time when parsing dd-mm-yyy <time> (#126)
+* Allow anchor handler to accept any separators (at, on) (#128)
 * Support parsing EXIF date format (#112)
 * Start using minitest for testing
 * Ensure periods are interpreted as colons (#81).

data/lib/chronic.rb

@@ -27,7 +27,7 @@ require 'date'
 #   Chronic.parse('may 27th', :guess => false)
 #     #=> Sun May 27 00:00:00 PDT 2007..Mon May 28 00:00:00 PDT 2007
 module Chronic
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 
   class << self
 

data/lib/chronic/chronic.rb

@@ -168,11 +168,11 @@ module Chronic
         ],
 
         :date => [
-          Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :repeater_time, :separator_slash_or_dash?, :time_zone, :scalar_year], :handle_rdn_rmn_sd_t_tz_sy),
+          Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :repeater_time, :separator_slash_or_dash?, :time_zone, :scalar_year], :handle_generic),
           Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day], :handle_rdn_rmn_sd),
           Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :scalar_year], :handle_rdn_rmn_sd_sy),
           Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day], :handle_rdn_rmn_od),
-          Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_day, :repeater_time, :time_zone], :handle_sy_sm_sd_t_tz),
+          Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_day, :repeater_time, :time_zone], :handle_generic),
           Handler.new([:repeater_month_name, :scalar_day, :scalar_year], :handle_rmn_sd_sy),
           Handler.new([:repeater_month_name, :ordinal_day, :scalar_year], :handle_rmn_od_sy),
           Handler.new([:repeater_month_name, :scalar_day, :scalar_year, :separator_at?, 'time?'], :handle_rmn_sd_sy),
@@ -182,21 +182,23 @@ module Chronic
           Handler.new([:repeater_month_name, :ordinal_day, :separator_at?, 'time?'], :handle_rmn_od),
           Handler.new([:ordinal_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_od_rmn_sy),
           Handler.new([:ordinal_day, :repeater_month_name, :separator_at?, 'time?'], :handle_od_rmn),
+          Handler.new([:ordinal_day, :grabber?, :repeater_month, :separator_at?, 'time?'], :handle_od_rm),
           Handler.new([:scalar_year, :repeater_month_name, :ordinal_day], :handle_sy_rmn_od),
           Handler.new([:repeater_time, :repeater_day_portion?, :separator_on?, :repeater_month_name, :ordinal_day], :handle_rmn_od_on),
           Handler.new([:repeater_month_name, :scalar_year], :handle_rmn_sy),
           Handler.new([:scalar_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_sd_rmn_sy),
           Handler.new([:scalar_day, :repeater_month_name, :separator_at?, 'time?'], :handle_sd_rmn),
           Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_day, :separator_at?, 'time?'], :handle_sy_sm_sd),
-          Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_day], :handle_sm_sd),
           Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_year], :handle_sm_sy),
-          Handler.new([:scalar_day, :separator_slash_or_dash, :repeater_month_name, :separator_slash_or_dash, :scalar_year], :handle_sm_rmn_sy)
+          Handler.new([:scalar_day, :separator_slash_or_dash, :repeater_month_name, :separator_slash_or_dash, :scalar_year, :repeater_time?], :handle_sm_rmn_sy),
+          Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :time_zone], :handle_generic)
+
         ],
 
         # tonight at 7pm
         :anchor => [
-          Handler.new([:grabber?, :repeater, :separator_at?, :repeater?, :repeater?], :handle_r),
-          Handler.new([:grabber?, :repeater, :repeater, :separator_at?, :repeater?, :repeater?], :handle_r),
+          Handler.new([:separator_on?, :grabber?, :repeater, :separator_at?, :repeater?, :repeater?], :handle_r),
+          Handler.new([:grabber?, :repeater, :repeater, :separator?, :repeater?, :repeater?], :handle_r),
           Handler.new([:repeater, :grabber, :repeater], :handle_r_g_r)
         ],
 
@@ -204,7 +206,7 @@ module Chronic
         :arrow => [
           Handler.new([:scalar, :repeater, :pointer], :handle_s_r_p),
           Handler.new([:pointer, :scalar, :repeater], :handle_p_s_r),
-          Handler.new([:scalar, :repeater, :pointer, 'anchor'], :handle_s_r_p_a)
+          Handler.new([:scalar, :repeater, :pointer, :separator_at?, 'anchor'], :handle_s_r_p_a)
         ],
 
         # 3rd week in march
@@ -216,6 +218,8 @@ module Chronic
 
       endians = [
         Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_day, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sm_sd_sy),
+        Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_day, :separator_at?, 'time?'], :handle_sm_sd),
+        Handler.new([:scalar_day, :separator_slash_or_dash, :scalar_month, :separator_at?, 'time?'], :handle_sd_sm),
         Handler.new([:scalar_day, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy)
       ]
 

data/lib/chronic/handlers.rb

@@ -49,6 +49,13 @@ module Chronic
       handle_m_d(month, day, tokens[2..tokens.size], options)
     end
 
+    # Handle ordinal this month
+    def handle_od_rm(tokens, options)
+      day = tokens[0].get_tag(OrdinalDay).type
+      month = tokens[2].get_tag(RepeaterMonth)
+      handle_m_d(month, day, tokens[3..tokens.size], options)
+    end
+
     # Handle ordinal-day/repeater-month-name
     def handle_od_rmn(tokens, options)
       month = tokens[1].get_tag(RepeaterMonthName)
@@ -124,13 +131,7 @@ module Chronic
     end
 
     # Handle generic timestamp (ruby 1.8)
-    def handle_rdn_rmn_sd_t_tz_sy(tokens, options)
-      t = Chronic.time_class.parse(options[:text])
-      Span.new(t, t + 1)
-    end
-
-    # Handle generic timestamp (ruby 1.9)
-    def handle_sy_sm_sd_t_tz(tokens, options)
+    def handle_generic(tokens, options)
       t = Chronic.time_class.parse(options[:text])
       Span.new(t, t + 1)
     end
@@ -224,27 +225,30 @@ module Chronic
       handle_sm_sd_sy(new_tokens + time_tokens, options)
     end
 
-    # Handle scalar-day/scalar-month AND scalar-month/scalar-day
+    # Handle scalar-month/scalar-day
     def handle_sm_sd(tokens, options)
       month = tokens[0].get_tag(ScalarMonth).type
       day = tokens[1].get_tag(ScalarDay).type
       year = Chronic.now.year
-
-      if Array(options[:endian_precedence]).first == :little
-        day, month = month, day
-      end
+      time_tokens = tokens.last(tokens.size - 2)
 
       return if month_overflow?(year, month, day)
 
       begin
-        start_time = Chronic.time_class.local(year, month, day)
-        end_time = Chronic.time_class.local(year, month, day + 1)
-        Span.new(start_time, end_time)
+        day_start = Chronic.time_class.local(year, month, day)
+        day_or_time(day_start, time_tokens, options)
       rescue ArgumentError
         nil
       end
     end
 
+    # Handle scalar-day/scalar-month
+    def handle_sd_sm(tokens, options)
+      new_tokens = [tokens[1], tokens[0]]
+      time_tokens = tokens.last(tokens.size - 2)
+      handle_sm_sd(new_tokens + time_tokens, options)
+    end
+
     # Handle scalar-month/scalar-year
     def handle_sm_sy(tokens, options)
       month = tokens[0].get_tag(ScalarMonth).type
@@ -321,8 +325,15 @@ module Chronic
       day = tokens[0].get_tag(ScalarDay).type
       month = tokens[1].get_tag(RepeaterMonthName).index
       year = tokens[2].get_tag(ScalarYear).type
-      time = Chronic.time_class.local(year, month, day)
-      end_time = Chronic.time_class.local(year, month, day + 1)
+      if tokens.size > 3
+        time = get_anchor([tokens.last], options).begin
+        h, m, s = time.hour, time.min, time.sec
+        time = Chronic.time_class.local(year, month, day, h, m, s)
+        end_time = Chronic.time_class.local(year, month, day + 1, h, m, s)
+      else
+        time = Chronic.time_class.local(year, month, day)
+        end_time = Chronic.time_class.local(year, month, day + 1)
+      end
       Span.new(time, end_time)
     end
 
@@ -420,7 +431,6 @@ module Chronic
     def get_anchor(tokens, options)
       grabber = Grabber.new(:this)
       pointer = :future
-
       repeaters = get_repeaters(tokens)
       repeaters.size.times { tokens.pop }
 

data/lib/chronic/repeater.rb

@@ -88,7 +88,7 @@ module Chronic
     #
     # Returns a new Repeater object.
     def self.scan_for_times(token)
-      scan_for token, RepeaterTime, /^\d{1,2}(:?\d{2})?([\.:]?\d{2})?$/
+      scan_for token, RepeaterTime, /^\d{1,2}(:?\d{1,2})?([\.:]?\d{1,2})?$/
     end
 
     # token - The Token object we want to scan.
@@ -104,11 +104,11 @@ module Chronic
         /^weekends?$/ => :weekend,
         /^(week|business)days?$/ => :weekday,
         /^days?$/ => :day,
-	/^hrs?$/ => :hour,
+	      /^hrs?$/ => :hour,
         /^hours?$/ => :hour,
-	/^mins?$/ => :minute,
+	      /^mins?$/ => :minute,
         /^minutes?$/ => :minute,
-	/^secs?$/ => :second,
+	      /^secs?$/ => :second,
         /^seconds?$/ => :second
       }.each do |item, symbol|
         if item =~ token.word

data/test/test_chronic.rb

@@ -67,6 +67,8 @@ class TestChronic < TestCase
     # middle, little
     endians = [
       Chronic::Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_day, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sm_sd_sy),
+      Chronic::Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_day, :separator_at?, 'time?'], :handle_sm_sd),
+      Chronic::Handler.new([:scalar_day, :separator_slash_or_dash, :scalar_month, :separator_at?, 'time?'], :handle_sd_sm),
       Chronic::Handler.new([:scalar_day, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy)
     ]
 

data/test/test_parsing.rb

@@ -8,6 +8,14 @@ class TestParsing < TestCase
     @time_2006_08_16_14_00_00 = TIME_2006_08_16_14_00_00
   end
 
+  def test_handle_generic
+    time = Chronic.parse("2012-08-02T12:00:00+01:00")
+    assert_equal Time.local(2012, 8, 2, 12), time
+
+    time = Chronic.parse("2012-08-02T12:00:00Z")
+    assert_equal Time.utc(2012, 8, 2, 12), time
+  end
+
   def test_handle_rmn_sd
     time = parse_now("aug 3")
     assert_equal Time.local(2006, 8, 3, 12), time
@@ -65,6 +73,11 @@ class TestParsing < TestCase
     assert_equal Time.local(2007, 5, 27, 5), time
   end
 
+  def test_handle_od_rm
+    time = parse_now("fifteenth of this month")
+    assert_equal Time.local(2006, 8, 15, 12), time
+  end
+
   def test_handle_od_rmn
     time = parse_now("22nd February")
     assert_equal Time.local(2007, 2, 22, 12), time
@@ -294,8 +307,14 @@ class TestParsing < TestCase
     time = parse_now("05/06", :endian_precedence => [:little, :medium])
     assert_equal Time.local(2006, 6, 5, 12), time
 
+    time = parse_now("05/06 6:05:57 PM")
+    assert_equal Time.local(2006, 5, 6, 18, 05, 57), time
+
+    time = parse_now("05/06 6:05:57 PM", :endian_precedence => [:little, :medium])
+    assert_equal Time.local(2006, 6, 5, 18, 05, 57), time
+
     time = parse_now("13/01")
-    assert_nil time
+    assert_equal Time.local(2006, 1, 13, 12), time
   end
 
   # def test_handle_sm_sy
@@ -310,6 +329,11 @@ class TestParsing < TestCase
   # end
 
   def test_handle_r
+    time = parse_now("9am on Saturday")
+    assert_equal Time.local(2006, 8, 19, 9), time
+
+    time = parse_now("on Tuesday")
+    assert_equal Time.local(2006, 8, 22, 12), time
   end
 
   def test_handle_r_g_r
@@ -325,6 +349,9 @@ class TestParsing < TestCase
   end
 
   def test_handle_s_r_p_a
+    time1 = parse_now("two days ago 0:0:0am")
+    time2 = parse_now("two days ago 00:00:00am")
+    assert_equal time1, time2
   end
 
   def test_handle_orr

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chronic
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-01 00:00:00.000000000 Z
+date: 2012-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake