tickle 0.0.5 → 0.1.3

data/README.rdoc

@@ -2,6 +2,10 @@
   http://github.com/noctivityinc/tickle
   by Joshua Lippiner, Noctivity
 
+** LEGACY WARNING
+
+If you starting using Tickle pre version 0.1.X, you will need to update your code to either include the :next_only => true option or read correctly from the options hash.  Sorry.
+
 -- DESCRIPTION
 
 Tickle is a natural language parser for recurring events.
@@ -30,82 +34,143 @@ thoughtbot's shoulda (gem install shoulda)
 
 You can parse strings containing a natural language interval using the Tickle.parse method.
 
-Tickle.parse returns the next occurrence of the event.
+You can either pass a string prefixed with the word "every, each or 'on the'" or simply the time frame.   
 
-You can either pass a string prefixed with the word "every, each or 'on the'" or simply the time frame.   You can also pass a start date with the word "starting" (e.g. Tickle.parse('every 3 days starting next friday'))
+Tickle.parse returns a hash containing the following keys:
+* next = the next occurrence of the event.  This is NEVER today as its always the next date in the future.
+* starting = the date all calculations as based on.  If not passed as an option, the start date is right now.
+* until = the last date you want this event to run until.
+* expression = this is the natural language expression to store to run through tickle later to get the next occurrence.
 
 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.
 
+-- OPTIONS
+
+There are two ways to pass options: natural language or an options hash.
+
+NATURAL LANGUAGE:
+Pass a start date with the word "starting, start, stars" (e.g. Tickle.parse('every 3 days starting next friday'))
+Pass an end date with the word "until, end, ends, ending" (e.g. Tickle.parse('every 3 days until next friday'))
+Pass both at the same time (e.g. "starting May 5th repeat every other week until December 1")
+
+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) }))
+* 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
+
+You may notice when parsing an expression with a start date that the next occurrence IS the start date passed.  This is DESIGNED BEHAVIOR.  
+
+Here's why - assume your user says "remind me every 3 weeks starting Dec 1" and today is May 8th.  Well the first reminder needs to be sent on Dec 1, not Dec 21 (three weeks later). 
+
+If you don't like that, fork and have fun but don't say I didn't warn ya.
+
 -- EXAMPLES
 
   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}
   
-  Time.now
-  2010-04-24 12:05:51 -0400
-
-  Tickle.parse('each day')  #=> 2010-04-24 12:05:51 -0400
-  Tickle.parse('every day')  #=> 2010-04-24 12:05:51 -0400
-  Tickle.parse('every week')  #=> 2010-05-01 12:05:51 -0400
-  Tickle.parse('every Month')  #=> 2010-05-24 12:05:51 -0400
-  Tickle.parse('every year')  #=> 2011-04-24 12:05:51 -0400
-  Tickle.parse('daily')  #=> 2010-04-24 12:05:51 -0400
-  Tickle.parse('weekly')  #=> 2010-05-01 12:05:51 -0400
-  Tickle.parse('monthly')  #=> 2010-05-24 12:05:51 -0400
-  Tickle.parse('yearly')  #=> 2011-04-24 12:05:51 -0400
-  Tickle.parse('every 3 days')  #=> 2010-04-27 12:05:51 -0400
-  Tickle.parse('every 3 weeks')  #=> 2010-05-15 12:05:51 -0400
-  Tickle.parse('every 3 months')  #=> 2010-07-23 12:05:51 -0400
-  Tickle.parse('every 3 years')  #=> 2013-04-23 12:05:51 -0400
-  Tickle.parse('every other day')  #=> 2010-04-26 12:05:51 -0400
-  Tickle.parse('every other week')  #=> 2010-05-08 12:05:51 -0400
-  Tickle.parse('every other month')  #=> 2010-06-24 12:05:51 -0400
-  Tickle.parse('every other year')  #=> 2012-04-24 12:05:51 -0400
-  Tickle.parse('every other day starting May 1st')  #=> 2010-05-01 12:00:00 -0400
-  Tickle.parse('every other week starting this Sunday')  #=> 2010-04-25 12:00:00 -0400
-  Tickle.parse('every Monday')  #=> 2010-04-26 12:00:00 -0400
-  Tickle.parse('every Wednesday')  #=> 2010-04-28 12:00:00 -0400
-  Tickle.parse('every Friday')  #=> 2010-04-30 12:00:00 -0400
-  Tickle.parse('every May')  #=> 2010-05-01 12:00:00 -0400
-  Tickle.parse('every june')  #=> 2010-06-01 12:00:00 -0400
-  Tickle.parse('beginning of the week')  #=> 2010-04-25 12:00:00 -0400
-  Tickle.parse('middle of the week')  #=> 2010-04-28 12:00:00 -0400
-  Tickle.parse('end of the week')  #=> 2010-05-01 12:00:00 -0400
-  Tickle.parse('beginning of the month')  #=> 2010-05-01 12:00:00 -0400
-  Tickle.parse('middle of the month')  #=> 2010-05-15 12:00:00 -0400
-  Tickle.parse('end of the month')  #=> 2010-04-30 00:00:00 -0400
-  Tickle.parse('beginning of the year')  #=> 2011-01-01 12:00:00 -0500
-  Tickle.parse('middle of the year')  #=> 2010-06-15 00:00:00 -0400
-  Tickle.parse('end of the year')  #=> 2010-12-31 00:00:00 -0500
-  Tickle.parse('the 3rd of May')  #=> 2010-05-03 12:00:00 -0400
-  Tickle.parse('the 3rd of February')  #=> 2011-02-03 12:00:00 -0500
-  Tickle.parse('the 10th of the month')  #=> 2010-05-10 12:00:00 -0400
-  Tickle.parse('the tenth of the month')  #=> 2010-05-10 12:00:00 -0400
-  Tickle.parse('the first of the month')  #=> 2010-05-01 12:00:00 -0400
-  Tickle.parse('the thirtieth')  #=> 2010-04-30 12:00:00 -0400
-  Tickle.parse('the fifth')  #=> 2010-05-05 12:00:00 -0400
-  Tickle.parse('the 3rd Sunday of May')  #=> 2010-05-16 12:00:00 -0400
-  Tickle.parse('the 3rd Sunday of the month')  #=> 2010-05-16 12:00:00 -0400
-  Tickle.parse('the 23rd of June')  #=> 2010-06-23 12:00:00 -0400
-  Tickle.parse('the twenty third of June')  #=> 2010-06-23 12:00:00 -0400
-  Tickle.parse('the thirty first of August')  #=> 2010-08-31 12:00:00 -0400
-  Tickle.parse('the twenty first')  #=> 2010-05-21 12:00:00 -0400
-  Tickle.parse('the twenty first of the month')  #=> 2010-05-21 12:00:00 -0400
+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}
+  .
 
 -- USING IN APP
 
 To use in your app, we recommend adding two attributes to your database model:
 * next_occurrence
-* tickle_query
+* tickle_expression
 
 Then call Tickle.parse(query) 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_query) again to update the next occurrence of the event.
+After it completes, call Tickle.parse(tickle_expression) again to update the next occurrence of the event.
+
 
+-- TESTING
+
+Tickle comes with a full testing suite that tests and shows sample output 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.
 
 -- LIMITATIONS
 
@@ -117,6 +182,8 @@ HUGE shout-out to both the creator of Chronic, Tom Preston-Werner (http://chroni
 
 Without their work and code structure I'd be lost.
 
+As always, BIG shout-out to the RVM Master himself, Wayne Seguin, for putting up with me and Ruby from day one.  Ask Wayne to make you some Ciabatta bread next time you see him
+
 
 == Note on Patches/Pull Requests
  
@@ -126,7 +193,7 @@ Without their work and code structure I'd be lost.
   future version unintentionally.
 * Commit, do not mess with rakefile, version, or history.
   (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
+* Send me a pull request. Bonus points for time-based branches.
 
 == Copyright
 

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.1.3

data/git-flow-version

@@ -1 +1 @@
-GITFLOW_VERSION=0.0.5
+GITFLOW_VERSION=0.1.3

data/lib/tickle.rb

@@ -6,7 +6,8 @@
 #
 #=============================================================================
 
-$:.unshift File.dirname(__FILE__)     # For use/testing when no gem is installed
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))     # For use/testing when no gem is installed
 
 require 'date'
 require 'time'
@@ -17,7 +18,7 @@ require 'tickle/handler'
 require 'tickle/repeater'
 
 module Tickle
-  VERSION = "0.0.3"
+  VERSION = "0.1.3"
 
   def self.debug; false; end
 

data/lib/tickle/handler.rb

@@ -2,75 +2,62 @@ module Tickle
   class << self
 
     def guess()
-      interval = guess_unit_types
-      interval ||= guess_weekday
-      interval ||= guess_month_names
-      interval ||= guess_number_and_unit
-      interval ||= guess_ordinal
-      interval ||= guess_ordinal_and_unit
-      interval ||= guess_special
+      guess_unit_types
+      guess_weekday unless @next
+      guess_month_names unless @next
+      guess_number_and_unit unless @next
+      guess_ordinal unless @next
+      guess_ordinal_and_unit unless @next
+      guess_special unless @next
 
-      # defines the next occurrence of this tickle if not set in a guess routine
-      @next ||= @start + (interval * 60 * 60 * 24) if interval
-
-      # check to see if the start date is > NOW and, if so, set the next occurrence = start
-      @next = @start if @start.to_time > Time.now
+      # 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 
 
       # return the next occurrence
-      return @next.to_time if interval
+      return @next.to_time if @next
     end
 
     def guess_unit_types
-      interval = 0 if token_types.same?([:day])
+      interval = 1 if token_types.same?([:day])
       interval = 7 if token_types.same?([:week])
-      interval = 30 if token_types.same?([:month])
+      interval = Tickle.days_in_month if token_types.same?([:month])
       interval = 365 if token_types.same?([:year])
-      interval
+      compute_next(interval)
     end
 
     def guess_weekday
-      if token_types.same?([:weekday]) then
-        @start = Chronic.parse(token_of_type(:weekday).start.to_s)
-        interval = 7
-      end
-      interval
+      @next = chronic_parse("#{token_of_type(:weekday).start.to_s}") if token_types.same?([:weekday])
     end
 
     def guess_month_names
-      if token_types.same?([:month_name]) then
-        @start = Chronic.parse("#{token_of_type(:month_name).start.to_s} 1")
-        interval = 30
-      end
-      interval
+      @next = chronic_parse("#{token_of_type(:month_name).start.to_s} 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 * 30) if token_types.same?([:number, :month])
+      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])
-      interval
+      compute_next(interval)
     end
 
     def guess_ordinal
-      if token_types.same?([:ordinal]) then interval = 365; @next = Chronic.parse("#{token_of_type(:ordinal).start} day in #{Date::MONTHNAMES[get_next_month(token_of_type(:ordinal).start)]}"); end
-      interval
+      @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]) 
     end
 
     def guess_ordinal_and_unit
-      parse_text = ''
-      if token_types.same?([:ordinal, :month_name]) then interval = 365; @next = Chronic.parse("#{token_of_type(:ordinal).original} day in #{token_of_type(:month_name).start.to_s}"); end
-      if token_types.same?([:ordinal, :month]) then interval = 365; @next = Chronic.parse("#{token_of_type(:ordinal).start} day in #{Date::MONTHNAMES[get_next_month(token_of_type(:ordinal).start)]}"); end
-      if token_types.same?([:ordinal, :weekday, :month_name]) then interval = 365; @next = Chronic.parse("#{token_of_type(:ordinal).original} #{token_of_type(:weekday).start.to_s} in #{token_of_type(:month_name).start.to_s}"); end
-      if token_types.same?([:ordinal, :weekday, :month]) then interval = 365; @next = Chronic.parse("#{token_of_type(:ordinal).original} #{token_of_type(:weekday).start.to_s} in #{Date::MONTHNAMES[get_next_month(token_of_type(:ordinal).start)]}"); end
-      interval
+      @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])
     end
 
     def guess_special
-      interval = guess_special_other
-      interval ||= guess_special_beginning
-      interval ||= guess_special_middle
-      interval ||= guess_special_end
+      guess_special_other
+      guess_special_beginning unless @next
+      guess_special_middle unless @next
+      guess_special_end unless @next
     end
 
     private
@@ -78,36 +65,31 @@ module Tickle
     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
-      if token_types.same?([:special, :month]) && token_of_type(:special).start == :other then interval = 60;  @next = Chronic.parse('2 months from now'); end
-      if token_types.same?([:special, :year]) && token_of_type(:special).start == :other then interval = 730;  @next = Chronic.parse('2 years from now'); end
-      interval
+      @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)
     end
 
     def guess_special_beginning
-      if token_types.same?([:special, :week]) && token_of_type(:special).start == :beginning then interval = 7;  @start = Chronic.parse('Sunday'); end
-      if token_types.same?([:special, :month]) && token_of_type(:special).start == :beginning then interval = 30;  @start = Chronic.parse('1st day next month'); end
-      if token_types.same?([:special, :year]) && token_of_type(:special).start == :beginning then interval = 365;  @start = Chronic.parse('1st day next year'); end
-      interval
+      if token_types.same?([:special, :week]) && token_of_type(:special).start == :beginning then @next = chronic_parse('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 interval = 7;  @start = Chronic.parse('Saturday'); end
-      if token_types.same?([:special, :month]) && token_of_type(:special).start == :end then interval = 30;  @start = Date.new(Date.today.year, Date.today.month, Date.today.days_in_month); end
-      if token_types.same?([:special, :year]) && token_of_type(:special).start == :end then interval = 365;  @start = Date.new(Date.today.year, 12, 31); end
-      interval
+      if token_types.same?([:special, :week]) && token_of_type(:special).start == :end then @next = chronic_parse('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 interval = 7;  @start = Chronic.parse('Wednesday'); end
+      if token_types.same?([:special, :week]) && token_of_type(:special).start == :middle then @next = chronic_parse('Wednesday'); end
       if token_types.same?([:special, :month]) && token_of_type(:special).start == :middle then
-        interval = 30;
-        @start = (Date.today.day > 15 ? Chronic.parse('15th day of next month') : Date.new(Date.today.year, Date.today.month, 15))
+        @next = (@start.day > 15 ? Date.civil(@start.year, @start.month + 1, 15) : Date.civil(@start.year, @start.month, 15))
       end
       if token_types.same?([:special, :year]) && token_of_type(:special).start == :middle then
-        interval = 365;
-        @start = (Date.today.day > 15 && Date.today.month > 6 ? Date.new(Date.today.year+1, 6, 15) : Date.new(Date.today.year, 6, 15))
+        @next = (@start.day > 15 && @start.month > 6 ? Date.new(@start.year+1, 6, 15) : Date.new(@start.year, 6, 15))
       end
-      interval
     end
 
     def token_of_type(type)
@@ -116,10 +98,16 @@ module Tickle
 
     private
 
-    def get_next_month(ordinal)
-      ord_to_int = ordinal.gsub(/\b(\d*)(st|nd|rd|th)\b/,'\1').to_i
-      month = (ord_to_int < Date.today.day ? Date.today.month + 1 : Date.today.month)
+    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
+      Chronic.parse(exp, :now => @start)
+    end
+
 
   end
 end

data/lib/tickle/repeater.rb

@@ -4,10 +4,11 @@ class Tickle::Repeater < Chronic::Tag #:nodoc:
     # for each token
     tokens.each do |token|
       token = self.scan_for_numbers(token)
-      token = self.scan_for_ordinal_names(token)
-      token = self.scan_for_ordinals(token)
+      token = self.scan_for_ordinal_names(token) unless token.type
+      token = self.scan_for_ordinals(token) unless token.type
       token = self.scan_for_month_names(token) unless token.type
       token = self.scan_for_day_names(token) unless token.type
+      token = self.scan_for_year_name(token) unless token.type
       token = self.scan_for_special_text(token) unless token.type
       token = self.scan_for_units(token) unless token.type
     end
@@ -15,46 +16,52 @@ class Tickle::Repeater < Chronic::Tag #:nodoc:
   end
 
   def self.scan_for_numbers(token)
-    num = Float(token.word) rescue nil
-    token.update(:number, num.to_i, num.to_i) if num
+    regex = /\b(\d\d?)\b/
+    token.update(:number, token.word.gsub(regex,'\1').to_i, token.word.gsub(regex,'\1').to_i) if token.word =~ regex
     token
   end
 
   def self.scan_for_ordinal_names(token)
     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',
+      /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',
     }
     scanner.keys.each do |scanner_item|
-      token.update(:ordinal, scanner[scanner_item], 365) if scanner_item =~ token.original
+      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]))))
+      end
     end
     token
   end
-  
+
   def self.scan_for_ordinals(token)
     regex = /\b(\d*)(st|nd|rd|th)\b/
-    token.update(:ordinal, token.original, 365) if !(token.original =~ regex).nil?
+    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)))
+    end
     token
   end
-  
+
   def self.scan_for_month_names(token)
     scanner = {/^jan\.?(uary)?$/ => :january,
       /^feb\.?(ruary)?$/ => :february,
@@ -91,6 +98,12 @@ class Tickle::Repeater < Chronic::Tag #:nodoc:
     token
   end
 
+  def self.scan_for_year_name(token)
+    regex = /\b\d{4}\b/
+    token.update(:specific_year, token.original.gsub(regex,'\1'), 365) if token.original =~ regex
+    token
+  end
+
   def self.scan_for_special_text(token)
     scanner = {/^other$/ => :other,
       /^begin(ing|ning)?$/ => :beginning,
@@ -109,8 +122,8 @@ class Tickle::Repeater < Chronic::Tag #:nodoc:
       /^fortnights?$/ => {:type => :fortnight, :interval => 365, :start => :today},
       /^week(ly)?s?$/ => {:type => :week, :interval => 7, :start => :today},
       /^weekends?$/ => {:type => :weekend, :interval => 7, :start => :saturday},
-      /^days?$/ => {:type => :day, :interval => 1, :start => :today},
-    /^daily?$/ => {:type => :day, :interval => 1, :start => :today}}
+      /^days?$/ => {:type => :day, :interval => 0, :start => :today},
+    /^daily?$/ => {:type => :day, :interval => 0, :start => :today}}
     scanner.keys.each do |scanner_item|
       if scanner_item =~ token.word
         token.update(scanner[scanner_item][:type], scanner[scanner_item][:start], scanner[scanner_item][:interval]) if scanner_item =~ token.word
@@ -119,4 +132,10 @@ 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

@@ -3,49 +3,119 @@ module Tickle
 
     def parse(text, specified_options = {})
       # get options and set defaults if necessary
-      default_options = {:start => Time.now}
+      default_options = {:start => Time.now, :next_only => false, :until  => nil}
       options = default_options.merge specified_options
 
+      # ensure an expression was provided
+      raise(InvalidArgumentException, 'date expression is required') unless text
+
       # ensure the specified options are valid
       specified_options.keys.each do |key|
         raise(InvalidArgumentException, "#{key} is not a valid option key.") unless default_options.keys.include?(key)
       end
       raise(InvalidArgumentException, ':start specified is not a valid datetime.') unless  (is_date(specified_options[:start]) || Chronic.parse(specified_options[:start])) if specified_options[:start]
 
+      # check to see if a valid datetime was passed
+      return text if text.is_a?(Date) ||  text.is_a?(Time)
+
       # check to see if this event starts some other time and reset now
-      event, starting = text.split('starting')
-      @start = (Chronic.parse(starting) || options[:start])
-      @next = nil
+      event = scan_expression(text, options)
+
+      raise(InvalidDateExpression, "the start date (#{@start.to_date}) for a recurring event cannot occur in the past ") if @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
 
-      # put the text into a normal format to ease scanning using Chronic
-      event = pre_tokenize(event)
+      # no need to guess at expression if the start_date is in the future
+      best_guess = nil
+      if @start.to_time > Time.now
+        best_guess = @start
+      else
+        # put the text into a normal format to ease scanning using Chronic
+        event = pre_filter(event)
 
-      # split into tokens
-      @tokens = base_tokenize(event)
+        # split into tokens
+        @tokens = base_tokenize(event)
 
-      # process each original word for implied word
-      post_tokenize
+        # process each original word for implied word
+        post_tokenize
 
-      # scan the tokens with each token scanner
-      @tokens = Repeater.scan(@tokens)
+        # @tokens.each {|x| puts x.inspect} if Tickle.debug
 
-      # remove all tokens without a type
-      @tokens.reject! {|token| token.type.nil? }
+        # scan the tokens with each token scanner
+        @tokens = Repeater.scan(@tokens)
 
-      # combine number and ordinals into single number
-      combine_multiple_numbers
+        # remove all tokens without a type
+        @tokens.reject! {|token| token.type.nil? }
 
-      @tokens.each {|x| puts x.inspect} if Tickle.debug
+        # combine number and ordinals into single number
+        combine_multiple_numbers
 
-      return guess
+        @tokens.each {|x| puts x.inspect} if Tickle.debug
+
+        best_guess = guess
+      end
+
+      raise(InvalidDateExpression, "the next occurrence takes place after the end date specified") if @until && best_guess.to_date > @until.to_date
+
+      if !best_guess
+        return nil
+      elsif options[:next_only] != true
+        h = {:next => best_guess.to_time, :recurrence_expression => event.strip}
+        h.merge!({:starting => @start.to_time}) if @start
+        h.merge!({:until => @until.to_time}) if @until
+        return h
+      else
+        return best_guess
+      end
+    end
+
+    # scans the expression for a variety of natural formats, such as 'every thursday starting tomorrow until May 15th
+    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
+      if text =~ start_every_regex
+        starting = text.match(start_every_regex)[2]
+        text = text.match(start_every_regex)[4]
+        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]
+        starting, ending = process_for_ending(text)
+      else
+        event, ending = process_for_ending(text)
+      end
+
+      @start = (starting && Tickle.parse(pre_filter(starting), {:next_only => true}) || options[:start])
+      @until = (ending && Tickle.parse(pre_filter(ending), {:next_only => true})  || options[:until])
+      @next = nil
+      return event
+    end
+
+    def inspect_matches
+
+    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
+      if text =~ regex
+        return text.match(regex)[1], text.match(regex)[3]
+      else
+        return text, nil
+      end
     end
 
     # Normalize natural string removing prefix language
-    def pre_tokenize(text)
-      normalized_text = text.gsub(/^every\s\b/, '')
-      normalized_text = text.gsub(/^each\s\b/, '')
-      normalized_text = text.gsub(/^on the\s\b/, '')
-      normalized_text.downcase
+    def pre_filter(text)
+      return nil unless text
+
+      text.gsub!(/every(\s)?/, '')
+      text.gsub!(/each(\s)?/, '')
+      text.gsub!(/repeat(s|ing)?(\s)?/, '')
+      text.gsub!(/on the(\s)?/, '')
+      text.gsub!(/([^\w\d\s])+/, '')
+      text.downcase.strip
     end
 
     # Split the text on spaces and convert each word into
@@ -85,12 +155,7 @@ module Tickle
       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 = numericize_ordinals(normalized_text)
-    end
-
-    # Convert ordinal words to numeric ordinals (third => 3rd)
-    def numericize_ordinals(text) #:nodoc:
-      text = text.gsub(/\b(\d*)(st|nd|rd|th)\b/, '\1')
+      normalized_text
     end
 
     # Turns compound numbers, like 'twenty first' => 21
@@ -98,8 +163,10 @@ module Tickle
       if [:number, :ordinal].all? {|type| token_types.include? type}
         number = token_of_type(:number)
         ordinal = token_of_type(:ordinal)
+        combined_original = "#{number.original} #{ordinal.original}"
+        combined_word = (number.start.to_s[0] + ordinal.word)
         combined_value = (number.start.to_s[0] + ordinal.start.to_s)
-        new_number_token = Token.new(combined_value, combined_value, :ordinal, combined_value, 365)
+        new_number_token = Token.new(combined_original, combined_word, :ordinal, combined_value, 365)
         @tokens.reject! {|token| (token.type == :number || token.type == :ordinal)}
         @tokens << new_number_token
       end
@@ -109,6 +176,17 @@ module Tickle
     def token_types
       @tokens.map(&:type)
     end
+
+    protected
+
+    def get_next_month(number)
+      month = number.to_i < Date.today.day ? (Date.today.month == 12 ? 1 : Date.today.month + 1) : Date.today.month
+    end
+
+    def days_in_month(month=nil)
+      month ||= Date.today.month
+      days_in_mon = Date.civil(Date.today.year, month, -1).day
+    end
   end
 
   class Token #:nodoc:
@@ -134,4 +212,10 @@ module Tickle
   class InvalidArgumentException < Exception
 
   end
+
+  # This exception is raised if there is an issue with the parsing
+  # output from the date expression provided
+  class InvalidDateExpression < Exception
+
+  end
 end

data/test/test_parsing.rb

@@ -1,14 +1,13 @@
-require 'helper'
+require File.expand_path(File.dirname(__FILE__) + '/helper')
 require 'time'
 require 'test/unit'
 
 class TestParsing < Test::Unit::TestCase
 
   def setup
-
   end
 
-  def test_parse_best_guess
+  def test_parse_best_guess_simple
     puts "Time.now"
     p Time.now
 
@@ -33,8 +32,6 @@ class TestParsing < Test::Unit::TestCase
     parse_now('every other week')
     parse_now('every other month')
     parse_now('every other year')
-    parse_now('every other day starting May 1st')
-    parse_now('every other week starting this Sunday')
 
     parse_now('every Monday')
     parse_now('every Wednesday')
@@ -56,14 +53,17 @@ class TestParsing < Test::Unit::TestCase
     parse_now('end of the year')
 
     parse_now('the 3rd of May')
-    parse_now('the 3rd of February', {:start => Date.new(2010, 03, 01).to_time})
+    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', {:start => Date.new(2010, 03, 15)})
+    parse_now('the fifth')
 
     parse_now('the 3rd Sunday of May')
     parse_now('the 3rd Sunday of the month')
@@ -72,11 +72,48 @@ class TestParsing < Test::Unit::TestCase
     parse_now('the twenty third of June')
     parse_now('the thirty first of August')
 
-
     parse_now('the twenty first')
     parse_now('the twenty first of the month')
   end
 
+  def test_parse_best_guess_complex
+    puts "Time.now"
+    p Time.now
+
+    parse_now('starting Monday repeat every month')
+    parse_now('starting May 13th repeat every week')
+    parse_now('starting May 13th repeat every other day')
+
+    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')
+
+    parse_now("every other day starting May 1st #{Date.today.year + 1}")
+    parse_now('every other week starting this Sunday')
+
+    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')
+
+  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})
+  end
+
   def test_argument_validation
     assert_raise(Tickle::InvalidArgumentException) do
       time = Tickle.parse("may 27", :today => 'something odd')
@@ -85,12 +122,33 @@ class TestParsing < Test::Unit::TestCase
     assert_raise(Tickle::InvalidArgumentException) do
       time = Tickle.parse("may 27", :foo => :bar)
     end
+
+    assert_raise(Tickle::InvalidArgumentException) do
+      time = Tickle.parse(nil)
+    end
+
+    assert_raise(Tickle::InvalidDateExpression) do
+      past_date = Date.civil(Date.today.year, Date.today.month, Date.today.day - 1)
+      time = Tickle.parse("every other day", {:start => past_date})
+    end
+
+    assert_raise(Tickle::InvalidDateExpression) do
+      start_date = Date.civil(Date.today.year, Date.today.month, Date.today.day + 10)
+      end_date = Date.civil(Date.today.year, Date.today.month, Date.today.day + 5)
+      time = Tickle.parse("every other day", :start => start_date, :until => end_date)
+    end
+
+    assert_raise(Tickle::InvalidDateExpression) do
+      end_date = Date.civil(Date.today.year, Date.today.month+2, Date.today.day)
+      parse_now('every 3 months', {:until => end_date})
+    end
   end
 
   private
   def parse_now(string, options={})
     out = Tickle.parse(string, {}.merge(options))
-    puts ("Tickle.parse('#{string}')  #=> #{out}")
+    puts (options.empty? ?  ("Tickle.parse('#{string}')  #=> #{out}") : ("Tickle.parse('#{string}, #{options}')  #=> #{out}"))
+    p '--' if Tickle.debug
     out
   end
 end

data/tickle.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{tickle}
-  s.version = "0.0.5"
+  s.version = "0.1.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Joshua Lippiner"]
-  s.date = %q{2010-04-25}
+  s.date = %q{2010-05-07}
   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

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 0
-  - 5
-  version: 0.0.5
+  - 1
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - Joshua Lippiner
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-25 00:00:00 -04:00
+date: 2010-05-07 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency