tickle 0.1.5 → 0.1.6

data/README.rdoc

@@ -44,7 +44,7 @@ Tickle.parse returns a hash containing the following keys:
 
 Tickle returns nil if it cannot parse the string cannot be parsed.
 
-Tickle HEAVILY uses chronic for parsing both the event and the start date.
+Tickle HEAVILY uses chronic for parsing but mostly the start and until phrases.
 
 === OPTIONS
 
@@ -57,8 +57,8 @@ NATURAL LANGUAGE:
 
 OPTIONS HASH
 Valid options are:
-    * start - must be a valid date. (e.g. Tickle.parse('every other day', {:start => Date.new(2010,8,1) }))
-    * until - must be a valid date. (e.g. Tickle.parse('every other day', {:until => Date.new(2010,10,1) }))
+    * start - must be a valid date or Chronic date expression. (e.g. Tickle.parse('every other day', {:start => Date.new(2010,8,1) }))
+    * until - must be a valid date or Chronic date expression. (e.g. Tickle.parse('every other day', {:until => Date.new(2010,10,1) }))
     * next_only - legacy switch to ONLY return the next occurrence as a date and not return a hash
 
 === SUPER IMPORTANT NOTE ABOUT NEXT OCCURRENCE & START DATE
@@ -74,84 +74,237 @@ If you don't like that, fork and have fun but don't say I didn't warn ya.
   require 'rubygems'
   require 'tickle'
 
-  .Time.now
-  2010-05-07 14:01:19 -0400
-
 SIMPLE
-  Tickle.parse('day')  #=> {:next=>2010-05-08 14:01:19 -0400, :recurrence_expression=>"day", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('day')  #=> {:next=>2010-05-08 14:01:19 -0400, :recurrence_expression=>"day", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('week')  #=> {:next=>2010-05-14 14:01:19 -0400, :recurrence_expression=>"week", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('Month')  #=> {:next=>2010-06-07 14:01:19 -0400, :recurrence_expression=>"month", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('year')  #=> {:next=>2011-05-07 14:01:19 -0400, :recurrence_expression=>"year", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('daily')  #=> {:next=>2010-05-08 14:01:19 -0400, :recurrence_expression=>"daily", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('weekly')  #=> {:next=>2010-05-14 14:01:19 -0400, :recurrence_expression=>"weekly", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('monthly')  #=> {:next=>2010-06-07 14:01:19 -0400, :recurrence_expression=>"monthly", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('yearly')  #=> {:next=>2011-05-07 14:01:19 -0400, :recurrence_expression=>"yearly", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('3 days')  #=> {:next=>2010-05-10 14:01:19 -0400, :recurrence_expression=>"3 days", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('3 weeks')  #=> {:next=>2010-05-28 14:01:19 -0400, :recurrence_expression=>"3 weeks", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('3 months')  #=> {:next=>2010-08-08 14:01:19 -0400, :recurrence_expression=>"3 months", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('3 years')  #=> {:next=>2013-05-06 14:01:19 -0400, :recurrence_expression=>"3 years", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('other day')  #=> {:next=>2010-05-09 14:01:19 -0400, :recurrence_expression=>"other day", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('other week')  #=> {:next=>2010-05-21 14:01:19 -0400, :recurrence_expression=>"other week", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('other month')  #=> {:next=>2010-07-07 14:01:19 -0400, :recurrence_expression=>"other month", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('other year')  #=> {:next=>2012-05-07 14:01:19 -0400, :recurrence_expression=>"other year", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('Monday')  #=> {:next=>2010-05-10 12:00:00 -0400, :recurrence_expression=>"monday", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('Wednesday')  #=> {:next=>2010-05-12 12:00:00 -0400, :recurrence_expression=>"wednesday", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('Friday')  #=> {:next=>2010-05-14 12:00:00 -0400, :recurrence_expression=>"friday", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('May')  #=> {:next=>2011-05-01 12:00:00 -0400, :recurrence_expression=>"may", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('june')  #=> {:next=>2010-06-01 12:00:00 -0400, :recurrence_expression=>"june", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('beginning of the week')  #=> {:next=>2010-05-09 12:00:00 -0400, :recurrence_expression=>"beginning of the week", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('middle of the week')  #=> {:next=>2010-05-12 12:00:00 -0400, :recurrence_expression=>"middle of the week", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('end of the week')  #=> {:next=>2010-05-08 12:00:00 -0400, :recurrence_expression=>"end of the week", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('beginning of the month')  #=> {:next=>2010-06-01 00:00:00 -0400, :recurrence_expression=>"beginning of the month", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('middle of the month')  #=> {:next=>2010-05-15 00:00:00 -0400, :recurrence_expression=>"middle of the month", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('end of the month')  #=> {:next=>2010-05-31 00:00:00 -0400, :recurrence_expression=>"end of the month", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('beginning of the year')  #=> {:next=>2011-01-01 00:00:00 -0500, :recurrence_expression=>"beginning of the year", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('middle of the year')  #=> {:next=>2010-06-15 00:00:00 -0400, :recurrence_expression=>"middle of the year", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('end of the year')  #=> {:next=>2010-12-31 00:00:00 -0500, :recurrence_expression=>"end of the year", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the 3rd of May')  #=> {:next=>2011-05-03 12:00:00 -0400, :recurrence_expression=>"the 3rd of may", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the 3rd of February')  #=> {:next=>2011-02-03 12:00:00 -0500, :recurrence_expression=>"the 3rd of february", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the 3rd of February 2012')  #=> {:next=>2012-02-03 12:00:00 -0500, :recurrence_expression=>"the 3rd of february 2012", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the 3rd of Feb 2012')  #=> {:next=>2012-02-03 12:00:00 -0500, :recurrence_expression=>"the 3rd of feb 2012", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the 4th of the month')  #=> {:next=>2010-06-04 12:00:00 -0400, :recurrence_expression=>"the 4th of the month", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the 10th of the month')  #=> {:next=>2010-05-10 12:00:00 -0400, :recurrence_expression=>"the 10th of the month", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the tenth of the month')  #=> {:next=>2010-05-10 12:00:00 -0400, :recurrence_expression=>"the tenth of the month", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the first of the month')  #=> {:next=>2010-06-01 12:00:00 -0400, :recurrence_expression=>"the first of the month", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the thirtieth')  #=> {:next=>2010-05-30 12:00:00 -0400, :recurrence_expression=>"the thirtieth", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the fifth')  #=> {:next=>2010-06-05 12:00:00 -0400, :recurrence_expression=>"the fifth", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the 3rd Sunday of May')  #=> {:next=>2010-05-16 12:00:00 -0400, :recurrence_expression=>"the 3rd sunday of may", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the 3rd Sunday of the month')  #=> {:next=>2010-06-20 12:00:00 -0400, :recurrence_expression=>"the 3rd sunday of the month", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the 23rd of June')  #=> {:next=>2010-06-23 12:00:00 -0400, :recurrence_expression=>"the 23rd of june", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the twenty third of June')  #=> {:next=>2010-06-23 12:00:00 -0400, :recurrence_expression=>"the twenty third of june", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the thirty first of August')  #=> {:next=>2010-08-31 12:00:00 -0400, :recurrence_expression=>"the thirty first of august", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the twenty first')  #=> {:next=>2010-05-21 12:00:00 -0400, :recurrence_expression=>"the twenty first", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('the twenty first of the month')  #=> {:next=>2010-05-21 12:00:00 -0400, :recurrence_expression=>"the twenty first of the month", :starting=>2010-05-07 14:01:19 -0400}
-  
+    Tickle.parse('day')
+      #=> {:next=>2010-05-10 20:57:36 -0400, :expression=>"day", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('day')
+      #=> {:next=>2010-05-10 20:57:36 -0400, :expression=>"day", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('week')
+      #=> {:next=>2010-05-16 20:57:36 -0400, :expression=>"week", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('month')
+      #=> {:next=>2010-06-09 20:57:36 -0400, :expression=>"month", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('year')
+      #=> {:next=>2011-05-09 20:57:36 -0400, :expression=>"year", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('daily')
+      #=> {:next=>2010-05-10 20:57:36 -0400, :expression=>"daily", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('weekly')
+      #=> {:next=>2010-05-16 20:57:36 -0400, :expression=>"weekly", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('monthly')
+      #=> {:next=>2010-06-09 20:57:36 -0400, :expression=>"monthly", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('yearly')
+      #=> {:next=>2011-05-09 20:57:36 -0400, :expression=>"yearly", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('3 days')
+      #=> {:next=>2010-05-12 20:57:36 -0400, :expression=>"3 days", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('3 weeks')
+      #=> {:next=>2010-05-30 20:57:36 -0400, :expression=>"3 weeks", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('3 months')
+      #=> {:next=>2010-08-09 20:57:36 -0400, :expression=>"3 months", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('3 years')
+      #=> {:next=>2013-05-09 20:57:36 -0400, :expression=>"3 years", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('other day')
+      #=> {:next=>2010-05-11 20:57:36 -0400, :expression=>"other day", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('other week')
+      #=> {:next=>2010-05-23 20:57:36 -0400, :expression=>"other week", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('other month')
+      #=> {:next=>2010-07-09 20:57:36 -0400, :expression=>"other month", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('other year')
+      #=> {:next=>2012-05-09 20:57:36 -0400, :expression=>"other year", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('Monday')
+      #=> {:next=>2010-05-10 12:00:00 -0400, :expression=>"monday", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('Wednesday')
+      #=> {:next=>2010-05-12 12:00:00 -0400, :expression=>"wednesday", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('Friday')
+      #=> {:next=>2010-05-14 12:00:00 -0400, :expression=>"friday", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('February', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2021-02-01 12:00:00 -0500, :expression=>"february", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('May', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-05-01 12:00:00 -0400, :expression=>"may", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('june', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-06-01 12:00:00 -0400, :expression=>"june", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('beginning of the week')
+      #=> {:next=>2010-05-16 12:00:00 -0400, :expression=>"beginning of the week", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('middle of the week')
+      #=> {:next=>2010-05-12 12:00:00 -0400, :expression=>"middle of the week", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('end of the week')
+      #=> {:next=>2010-05-15 12:00:00 -0400, :expression=>"end of the week", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('beginning of the month', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-05-01 00:00:00 -0400, :expression=>"beginning of the month", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('middle of the month', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-04-15 00:00:00 -0400, :expression=>"middle of the month", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('end of the month', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-04-30 00:00:00 -0400, :expression=>"end of the month", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('beginning of the year', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2021-01-01 00:00:00 -0500, :expression=>"beginning of the year", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('middle of the year', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-06-15 00:00:00 -0400, :expression=>"middle of the year", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('end of the year', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-12-31 00:00:00 -0500, :expression=>"end of the year", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the 3rd of May', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-05-03 00:00:00 -0400, :expression=>"the 3rd of may", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the 3rd of February', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2021-02-03 00:00:00 -0500, :expression=>"the 3rd of february", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the 3rd of February 2022', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2022-02-03 00:00:00 -0500, :expression=>"the 3rd of february 2022", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the 3rd of Feb 2022', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2022-02-03 00:00:00 -0500, :expression=>"the 3rd of feb 2022", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the 4th of the month', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-04-04 00:00:00 -0400, :expression=>"the 4th of the month", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the 10th of the month', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-04-10 00:00:00 -0400, :expression=>"the 10th of the month", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the tenth of the month', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-04-10 00:00:00 -0400, :expression=>"the tenth of the month", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('first', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-05-01 00:00:00 -0400, :expression=>"first", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the first of the month', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-05-01 00:00:00 -0400, :expression=>"the first of the month", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the thirtieth', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-04-30 00:00:00 -0400, :expression=>"the thirtieth", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the fifth', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-04-05 00:00:00 -0400, :expression=>"the fifth", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the 1st Wednesday of the month', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-05-01 00:00:00 -0400, :expression=>"the 1st wednesday of the month", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the 3rd Sunday of May', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-05-17 12:00:00 -0400, :expression=>"the 3rd sunday of may", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the 3rd Sunday of the month', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-04-19 12:00:00 -0400, :expression=>"the 3rd sunday of the month", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the 23rd of June', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-06-23 00:00:00 -0400, :expression=>"the 23rd of june", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the twenty third of June', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-06-23 00:00:00 -0400, :expression=>"the twenty third of june", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the thirty first of July', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-07-31 00:00:00 -0400, :expression=>"the thirty first of july", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the twenty first', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-04-21 00:00:00 -0400, :expression=>"the twenty first", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
+    Tickle.parse('the twenty first of the month', {:start=>#<Date: 2020-04-01 (4917881/2,0,2299161)>, :now=>#<Date: 2020-04-01 (4917881/2,0,2299161)>})
+      #=> {:next=>2020-04-21 00:00:00 -0400, :expression=>"the twenty first of the month", :starting=>2020-04-01 00:00:00 -0400, :until=>nil}
+
 COMPLEX
-  Tickle.parse('starting Monday repeat every month')  #=> {:next=>2010-05-10 12:00:00 -0400, :recurrence_expression=>"month", :starting=>2010-05-10 12:00:00 -0400}
-  Tickle.parse('starting May 13th repeat every week')  #=> {:next=>2010-05-13 12:00:00 -0400, :recurrence_expression=>"week", :starting=>2010-05-13 12:00:00 -0400}
-  Tickle.parse('starting May 13th repeat every other day')  #=> {:next=>2010-05-13 12:00:00 -0400, :recurrence_expression=>"other day", :starting=>2010-05-13 12:00:00 -0400}
-  Tickle.parse('every week starts this wednesday')  #=> {:next=>2010-05-12 12:00:00 -0400, :recurrence_expression=>"week", :starting=>2010-05-12 12:00:00 -0400}
-  Tickle.parse('every other day starts the 1st May')  #=> {:next=>2011-05-01 12:00:00 -0400, :recurrence_expression=>"other day", :starting=>2011-05-01 12:00:00 -0400}
-  Tickle.parse('every other day starting May 6')  #=> {:next=>2010-05-09 14:01:19 -0400, :recurrence_expression=>"other day", :starting=>2010-05-07 14:01:19 -0400}
-  Tickle.parse('every week starting this wednesday')  #=> {:next=>2010-05-12 12:00:00 -0400, :recurrence_expression=>"week", :starting=>2010-05-12 12:00:00 -0400}
-  Tickle.parse('every other day starting the 1st May')  #=> {:next=>2011-05-01 12:00:00 -0400, :recurrence_expression=>"other day", :starting=>2011-05-01 12:00:00 -0400}
-  Tickle.parse('every other day starting May 1st 2011')  #=> {:next=>2011-05-01 12:00:00 -0400, :recurrence_expression=>"other day", :starting=>2011-05-01 12:00:00 -0400}
-  Tickle.parse('every other week starting this Sunday')  #=> {:next=>2010-05-09 12:00:00 -0400, :recurrence_expression=>"other week", :starting=>2010-05-09 12:00:00 -0400}
-  Tickle.parse('every week starting this wednesday until June 5th')  #=> {:next=>2010-05-14 14:01:19 -0400, :recurrence_expression=>"week", :starting=>2010-05-07 14:01:19 -0400, :until=>2010-06-05 12:00:00 -0400}
-  Tickle.parse('every week starting this wednesday ends June 5th')  #=> {:next=>2010-05-14 14:01:19 -0400, :recurrence_expression=>"week", :starting=>2010-05-07 14:01:19 -0400, :until=>2010-06-05 12:00:00 -0400}
-  Tickle.parse('every week starting this wednesday ending June 5th')  #=> {:next=>2010-05-14 14:01:19 -0400, :recurrence_expression=>"week", :starting=>2010-05-07 14:01:19 -0400, :until=>2010-06-05 12:00:00 -0400}
-  
-WITH OPTIONS HASH  
-  .Tickle.parse('May 1st 2011, {:next_only=>true}')  #=> 2011-05-01 12:00:00 -0400
-  Tickle.parse('every 3 days, {:start=>Mon, 17 May 2010}')  #=> {:next=>2010-05-17 00:00:00 -0400, :recurrence_expression=>"every 3 days", :starting=>2010-05-17 00:00:00 -0400}
-  Tickle.parse('every 3 weeks, {:start=>Mon, 17 May 2010}')  #=> {:next=>2010-05-17 00:00:00 -0400, :recurrence_expression=>"every 3 weeks", :starting=>2010-05-17 00:00:00 -0400}
-  Tickle.parse('every 3 months, {:start=>Mon, 17 May 2010}')  #=> {:next=>2010-05-17 00:00:00 -0400, :recurrence_expression=>"every 3 months", :starting=>2010-05-17 00:00:00 -0400}
-  Tickle.parse('every 3 years, {:start=>Mon, 17 May 2010}')  #=> {:next=>2010-05-17 00:00:00 -0400, :recurrence_expression=>"every 3 years", :starting=>2010-05-17 00:00:00 -0400}
-  Tickle.parse('every 3 days, {:start=>Mon, 17 May 2010, :until=>Thu, 07 Oct 2010}')  #=> {:next=>2010-05-17 00:00:00 -0400, :recurrence_expression=>"every 3 days", :starting=>2010-05-17 00:00:00 -0400, :until=>2010-10-07 00:00:00 -0400}
-  Tickle.parse('every 3 weeks, {:start=>Mon, 17 May 2010, :until=>Thu, 07 Oct 2010}')  #=> {:next=>2010-05-17 00:00:00 -0400, :recurrence_expression=>"every 3 weeks", :starting=>2010-05-17 00:00:00 -0400, :until=>2010-10-07 00:00:00 -0400}
-  Tickle.parse('3 months, {:until=>Thu, 07 Oct 2010}')  #=> {:next=>2010-08-08 14:01:19 -0400, :recurrence_expression=>"3 months", :starting=>2010-05-07 14:01:19 -0400, :until=>2010-10-07 00:00:00 -0400}
-  .
+    Tickle.parse('starting today and ending one week from now')
+      #=> {:next=>2010-05-10 22:30:00 -0400, :expression=>"day", :starting=>2010-05-09 22:30:00 -0400, :until=>2010-05-16 20:57:35 -0400}
+
+    Tickle.parse('starting tomorrow and ending one week from now')
+      #=> {:next=>2010-05-10 12:00:00 -0400, :expression=>"day", :starting=>2010-05-10 12:00:00 -0400, :until=>2010-05-16 20:57:35 -0400}
+
+    Tickle.parse('starting Monday repeat every month')
+      #=> {:next=>2010-05-10 12:00:00 -0400, :expression=>"month", :starting=>2010-05-10 12:00:00 -0400, :until=>nil}
+
+    Tickle.parse('starting May 13th repeat every week')
+      #=> {:next=>2010-05-13 12:00:00 -0400, :expression=>"week", :starting=>2010-05-13 12:00:00 -0400, :until=>nil}
+
+    Tickle.parse('starting May 13th repeat every other day')
+      #=> {:next=>2010-05-13 12:00:00 -0400, :expression=>"other day", :starting=>2010-05-13 12:00:00 -0400, :until=>nil}
+
+    Tickle.parse('every other day starts May 13th')
+      #=> {:next=>2010-05-13 12:00:00 -0400, :expression=>"other day", :starting=>2010-05-13 12:00:00 -0400, :until=>nil}
+
+    Tickle.parse('every other day starts May 13')
+      #=> {:next=>2010-05-13 12:00:00 -0400, :expression=>"other day", :starting=>2010-05-13 12:00:00 -0400, :until=>nil}
+
+    Tickle.parse('every other day starting May 13th')
+      #=> {:next=>2010-05-13 12:00:00 -0400, :expression=>"other day", :starting=>2010-05-13 12:00:00 -0400, :until=>nil}
+
+    Tickle.parse('every other day starting May 13')
+      #=> {:next=>2010-05-13 12:00:00 -0400, :expression=>"other day", :starting=>2010-05-13 12:00:00 -0400, :until=>nil}
+
+    Tickle.parse('every week starts this wednesday')
+      #=> {:next=>2010-05-12 12:00:00 -0400, :expression=>"week", :starting=>2010-05-12 12:00:00 -0400, :until=>nil}
+
+    Tickle.parse('every week starting this wednesday')
+      #=> {:next=>2010-05-12 12:00:00 -0400, :expression=>"week", :starting=>2010-05-12 12:00:00 -0400, :until=>nil}
+
+    Tickle.parse('every other day starting May 1st 2021')
+      #=> {:next=>2021-05-01 12:00:00 -0400, :expression=>"other day", :starting=>2021-05-01 12:00:00 -0400, :until=>nil}
+
+    Tickle.parse('every other day starting May 1 2021')
+      #=> {:next=>2021-05-01 12:00:00 -0400, :expression=>"other day", :starting=>2021-05-01 12:00:00 -0400, :until=>nil}
+
+    Tickle.parse('every other week starting this Sunday')
+      #=> {:next=>2010-05-16 12:00:00 -0400, :expression=>"other week", :starting=>2010-05-16 12:00:00 -0400, :until=>nil}
+
+    Tickle.parse('every week starting this wednesday until May 13th')
+      #=> {:next=>2010-05-12 12:00:00 -0400, :expression=>"week", :starting=>2010-05-12 12:00:00 -0400, :until=>2010-05-13 12:00:00 -0400}
+
+    Tickle.parse('every week starting this wednesday ends May 13th')
+      #=> {:next=>2010-05-12 12:00:00 -0400, :expression=>"week", :starting=>2010-05-12 12:00:00 -0400, :until=>2010-05-13 12:00:00 -0400}
+
+    Tickle.parse('every week starting this wednesday ending May 13th')
+      #=> {:next=>2010-05-12 12:00:00 -0400, :expression=>"week", :starting=>2010-05-12 12:00:00 -0400, :until=>2010-05-13 12:00:00 -0400}
+
+
+OPTIONS HASH
+    Tickle.parse('May 1st 2020', {:next_only=>true})
+      #=> 2020-05-01 00:00:00 -0400
+
+    Tickle.parse('3 days', {:start=>2010-05-09 20:57:36 -0400})
+      #=> {:next=>2010-05-12 20:57:36 -0400, :expression=>"3 days", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('3 weeks', {:start=>2010-05-09 20:57:36 -0400})
+      #=> {:next=>2010-05-30 20:57:36 -0400, :expression=>"3 weeks", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('3 months', {:start=>2010-05-09 20:57:36 -0400})
+      #=> {:next=>2010-08-09 20:57:36 -0400, :expression=>"3 months", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('3 years', {:start=>2010-05-09 20:57:36 -0400})
+      #=> {:next=>2013-05-09 20:57:36 -0400, :expression=>"3 years", :starting=>2010-05-09 20:57:36 -0400, :until=>nil}
+
+    Tickle.parse('3 days', {:start=>2010-05-09 20:57:36 -0400, :until=>2010-10-09 00:00:00 -0400})
+      #=> {:next=>2010-05-12 20:57:36 -0400, :expression=>"3 days", :starting=>2010-05-09 20:57:36 -0400, :until=>2010-10-09 00:00:00 -0400}
+
+    Tickle.parse('3 weeks', {:start=>2010-05-09 20:57:36 -0400, :until=>2010-10-09 00:00:00 -0400})
+      #=> {:next=>2010-05-30 20:57:36 -0400, :expression=>"3 weeks", :starting=>2010-05-09 20:57:36 -0400, :until=>2010-10-09 00:00:00 -0400}
+
+    Tickle.parse('3 months', {:until=>2010-10-09 00:00:00 -0400})
+      #=> {:next=>2010-08-09 20:57:36 -0400, :expression=>"3 months", :starting=>2010-05-09 20:57:36 -0400, :until=>2010-10-09 00:00:00 -0400}
 
 == USING IN APP
 
@@ -159,7 +312,7 @@ To use in your app, we recommend adding two attributes to your database model:
 * next_occurrence
 * tickle_expression
 
-Then call Tickle.parse(query) when you need to and save the results accordingly.  In your 
+Then call Tickle.parse(date expression) when you need to and save the results accordingly.  In your 
 code, each day, simply check to see if today is >= next_occurrence and, if so, run your block.
 
 After it completes, call Tickle.parse(tickle_expression) again to update the next occurrence of the event.
@@ -167,10 +320,11 @@ After it completes, call Tickle.parse(tickle_expression) again to update the nex
 
 == TESTING
 
-Tickle comes with a full testing suite that tests and shows sample output for simple, complex, options hash and invalid arguments.
+Tickle comes with a full testing suite for simple, complex, options hash and invalid arguments.
 
-Please note, the tests were designed to output the parsed expression and not return true.  This allows (and sorry, forces you) to have to skim through the 
-results and queries to ensure they are working correctly.  You can also add your own for fun.
+You also have some command line options:
+    --v     verbose output like the examples above
+    --d     debug output showing the guts of a date expression
 
 == LIMITATIONS
 

data/VERSION

@@ -1 +1 @@
-0.1.5
+0.1.6

data/git-flow-version

@@ -1 +1 @@
-GITFLOW_VERSION=0.1.5
+GITFLOW_VERSION=0.1.6

data/lib/tickle/handler.rb

@@ -1,11 +1,13 @@
 module Tickle #:nodoc:
   class << self #:nodoc:
 
-    # The heavy lifting.  Goes through each token groupings to determine what natural language should either by 
-    # parsed by Chronic or returned.  This methodology makes extension fairly simple, as new token types can be 
+    # The heavy lifting.  Goes through each token groupings to determine what natural language should either by
+    # parsed by Chronic or returned.  This methodology makes extension fairly simple, as new token types can be
     # easily added in repeater and then processed by the guess method
     #
     def guess()
+      return nil if @tokens.empty?
+
       guess_unit_types
       guess_weekday unless @next
       guess_month_names unless @next
@@ -15,46 +17,52 @@ module Tickle #:nodoc:
       guess_special unless @next
 
       # check to see if next is less than now and, if so, set it to next year
-      @next = Time.local(@next.year + 1, @next.month, @next.day, @next.hour, @next.min, @next.sec) if @next && @next.to_date < @start.to_date 
+      @next = Time.local(@next.year + 1, @next.month, @next.day, @next.hour, @next.min, @next.sec) if @next && @next.to_date < @start.to_date
 
       # return the next occurrence
       return @next.to_time if @next
     end
 
     def guess_unit_types
-      interval = 1 if token_types.same?([:day])
-      interval = 7 if token_types.same?([:week])
-      interval = Tickle.days_in_month if token_types.same?([:month])
-      interval = 365 if token_types.same?([:year])
-      compute_next(interval)
+      @next = @start.bump(:day) if token_types.same?([:day])
+      @next = @start.bump(:week) if token_types.same?([:week])
+      @next = @start.bump(:month) if token_types.same?([:month])
+      @next = @start.bump(:year) if token_types.same?([:year])
     end
 
     def guess_weekday
-      @next = chronic_parse("#{token_of_type(:weekday).start.to_s}") if token_types.same?([:weekday])
+      @next = chronic_parse_with_start("#{token_of_type(:weekday).start.to_s}") if token_types.same?([:weekday])
     end
 
     def guess_month_names
-      @next = chronic_parse("#{token_of_type(:month_name).start.to_s} 1") if token_types.same?([:month_name])
+      @next = chronic_parse_with_start("#{Date::MONTHNAMES[token_of_type(:month_name).start]} 1") if token_types.same?([:month_name])
     end
 
     def guess_number_and_unit
-      interval = token_of_type(:number).interval if token_types.same?([:number, :day])
-      interval = (token_of_type(:number).interval * 7) if token_types.same?([:number, :week])
-      interval = (token_of_type(:number).interval * Tickle.days_in_month) if token_types.same?([:number, :month])
-      interval = (token_of_type(:number).interval * 365) if token_types.same?([:number, :year])
-      compute_next(interval)
+      @next = @start.bump(:day, token_of_type(:number).interval) if token_types.same?([:number, :day])
+      @next = @start.bump(:week, token_of_type(:number).interval) if token_types.same?([:number, :week])
+      @next = @start.bump(:month, token_of_type(:number).interval) if token_types.same?([:number, :month])
+      @next = @start.bump(:year, token_of_type(:number).interval) if token_types.same?([:number, :year])
     end
 
     def guess_ordinal
-      @next = chronic_parse("#{token_of_type(:ordinal).word} day in #{Date::MONTHNAMES[get_next_month(token_of_type(:ordinal).start)]}") if token_types.same?([:ordinal]) 
+      @next = handle_same_day_chronic_issue(@start.year, @start.month, token_of_type(:ordinal).start) if token_types.same?([:ordinal])
     end
 
     def guess_ordinal_and_unit
-      @next = chronic_parse("#{token_of_type(:ordinal).word} day in #{token_of_type(:month_name).start.to_s} ") if token_types.same?([:ordinal, :month_name])
-      @next = chronic_parse("#{token_of_type(:ordinal).word} day in #{Date::MONTHNAMES[get_next_month(token_of_type(:ordinal).start)]}") if token_types.same?([:ordinal, :month]) 
-      @next = chronic_parse("#{token_of_type(:ordinal).word} #{token_of_type(:weekday).start.to_s} in #{token_of_type(:month_name).start.to_s}") if token_types.same?([:ordinal, :weekday, :month_name]) 
-      @next = chronic_parse("#{token_of_type(:ordinal).word} #{token_of_type(:weekday).start.to_s} in #{Date::MONTHNAMES[get_next_month(token_of_type(:ordinal).start)]}") if token_types.same?([:ordinal, :weekday, :month]) 
-      @next = chronic_parse("#{token_of_type(:month_name).word} #{token_of_type(:ordinal).start} #{token_of_type(:specific_year).word}") if token_types.same?([:ordinal, :month_name, :specific_year])
+      @next = handle_same_day_chronic_issue(@start.year, token_of_type(:month_name).start, token_of_type(:ordinal).start) if token_types.same?([:ordinal, :month_name])
+      @next = handle_same_day_chronic_issue(@start.year, @start.month, token_of_type(:ordinal).start) if token_types.same?([:ordinal, :month])
+      @next = handle_same_day_chronic_issue(token_of_type(:specific_year).word, token_of_type(:month_name).start, token_of_type(:ordinal).start) if token_types.same?([:ordinal, :month_name, :specific_year])
+
+      if token_types.same?([:ordinal, :weekday, :month_name])
+        @next = chronic_parse_with_start("#{token_of_type(:ordinal).word} #{token_of_type(:weekday).start.to_s} in #{Date::MONTHNAMES[token_of_type(:month_name).start]}")
+        @next = handle_same_day_chronic_issue(@start.year, token_of_type(:month_name).start, token_of_type(:ordinal).start) if @next.to_date == @start.to_date
+      end
+
+      if token_types.same?([:ordinal, :weekday, :month])
+        @next = chronic_parse_with_start("#{token_of_type(:ordinal).word} #{token_of_type(:weekday).start.to_s} in #{Date::MONTHNAMES[get_next_month(token_of_type(:ordinal).start)]}")
+        @next = handle_same_day_chronic_issue(@start.year, @start.month, token_of_type(:ordinal).start) if @next.to_date == @start.to_date
+      end
     end
 
     def guess_special
@@ -67,27 +75,26 @@ module Tickle #:nodoc:
     private
 
     def guess_special_other
-      interval = 2 if token_types.same?([:special, :day]) && token_of_type(:special).start == :other
-      interval = 14 if token_types.same?([:special, :week]) && token_of_type(:special).start == :other
-      @next = chronic_parse('2 months from now') if token_types.same?([:special, :month]) && token_of_type(:special).start == :other 
-      @next = chronic_parse('2 years from now') if token_types.same?([:special, :year]) && token_of_type(:special).start == :other 
-      compute_next(interval)
+      @next = @start.bump(:day, 2) if token_types.same?([:special, :day]) && token_of_type(:special).start == :other
+      @next = @start.bump(:week, 2)  if token_types.same?([:special, :week]) && token_of_type(:special).start == :other
+      @next = chronic_parse_with_start('2 months from now') if token_types.same?([:special, :month]) && token_of_type(:special).start == :other
+      @next = chronic_parse_with_start('2 years from now') if token_types.same?([:special, :year]) && token_of_type(:special).start == :other
     end
 
     def guess_special_beginning
-      if token_types.same?([:special, :week]) && token_of_type(:special).start == :beginning then @next = chronic_parse('Sunday'); end
+      if token_types.same?([:special, :week]) && token_of_type(:special).start == :beginning then @next = chronic_parse_with_start('Sunday'); end
       if token_types.same?([:special, :month]) && token_of_type(:special).start == :beginning then @next = Date.civil(@start.year, @start.month + 1, 1); end
       if token_types.same?([:special, :year]) && token_of_type(:special).start == :beginning then @next = Date.civil(@start.year+1, 1, 1); end
     end
 
     def guess_special_end
-      if token_types.same?([:special, :week]) && token_of_type(:special).start == :end then @next = chronic_parse('Saturday'); end
+      if token_types.same?([:special, :week]) && token_of_type(:special).start == :end then @next = chronic_parse_with_start('Saturday'); end
       if token_types.same?([:special, :month]) && token_of_type(:special).start == :end then @next = Date.civil(@start.year, @start.month, -1); end
       if token_types.same?([:special, :year]) && token_of_type(:special).start == :end then @next = Date.new(@start.year, 12, 31); end
     end
 
     def guess_special_middle
-      if token_types.same?([:special, :week]) && token_of_type(:special).start == :middle then @next = chronic_parse('Wednesday'); end
+      if token_types.same?([:special, :week]) && token_of_type(:special).start == :middle then @next = chronic_parse_with_start('Wednesday'); end
       if token_types.same?([:special, :month]) && token_of_type(:special).start == :middle then
         @next = (@start.day > 15 ? Date.civil(@start.year, @start.month + 1, 15) : Date.civil(@start.year, @start.month, 15))
       end
@@ -102,16 +109,19 @@ module Tickle #:nodoc:
 
     private
 
-    def compute_next(interval)
-      # defines the next occurrence of this tickle if not set in a guess routine
-      @next ||= @start + (interval * 60 * 60 * 24) if interval
-    end
-    
-    def chronic_parse(exp)
-      puts "date expression: #{exp}" if Tickle.debug
+    # runs Chronic.parse with now being set to the specified start date for Tickle parsing
+    def chronic_parse_with_start(exp)
+      Tickle.dwrite("date expression: #{exp}, start: #{@start}")
       Chronic.parse(exp, :now => @start)
     end
 
+    # needed to handle the unique situation where a number or ordinal plus optional month or month name is passed that is EQUAL to the start date since Chronic returns that day.
+    def handle_same_day_chronic_issue(year, month, day)
+      Tickle.dwrite("year (#{year}), month (#{month}), day (#{day})")
+      arg_date = (Date.new(year.to_i, month.to_i, day.to_i) == @start.to_date) ? Time.local(year, month+1, day) : Time.local(year, month, day)
+      return arg_date
+    end
+
 
   end
 end

data/lib/tickle/repeater.rb

@@ -47,7 +47,7 @@ class Tickle::Repeater < Chronic::Tag #:nodoc:
     scanner.keys.each do |scanner_item|
       if scanner_item =~ token.original
         token.word = scanner[scanner_item]
-        token.update(:ordinal, numericize_ordinals(scanner[scanner_item]), Tickle.days_in_month(Tickle.get_next_month(numericize_ordinals(scanner[scanner_item]))))
+        token.update(:ordinal, scanner[scanner_item].ordinal_as_number, Tickle.days_in_month(Tickle.get_next_month(scanner[scanner_item].ordinal_as_number)))
       end
     end
     token
@@ -57,24 +57,24 @@ class Tickle::Repeater < Chronic::Tag #:nodoc:
     regex = /\b(\d*)(st|nd|rd|th)\b/
     if token.original =~ regex
       token.word = token.original
-      token.update(:ordinal, numericize_ordinals(token.word), Tickle.days_in_month(Tickle.get_next_month(token.word)))
+      token.update(:ordinal, token.word.ordinal_as_number, Tickle.days_in_month(Tickle.get_next_month(token.word)))
     end
     token
   end
 
   def self.scan_for_month_names(token)
-    scanner = {/^jan\.?(uary)?$/ => :january,
-      /^feb\.?(ruary)?$/ => :february,
-      /^mar\.?(ch)?$/ => :march,
-      /^apr\.?(il)?$/ => :april,
-      /^may$/ => :may,
-      /^jun\.?e?$/ => :june,
-      /^jul\.?y?$/ => :july,
-      /^aug\.?(ust)?$/ => :august,
-      /^sep\.?(t\.?|tember)?$/ => :september,
-      /^oct\.?(ober)?$/ => :october,
-      /^nov\.?(ember)?$/ => :november,
-    /^dec\.?(ember)?$/ => :december}
+    scanner = {/^jan\.?(uary)?$/ => 1,
+      /^feb\.?(ruary)?$/ => 2,
+      /^mar\.?(ch)?$/ => 3,
+      /^apr\.?(il)?$/ => 4,
+      /^may$/ => 5,
+      /^jun\.?e?$/ => 6,
+      /^jul\.?y?$/ => 7,
+      /^aug\.?(ust)?$/ => 8,
+      /^sep\.?(t\.?|tember)?$/ => 9,
+      /^oct\.?(ober)?$/ => 10,
+      /^nov\.?(ember)?$/ => 11,
+    /^dec\.?(ember)?$/ => 12}
     scanner.keys.each do |scanner_item|
       token.update(:month_name, scanner[scanner_item], 30) if scanner_item =~ token.word
     end
@@ -132,10 +132,5 @@ class Tickle::Repeater < Chronic::Tag #:nodoc:
     token
   end
 
-  # Convert ordinal words to numeric ordinals (third => 3rd)
-  def self.numericize_ordinals(text) #:nodoc:
-    text = text.gsub(/\b(\d*)(st|nd|rd|th)\b/, '\1')
-  end
-
 
 end

data/lib/tickle/tickle.rb

@@ -25,17 +25,17 @@ module Tickle  #:nodoc:
     #
     # * +start+ - start date for future occurrences.  Must be in valid date format.
     # * +until+ - last date to run occurrences until.  Must be in valid date format.
-    # 
+    #
     #  Use by calling Tickle.parse and passing natural language with or without options.
-    #      
+    #
     #  def get_next_occurrence
     #      results = Tickle.parse('every Wednesday starting June 1st until Dec 15th')
     #      return results[:next] if results
     #  end
     #
     def parse(text, specified_options = {})
-      # get options and set defaults if necessary
-      default_options = {:start => Time.now, :next_only => false, :until  => nil}
+      # get options and set defaults if necessary.  Ability to set now is mostly for debugging
+      default_options = {:start => Time.now, :next_only => false, :until => nil, :now => Time.now}
       options = default_options.merge specified_options
 
       # ensure an expression was provided
@@ -52,13 +52,16 @@ module Tickle  #:nodoc:
 
       # check to see if this event starts some other time and reset now
       event = scan_expression(text, options)
+      
+      Tickle.dwrite("start: #{@start}, until: #{@until}, now: #{options[:now].to_date}")
 
-      raise(InvalidDateExpression, "the start date (#{@start.to_date}) for a recurring event cannot occur in the past ") if @start.to_date < Date.today
+      # => ** this is mostly for testing. Bump by 1 day if today (or in the past for testing)
+      raise(InvalidDateExpression, "the start date (#{@start.to_date}) cannot occur in the past for a future event") if @start && @start.to_date < Date.today
       raise(InvalidDateExpression, "the start date (#{@start.to_date}) cannot occur after the end date") if @until && @start.to_date > @until.to_date
 
       # no need to guess at expression if the start_date is in the future
       best_guess = nil
-      if @start.to_time > Time.now
+      if @start.to_date > options[:now].to_date
         best_guess = @start
       else
         # put the text into a normal format to ease scanning using Chronic
@@ -70,7 +73,7 @@ module Tickle  #:nodoc:
         # process each original word for implied word
         post_tokenize
 
-        # @tokens.each {|x| puts x.inspect} if Tickle.debug
+        @tokens.each {|x| Tickle.dwrite("raw: #{x.inspect}")}
 
         # scan the tokens with each token scanner
         @tokens = Repeater.scan(@tokens)
@@ -81,9 +84,10 @@ module Tickle  #:nodoc:
         # combine number and ordinals into single number
         combine_multiple_numbers
 
-        @tokens.each {|x| puts x.inspect} if Tickle.debug
+        @tokens.each {|x| Tickle.dwrite("processed: #{x.inspect}")}
 
-        best_guess = guess
+        # if we can't guess it maybe chronic can
+        best_guess = (guess || chronic_parse(event))
       end
 
       raise(InvalidDateExpression, "the next occurrence takes place after the end date specified") if @until && best_guess.to_date > @until.to_date
@@ -101,30 +105,57 @@ module Tickle  #:nodoc:
     def scan_expression(text, options)
       starting = ending = nil
 
-      start_every_regex = /^(start(?:s|ing)?)\s(.*)(\s(?:every|each|on|repeat)(?:s|ing)?)(.*)/i
-      every_start_regex = /^(every|each|on|repeat(?:the)?)\s(.*)(\s(?:start)(?:s|ing)?)(.*)/i
+      start_every_regex = /^(start(?:s|ing)?)\s(.*)(\s(?:every|each|\bon\b|repeat)(?:s|ing)?)(.*)/i
+      every_start_regex = /^(every|each|\bon\b|repeat(?:the)?)\s(.*)(\s(?:start)(?:s|ing)?)(.*)/i
+      start_ending_regex = /^(start(?:s|ing)?)\s(.*)(\s(?:\bend|until)(?:s|ing)?)(.*)/i
       if text =~ start_every_regex
-        starting = text.match(start_every_regex)[2]
-        text = text.match(start_every_regex)[4]
+        starting = text.match(start_every_regex)[2].strip
+        text = text.match(start_every_regex)[4].strip
         event, ending = process_for_ending(text)
       elsif text =~ every_start_regex
-        event = text.match(every_start_regex)[2]
-        text = text.match(every_start_regex)[4]
+        event = text.match(every_start_regex)[2].strip
+        text = text.match(every_start_regex)[4].strip
         starting, ending = process_for_ending(text)
+      elsif text =~ start_ending_regex
+        starting = text.match(start_ending_regex)[2].strip
+        ending = text.match(start_ending_regex)[4].strip
+        event = 'day'
       else
         event, ending = process_for_ending(text)
       end
 
-      @start = (starting && Tickle.parse(pre_filter(starting), {:next_only => true}) || options[:start]).to_time
-      @until = (ending && Tickle.parse(pre_filter(ending), {:next_only => true})  || options[:until])
-      @until = @until.to_time if @until
+      # they gave a phrase so if we can't interpret then we need to raise an error
+      if starting
+        Tickle.dwrite("starting: #{starting}")
+        @start = chronic_parse(pre_filter(starting))
+        if @start
+          @start.to_time
+        else
+          raise(InvalidDateExpression,"the starting date expression \"#{starting}\" could not be interpretted")
+        end
+      else
+        @start = options[:start].to_time rescue nil
+      end
+
+      if ending
+        @until = chronic_parse(pre_filter(ending))
+        if @until
+          @until.to_time
+        else
+          raise(InvalidDateExpression,"the ending date expression \"#{ending}\" could not be interpretted")
+        end
+      else
+        @until = options[:until].to_time rescue nil
+      end
+
       @next = nil
+
       return event
     end
 
     # process the remaining expression to see if an until, end, ending is specified
     def process_for_ending(text)
-      regex = /^(.*)(\s(?:end|until)(?:s|ing)?)(.*)/i
+      regex = /^(.*)(\s(?:\bend|until)(?:s|ing)?)(.*)/i
       if text =~ regex
         return text.match(regex)[1], text.match(regex)[3]
       else
@@ -166,21 +197,21 @@ module Tickle  #:nodoc:
       normalized_text = Numerizer.numerize(normalized_text)
       normalized_text.gsub!(/['"\.]/, '')
       normalized_text.gsub!(/([\/\-\,\@])/) { ' ' + $1 + ' ' }
-      normalized_text.gsub!(/\btoday\b/, 'this day')
-      normalized_text.gsub!(/\btomm?orr?ow\b/, 'next day')
-      normalized_text.gsub!(/\byesterday\b/, 'last day')
-      normalized_text.gsub!(/\bnoon\b/, '12:00')
-      normalized_text.gsub!(/\bmidnight\b/, '24:00')
-      normalized_text.gsub!(/\bbefore now\b/, 'past')
-      normalized_text.gsub!(/\bnow\b/, 'this second')
-      normalized_text.gsub!(/\b(ago|before)\b/, 'past')
-      normalized_text.gsub!(/\bthis past\b/, 'last')
-      normalized_text.gsub!(/\bthis last\b/, 'last')
-      normalized_text.gsub!(/\b(?:in|during) the (morning)\b/, '\1')
-      normalized_text.gsub!(/\b(?:in the|during the|at) (afternoon|evening|night)\b/, '\1')
-      normalized_text.gsub!(/\btonight\b/, 'this night')
-      normalized_text.gsub!(/(?=\w)([ap]m|oclock)\b/, ' \1')
-      normalized_text.gsub!(/\b(hence|after|from)\b/, 'future')
+      # normalized_text.gsub!(/\btoday\b/, 'this day')
+      # normalized_text.gsub!(/\btomm?orr?ow\b/, 'next day')
+      # normalized_text.gsub!(/\byesterday\b/, 'last day')
+      # normalized_text.gsub!(/\bnoon\b/, '12:00')
+      # normalized_text.gsub!(/\bmidnight\b/, '24:00')
+      # normalized_text.gsub!(/\bbefore now\b/, 'past')
+      # normalized_text.gsub!(/\bnow\b/, 'this second')
+      # normalized_text.gsub!(/\b(ago|before)\b/, 'past')
+      # normalized_text.gsub!(/\bthis past\b/, 'last')
+      # normalized_text.gsub!(/\bthis last\b/, 'last')
+      # normalized_text.gsub!(/\b(?:in|during) the (morning)\b/, '\1')
+      # normalized_text.gsub!(/\b(?:in the|during the|at) (afternoon|evening|night)\b/, '\1')
+      # normalized_text.gsub!(/\btonight\b/, 'this night')
+      # normalized_text.gsub!(/(?=\w)([ap]m|oclock)\b/, ' \1')
+      # normalized_text.gsub!(/\b(hence|after|from)\b/, 'future')
       normalized_text
     end
 
@@ -206,10 +237,10 @@ module Tickle  #:nodoc:
     protected
 
     # Returns the next available month based on the current day of the month.
-    # For example, if get_next_month(15) is called and today is the 10th, then it will return the 15th of this month.
-    # However, if get_next_month(15) is called and today is the 18th, it will return the 15th of next month.
+    # For example, if get_next_month(15) is called and the start date is the 10th, then it will return the 15th of this month.
+    # However, if get_next_month(15) is called and the start date is the 18th, it will return the 15th of next month.
     def get_next_month(number)
-      month = number.to_i < Date.today.day ? (Date.today.month == 12 ? 1 : Date.today.month + 1) : Date.today.month
+      month = number.to_i < @start.day ? (@start.month == 12 ? 1 : @start.month + 1) : @start.month
     end
 
     # Return the number of days in a specified month.
@@ -218,6 +249,19 @@ module Tickle  #:nodoc:
       month ||= Date.today.month
       days_in_mon = Date.civil(Date.today.year, month, -1).day
     end
+
+    private
+
+    # slightly modified chronic parser to ensure that the date found is in the future
+    # first we check to see if an explicit date was passed and, if so, dont do anything.
+    # if, however, a date expression was passed we evaluate and shift forward if needed
+    def chronic_parse(exp)
+      result = Chronic.parse(exp.ordinal_as_number)
+      result = Time.local(result.year + 1, result.month, result.day, result.hour, result.min, result.sec) if result && result.to_time < Time.now
+      Tickle.dwrite("Chronic.parse('#{exp}') # => #{result}")
+      result
+    end
+
   end
 
   class Token #:nodoc:

data/lib/tickle.rb

@@ -20,10 +20,10 @@ require 'tickle/repeater'
 module Tickle #:nodoc:
   VERSION = "0.1.5"
 
-  def self.debug; false; end
+  def self.debug=(val); @debug = val; end
 
-  def self.dwrite(msg)
-    puts msg if Tickle.debug
+  def self.dwrite(msg, line_feed=nil)
+    (line_feed ? p(">> #{msg}") : puts(">> #{msg}")) if @debug
   end
 
   def self.is_date(str)
@@ -43,6 +43,56 @@ class Date #:nodoc:
     d += 1 while Date.valid_civil?(y,m,d)
     d - 1
   end
+
+  def bump(attr, amount=nil)
+    amount ||= 1
+    case attr
+    when :day then
+      Date.civil(self.year, self.month, self.day + amount)
+    when :wday then
+      amount = Date::ABBR_DAYNAMES.index(amount) if amount.is_a?(String)
+      raise Exception, "specified day of week invalid.  Use #{Date::ABBR_DAYNAMES}" unless amount
+      diff = (amount > self.wday) ? (amount - self.wday) : (7 - (self.wday - amount))
+      Date.civil(self.year, self.month, self.day + diff)
+    when :week then
+      Date.civil(self.year, self.month, self.day + (7*amount))
+    when :month then
+      Date.civil(self.year, self.month+amount, self.day)
+    when :year then
+      Date.civil(self.year + amount, self.month, self.day)
+    else
+            raise Exception, "type \"#{attr}\" not supported."
+    end
+  end
+end
+
+class Time #:nodoc:
+  def bump(attr, amount=nil)
+    amount ||= 1
+    case attr
+    when :sec then
+      Time.local(self.year, self.month, self.day, self.hour, self.min, self.sec + amount)
+    when :min then
+      Time.local(self.year, self.month, self.day, self.hour, self.min + amount, self.sec)
+    when :hour then
+      Time.local(self.year, self.month, self.day, self.hour + amount, self.min, self.sec)
+    when :day then
+      Time.local(self.year, self.month, self.day + amount, self.hour, self.min, self.sec)
+    when :wday then
+      amount = Time::RFC2822_DAY_NAME.index(amount) if amount.is_a?(String)
+      raise Exception, "specified day of week invalid.  Use #{Time::RFC2822_DAY_NAME}" unless amount
+      diff = (amount > self.wday) ? (amount - self.wday) : (7 - (self.wday - amount))
+      Time.local(self.year, self.month, self.day + diff, self.hour, self.min, self.sec)
+    when :week then
+      Time.local(self.year, self.month, self.day + (amount * 7), self.hour, self.min, self.sec)
+    when :month then
+      Time.local(self.year, self.month + amount, self.day, self.hour, self.min, self.sec)
+    when :year then
+      Time.local(self.year + amount, self.month, self.day, self.hour, self.min, self.sec)
+    else
+      raise Exception, "type \"#{attr}\" not supported."
+    end
+  end
 end
 
 class String #:nodoc:
@@ -52,6 +102,35 @@ class String #:nodoc:
     regex = /\b(\d*)(st|nd|rd|th)\b/
     !(self =~ regex).nil? || scanner.include?(self.downcase)
   end
+
+  def ordinal_as_number
+    return self unless self.is_ordinal?
+    scanner = {/first/ => '1st',
+      /second/ => '2nd',
+      /third/ => '3rd',
+      /fourth/ => '4th',
+      /fifth/ => '5th',
+      /sixth/ => '6th',
+      /seventh/ => '7th',
+      /eighth/ => '8th',
+      /ninth/ => '9th',
+      /tenth/ => '10th',
+      /eleventh/ => '11th',
+      /twelfth/ => '12th',
+      /thirteenth/ => '13th',
+      /fourteenth/ => '14th',
+      /fifteenth/ => '15th',
+      /sixteenth/ => '16th',
+      /seventeenth/ => '17th',
+      /eighteenth/ => '18th',
+      /nineteenth/ => '19th',
+      /twentieth/ => '20th',
+      /thirtieth/ => '30th',
+    }
+    result = self
+    scanner.keys.each {|scanner_item| result = scanner[scanner_item] if scanner_item =~ self}
+    return result.gsub(/\b(\d*)(st|nd|rd|th)\b/, '\1')
+  end
 end
 
 class Array #:nodoc:

data/test/test_parsing.rb

@@ -5,113 +5,129 @@ require 'test/unit'
 class TestParsing < Test::Unit::TestCase
 
   def setup
-  end
+    Tickle.debug = (ARGV.detect {|a| a == '--d'})
+    @verbose = (ARGV.detect {|a| a == '--v'})
 
-  def test_parse_best_guess_simple
     puts "Time.now"
     p Time.now
 
-    parse_now('each day')
-
-    parse_now('every day')
-    parse_now('every week')
-    parse_now('every Month')
-    parse_now('every year')
-
-    parse_now('daily')
-    parse_now('weekly')
-    parse_now('monthly')
-    parse_now('yearly')
-
-    parse_now('every 3 days')
-    parse_now('every 3 weeks')
-    parse_now('every 3 months')
-    parse_now('every 3 years')
-
-    parse_now('every other day')
-    parse_now('every other week')
-    parse_now('every other month')
-    parse_now('every other year')
-
-    parse_now('every Monday')
-    parse_now('every Wednesday')
-    parse_now('every Friday')
-
-    parse_now('every May')
-    parse_now('every june')
-
-    parse_now('beginning of the week')
-    parse_now('middle of the week')
-    parse_now('end of the week')
-
-    parse_now('beginning of the month')
-    parse_now('middle of the month')
-    parse_now('end of the month')
-
-    parse_now('beginning of the year')
-    parse_now('middle of the year')
-    parse_now('end of the year')
-
-    parse_now('the 3rd of May')
-    parse_now('the 3rd of February')
-    parse_now('the 3rd of February 2012')
-    parse_now('the 3rd of Feb, 2012')
-
-    parse_now('the 4th of the month')
-    parse_now('the 10th of the month')
-    parse_now('the tenth of the month')
-
-    parse_now('the first of the month')
-    parse_now('the thirtieth')
-    parse_now('the fifth')
-
-    parse_now('the 3rd Sunday of May')
-    parse_now('the 3rd Sunday of the month')
-
-    parse_now('the 23rd of June')
-    parse_now('the twenty third of June')
-    parse_now('the thirty first of August')
+    @date = Date.today
+  end
 
-    parse_now('the twenty first')
-    parse_now('the twenty first of the month')
+  def test_parse_best_guess_simple
+    start = Date.new(2020, 04, 01)
+
+    assert_date_match(@date.bump(:day, 1), 'each day')
+    assert_date_match(@date.bump(:day, 1), 'every day')
+    assert_date_match(@date.bump(:week, 1), 'every week')
+    assert_date_match(@date.bump(:month, 1), 'every month')
+    assert_date_match(@date.bump(:year, 1), 'every year')
+
+    assert_date_match(@date.bump(:day, 1), 'daily')
+    assert_date_match(@date.bump(:week, 1) , 'weekly')
+    assert_date_match(@date.bump(:month, 1) , 'monthly')
+    assert_date_match(@date.bump(:year, 1) , 'yearly')
+
+    assert_date_match(@date.bump(:day, 3), 'every 3 days')
+    assert_date_match(@date.bump(:week, 3), 'every 3 weeks')
+    assert_date_match(@date.bump(:month, 3), 'every 3 months')
+    assert_date_match(@date.bump(:year, 3), 'every 3 years')
+
+    assert_date_match(@date.bump(:day, 2), 'every other day')
+    assert_date_match(@date.bump(:week, 2), 'every other week')
+    assert_date_match(@date.bump(:month, 2), 'every other month')
+    assert_date_match(@date.bump(:year, 2), 'every other year')
+
+    assert_date_match(@date.bump(:wday, 'Mon'), 'every Monday')
+    assert_date_match(@date.bump(:wday, 'Wed'), 'every Wednesday')
+    assert_date_match(@date.bump(:wday, 'Fri'), 'every Friday')
+
+    assert_date_match(Date.new(2021, 2, 1), 'every February', {:start => start, :now => start})
+    assert_date_match(Date.new(2020, 5, 1), 'every May', {:start => start, :now => start})
+    assert_date_match(Date.new(2020, 6, 1), 'every june', {:start => start, :now => start})
+
+    assert_date_match(@date.bump(:wday, 'Sun'), 'beginning of the week')
+    assert_date_match(@date.bump(:wday, 'Wed'), 'middle of the week')
+    assert_date_match(@date.bump(:wday, 'Sat'), 'end of the week')
+
+    assert_date_match(Date.new(2020, 05, 01), 'beginning of the month', {:start => start, :now => start})
+    assert_date_match(Date.new(2020, 04, 15), 'middle of the month', {:start => start, :now => start})
+    assert_date_match(Date.new(2020, 04, 30), 'end of the month', {:start => start, :now => start})
+
+    assert_date_match(Date.new(2021, 01, 01), 'beginning of the year', {:start => start, :now => start})
+    assert_date_match(Date.new(2020, 06, 15), 'middle of the year', {:start => start, :now => start})
+    assert_date_match(Date.new(2020, 12, 31), 'end of the year', {:start => start, :now => start})
+
+    assert_date_match(Date.new(2020, 05, 03), 'the 3rd of May', {:start => start, :now => start})
+    assert_date_match(Date.new(2021, 02, 03), 'the 3rd of February', {:start => start, :now => start})
+    assert_date_match(Date.new(2022, 02, 03), 'the 3rd of February 2022', {:start => start, :now => start})
+    assert_date_match(Date.new(2022, 02, 03), 'the 3rd of Feb, 2022', {:start => start, :now => start})
+
+    assert_date_match(Date.new(2020, 04, 04), 'the 4th of the month', {:start => start, :now => start})
+    assert_date_match(Date.new(2020, 04, 10), 'the 10th of the month', {:start => start, :now => start})
+    assert_date_match(Date.new(2020, 04, 10), 'the tenth of the month', {:start => start, :now => start})
+
+    assert_date_match(Date.new(2020, 05, 01), 'first', {:start => start, :now => start})
+
+    assert_date_match(Date.new(2020, 05, 01), 'the first of the month', {:start => start, :now => start})
+    assert_date_match(Date.new(2020, 04, 30), 'the thirtieth', {:start => start, :now => start})
+    assert_date_match(Date.new(2020, 04, 05), 'the fifth', {:start => start, :now => start})
+
+    assert_date_match(Date.new(2020, 05, 01), 'the 1st Wednesday of the month', {:start => start, :now => start})
+    assert_date_match(Date.new(2020, 05, 17), 'the 3rd Sunday of May', {:start => start, :now => start})
+    assert_date_match(Date.new(2020, 04, 19), 'the 3rd Sunday of the month', {:start => start, :now => start})
+
+    assert_date_match(Date.new(2020, 06, 23), 'the 23rd of June', {:start => start, :now => start})
+    assert_date_match(Date.new(2020, 06, 23), 'the twenty third of June', {:start => start, :now => start})
+    assert_date_match(Date.new(2020, 07, 31), 'the thirty first of July', {:start => start, :now => start})
+
+    assert_date_match(Date.new(2020, 04, 21), 'the twenty first', {:start => start, :now => start})
+    assert_date_match(Date.new(2020, 04, 21), 'the twenty first of the month', {:start => start, :now => start})
   end
 
   def test_parse_best_guess_complex
-    puts "Time.now"
-    p Time.now
+    start = Date.new(2020, 04, 01)
 
-    parse_now('starting Monday repeat every month')
-    parse_now('starting May 13th repeat every week')
-    parse_now('starting May 13th repeat every other day')
+    assert_tickle_match(@date.bump(:day, 1), @date, @date.bump(:week, 1), 'day', 'starting today and ending one week from now') if Time.now.hour < 21 # => demonstrates leaving out the actual time period and implying it as daily
+    assert_tickle_match(@date.bump(:day, 1), @date.bump(:day, 1), @date.bump(:week, 1), 'day','starting tomorrow and ending one week from now') # => demonstrates leaving out the actual time period and implying it as daily.
 
-    parse_now('every week starts this wednesday')
-    parse_now('every other day starts the 1st May')
-    parse_now('every other day starting May 6')
-    parse_now('every week starting this wednesday')
-    parse_now('every other day starting the 1st May')
+    assert_tickle_match(@date.bump(:wday, 'Mon'), @date.bump(:wday, 'Mon'), nil, 'month', 'starting Monday repeat every month')
+    
+    year = @date >= Date.new(@date.year, 5, 13) ? @date.bump(:year,1) : @date.year
+    assert_tickle_match(Date.new(year, 05, 13), Date.new(year, 05, 13), nil, 'week', 'starting May 13th repeat every week')
+    assert_tickle_match(Date.new(year, 05, 13), Date.new(year, 05, 13), nil, 'other day', 'starting May 13th repeat every other day')
+    assert_tickle_match(Date.new(year, 05, 13), Date.new(year, 05, 13), nil, 'other day', 'every other day starts May 13th')
+    assert_tickle_match(Date.new(year, 05, 13), Date.new(year, 05, 13), nil, 'other day', 'every other day starts May 13')
+    assert_tickle_match(Date.new(year, 05, 13), Date.new(year, 05, 13), nil, 'other day', 'every other day starting May 13th')
+    assert_tickle_match(Date.new(year, 05, 13), Date.new(year, 05, 13), nil, 'other day', 'every other day starting May 13')
 
-    parse_now("every other day starting May 1st #{Date.today.year + 1}")
-    parse_now('every other week starting this Sunday')
+    assert_tickle_match(@date.bump(:wday, 'Wed'), @date.bump(:wday, 'Wed'), nil, 'week', 'every week starts this wednesday')
+    assert_tickle_match(@date.bump(:wday, 'Wed'), @date.bump(:wday, 'Wed'), nil, 'week', 'every week starting this wednesday')
 
-    parse_now('every week starting this wednesday until June 5th')
-    parse_now('every week starting this wednesday ends June 5th')
-    parse_now('every week starting this wednesday ending June 5th')
+    assert_tickle_match(Date.new(2021, 05, 01), Date.new(2021, 05, 01), nil, 'other day', "every other day starting May 1st #{start.bump(:year, 1).year}")
+    assert_tickle_match(Date.new(2021, 05, 01), Date.new(2021, 05, 01), nil, 'other day',  "every other day starting May 1 #{start.bump(:year, 1).year}")
+    assert_tickle_match(@date.bump(:wday, 'Sun'), @date.bump(:wday, 'Sun'),  nil, 'other week',  'every other week starting this Sunday')
+
+    assert_tickle_match(@date.bump(:wday, 'Wed'), @date.bump(:wday, 'Wed'), Date.new(year, 05, 13), 'week', 'every week starting this wednesday until May 13th')
+    assert_tickle_match(@date.bump(:wday, 'Wed'), @date.bump(:wday, 'Wed'), Date.new(year, 05, 13), 'week', 'every week starting this wednesday ends May 13th')
+    assert_tickle_match(@date.bump(:wday, 'Wed'), @date.bump(:wday, 'Wed'), Date.new(year, 05, 13), 'week', 'every week starting this wednesday ending May 13th')
 
   end
 
   def test_tickle_args
-    parse_now('May 1st, 2011', {:next_only => true})
-
-    start_date = Date.civil(Date.today.year, Date.today.month, Date.today.day + 10)
-    parse_now('every 3 days', {:start => start_date})
-    parse_now('every 3 weeks', {:start => start_date})
-    parse_now('every 3 months', {:start => start_date})
-    parse_now('every 3 years', {:start => start_date})
-
-    end_date = Date.civil(Date.today.year, Date.today.month+5, Date.today.day)
-    parse_now('every 3 days', {:start => start_date, :until  => end_date})
-    parse_now('every 3 weeks', {:start => start_date, :until  => end_date})
-    parse_now('every 3 months', {:until => end_date})
+    actual_next_only = parse_now('May 1st, 2020', {:next_only => true}).to_date
+    assert(Date.new(2020, 05, 01).to_date == actual_next_only, "\"May 1st, 2011\" :next parses to #{actual_next_only} but should be equal to #{Date.new(2020, 05, 01).to_date}")
+
+    start_date = Time.now
+    assert_tickle_match(start_date.bump(:day, 3), @date, nil, '3 days', 'every 3 days', {:start => start_date})
+    assert_tickle_match(start_date.bump(:week, 3), @date, nil, '3 weeks', 'every 3 weeks', {:start => start_date})
+    assert_tickle_match(start_date.bump(:month, 3), @date, nil, '3 months', 'every 3 months', {:start => start_date})
+    assert_tickle_match(start_date.bump(:year, 3), @date, nil, '3 years', 'every 3 years', {:start => start_date})
+
+    end_date = Date.civil(Date.today.year, Date.today.month+5, Date.today.day).to_time
+    assert_tickle_match(start_date.bump(:day, 3), @date, start_date.bump(:month, 5), '3 days', 'every 3 days', {:start => start_date, :until  => end_date})
+    assert_tickle_match(start_date.bump(:week, 3), @date, start_date.bump(:month, 5), '3 weeks', 'every 3 weeks', {:start => start_date, :until  => end_date})
+    assert_tickle_match(start_date.bump(:month, 3), @date, start_date.bump(:month, 5), '3 months', 'every 3 months', {:until => end_date})
   end
 
   def test_argument_validation
@@ -147,8 +163,27 @@ class TestParsing < Test::Unit::TestCase
   private
   def parse_now(string, options={})
     out = Tickle.parse(string, {}.merge(options))
-    puts (options.empty? ?  ("Tickle.parse('#{string}')  #=> #{out}") : ("Tickle.parse('#{string}, #{options}')  #=> #{out}"))
-    p '--' if Tickle.debug
+    puts (options.empty? ?  ("Tickle.parse('#{string}')\n\r  #=> #{out}\n\r") : ("Tickle.parse('#{string}', #{options})\n\r  #=> #{out}\n\r")) if @verbose
     out
   end
+
+  def assert_date_match(expected_next, date_expression, options={})
+    actual_next = parse_now(date_expression, options)[:next].to_date
+    assert (expected_next.to_date == actual_next.to_date), "\"#{date_expression}\" parses to #{actual_next} but should be equal to #{expected_next}"
+  end
+
+  def assert_tickle_match(expected_next, expected_start, expected_until, expected_expression, date_expression, options={})
+    result = parse_now(date_expression, options)
+    actual_next = result[:next].to_date
+    actual_start = result[:starting].to_date
+    actual_until = result[:until].to_date rescue nil
+    expected_until = expected_until.to_date rescue nil
+    actual_expression = result[:expression]
+    
+    assert (expected_next.to_date == actual_next.to_date), "\"#{date_expression}\" :next parses to #{actual_next} but should be equal to #{expected_next}"
+    assert (expected_start.to_date == actual_start.to_date), "\"#{date_expression}\" :starting parses to #{actual_start} but should be equal to #{expected_start}"
+    assert (expected_until == actual_until), "\"#{date_expression}\" :until parses to #{actual_until} but should be equal to #{expected_until}"
+    assert (expected_expression == actual_expression), "\"#{date_expression}\" :expression parses to \"#{actual_expression}\" but should be equal to \"#{expected_expression}\""
+  end
+
 end

data/tickle.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{tickle}
-  s.version = "0.1.5"
+  s.version = "0.1.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Joshua Lippiner"]
-  s.date = %q{2010-05-07}
+  s.date = %q{2010-05-09}
   s.description = %q{Tickle is a date/time helper gem to help parse natural language into a recurring pattern.  Tickle is designed to be a compliment of Chronic and can interpret things such as "every 2 days, every Sunday, Sundays, Weekly, etc.}
   s.email = %q{jlippiner@noctivity.com}
   s.extra_rdoc_files = [

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 5
-  version: 0.1.5
+  - 6
+  version: 0.1.6
 platform: ruby
 authors: 
 - Joshua Lippiner
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-07 00:00:00 -04:00
+date: 2010-05-09 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency