tickle 1.0.2 → 2.0.0rc3

data/lib/tickle/filters.rb

@@ -0,0 +1,58 @@
+module Tickle
+
+  require 'texttube/filterable'
+  module Filters
+  
+    extend TextTube::Filterable
+  # Normalize natural string removing prefix language
+    filter_with :remove_prefix do |text|
+      text.gsub(/every(\s)?/, '')
+          .gsub(/each(\s)?/, '')
+          .gsub(/repeat(s|ing)?(\s)?/, '')
+          .gsub(/on the(\s)?/, '')
+          .gsub(/([^\w\d\s])+/, '')
+          .downcase.strip
+      text
+    end
+
+
+    # Converts natural language US Holidays into a date expression to be
+    # parsed.
+    filter_with :normalize_us_holidays do |text|
+      normalized_text = text.to_s.downcase
+      normalized_text.gsub(/\bnew\syear'?s?(\s)?(day)?\b/){|md| $1 }
+        .gsub(/\bnew\syear'?s?(\s)?(eve)?\b/){|md| $1 }
+        .gsub(/\bm(artin\s)?l(uther\s)?k(ing)?(\sday)?\b/){|md| $1 }
+        .gsub(/\binauguration(\sday)?\b/){|md| $1 }
+        .gsub(/\bpresident'?s?(\sday)?\b/){|md| $1 }
+        .gsub(/\bmemorial\sday\b/){|md| $1 }
+        .gsub(/\bindepend(e|a)nce\sday\b/){|md| $1 }
+        .gsub(/\blabor\sday\b/){|md| $1 }
+        .gsub(/\bcolumbus\sday\b/){|md| $1 }
+        .gsub(/\bveterans?\sday\b/){|md| $1 }
+        .gsub(/\bthanksgiving(\sday)?\b/){|md| $1 }
+        .gsub(/\bchristmas\seve\b/){|md| $1 }
+        .gsub(/\bchristmas(\sday)?\b/){|md| $1 }
+        .gsub(/\bsuper\sbowl(\ssunday)?\b/){|md| $1 }
+        .gsub(/\bgroundhog(\sday)?\b/){|md| $1 }
+        .gsub(/\bvalentine'?s?(\sday)?\b/){|md| $1 }
+        .gsub(/\bs(ain)?t\spatrick'?s?(\sday)?\b/){|md| $1 }
+        .gsub(/\bapril\sfool'?s?(\sday)?\b/){|md| $1 }
+        .gsub(/\bearth\sday\b/){|md| $1 }
+        .gsub(/\barbor\sday\b/){|md| $1 }
+        .gsub(/\bcinco\sde\smayo\b/){|md| $1 }
+        .gsub(/\bmother'?s?\sday\b/){|md| $1 }
+        .gsub(/\bflag\sday\b/){|md| $1 }
+        .gsub(/\bfather'?s?\sday\b/){|md| $1 }
+        .gsub(/\bhalloween\b/){|md| $1 }
+        .gsub(/\belection\sday\b/){|md| $1 }
+        .gsub(/\bkwanzaa\b/){|md| $1 }
+      normalized_text
+    end
+
+#     filter_with :strip do |text|
+#       text.strip
+#     end
+  
+  end
+end

data/lib/tickle/handler.rb

@@ -1,129 +1,272 @@
-module Tickle #:nodoc:
-  class << self #:nodoc:
+module Tickle
+
+  require_relative "helpers.rb"
+  require_relative "token.rb"
+
 
     # 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?
+    def self.guess(tokens, start)
+      return nil if tokens.empty?
 
-      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
+      _next = catch(:guessed) {
+        %w{guess_unit_types guess_weekday guess_month_names guess_number_and_unit guess_ordinal guess_ordinal_and_unit guess_special}.each do |meth| # TODO pick better enumerator
+          send meth, tokens, start
+        end
+        nil # stop each sending the array to _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
-
+      if  _next &&
+          _next.to_date < start.to_date
+            _next = Time.local(_next.year + 1, _next.month, _next.day, _next.hour, _next.min, _next.sec)
+      end
       # return the next occurrence
-      return @next.to_time if @next
+      _next.to_time if _next
     end
 
-    def guess_unit_types
-      @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])
+
+    def self.guess_unit_types( tokens, start)
+      [:sec,:day,:week,:month,:year].each {|unit|
+        if Token.types(tokens).same?([unit])
+          throw :guessed, start.bump(unit)
+        end
+      }
+      nil
     end
 
-    def guess_weekday
-      @next = chronic_parse_with_start("#{token_of_type(:weekday).start.to_s}") if token_types.same?([:weekday])
+
+    def self.guess_weekday( tokens, start)
+      if Token.types(tokens).same? [:weekday]
+        throw :guessed, chronic_parse_with_start(
+          "#{Token.token_of_type(:weekday,tokens).start.to_s}", start
+        )
+      end
+      nil
     end
 
-    def guess_month_names
-      @next = chronic_parse_with_start("#{Date::MONTHNAMES[token_of_type(:month_name).start]} 1") if token_types.same?([:month_name])
+
+    def self.guess_month_names( tokens, start)
+      if Token.types(tokens).same? [:month_name]
+        throw :guessed, chronic_parse_with_start(
+          "#{Date::MONTHNAMES[Token.token_of_type(:month_name,tokens).start]} 1", start
+        )
+      end
+      nil
     end
 
-    def guess_number_and_unit
-      @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])
-      @next = chronic_parse_with_start("#{token_of_type(:month_name).word} #{token_of_type(:number).start}") if token_types.same?([:number, :month_name])
-      @next = chronic_parse_with_start("#{token_of_type(:specific_year).word}-#{token_of_type(:month_name).start}-#{token_of_type(:number).start}") if token_types.same?([:number, :month_name, :specific_year])
+
+    def self.guess_number_and_unit( tokens, start)
+      _next = 
+        [:sec,:day,:week,:month,:year].each {|unit|
+          if Token.types(tokens).same?([:number, unit])
+            throw :guessed, start.bump( unit, Token.token_of_type(:number,tokens).interval )
+          end
+        }
+
+      if Token.types(tokens).same?([:number, :month_name])
+        throw :guessed, chronic_parse_with_start(
+          "#{Token.token_of_type(:month_name,tokens, start).word} #{Token.token_of_type(:number,tokens).start}", start
+        )
+      end
+      
+      if Token.types(tokens).same?([:number, :month_name, :specific_year])
+        throw :guessed, chronic_parse_with_start(
+          [
+            Token.token_of_type(:specific_year,tokens, start).word,
+            Token.token_of_type(:month_name,tokens).start,
+            Token.token_of_type(:number,tokens).start
+          ].join("_"), start
+        )
+      end
+      nil
     end
 
-    def guess_ordinal
-      @next = handle_same_day_chronic_issue(@start.year, @start.month, token_of_type(:ordinal).start) if token_types.same?([:ordinal])
+
+    def self.guess_ordinal( tokens, start)
+      if Token.types(tokens).same?([:ordinal])
+        throw :guessed, handle_same_day_chronic_issue(
+          start.year, start.month, Token.token_of_type(:ordinal,tokens).start, start
+        )
+      end
+      nil
     end
 
-    def guess_ordinal_and_unit
-      @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
+    def self.guess_ordinal_and_unit( tokens, start)
+      if Token.types(tokens).same?([:ordinal, :month_name])
+        throw :guessed, handle_same_day_chronic_issue(
+          start.year, Token.token_of_type(:month_name,tokens).start, Token.token_of_type(:ordinal,tokens).start, start
+        )
+        nil
+      end
+
+      if Token.types(tokens).same?([:ordinal, :month])
+        throw :guessed, handle_same_day_chronic_issue(
+          start.year,
+          start.month,
+          Token.token_of_type(:ordinal,tokens).start,
+          start  
+        )
+        nil
       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
+      if Token.types(tokens).same?([:ordinal, :month_name, :specific_year])
+        throw :guessed, handle_same_day_chronic_issue(
+          Token.token_of_type(:specific_year,tokens).word, Token.token_of_type(:month_name,tokens).start, Token.token_of_type(:ordinal,tokens).start, start
+          )
+        nil
       end
+
+      if Token.types(tokens).same?([:ordinal, :weekday, :month_name])
+        _next = chronic_parse_with_start(
+          "#{Token.token_of_type(:ordinal,tokens).word} #{Token.token_of_type(:weekday,tokens).start.to_s} in #{Date::MONTHNAMES[Token.token_of_type(:month_name,tokens).start]}", start
+        )
+        if _next.to_date == start.to_date
+          throw :guessed, handle_same_day_chronic_issue(start.year, Token.token_of_type(:month_name,tokens).start, Token.token_of_type(:ordinal,tokens).start, start)
+        end
+        throw :guessed, _next
+        nil
+      end
+
+      if Token.types(tokens).same?([:ordinal, :weekday, :month])
+       _next = chronic_parse_with_start(
+          "#{Token.token_of_type(:ordinal,tokens).word} #{Token.token_of_type(:weekday,tokens).start.to_s} in #{Date::MONTHNAMES[get_next_month(Token.token_of_type(:ordinal,tokens).start)]}", start
+        )
+        _next =
+          if _next.to_date == start.to_date
+            handle_same_day_chronic_issue(
+              start.year, start.month, Token.token_of_type(:ordinal,tokens).start, start
+            )
+          else
+            _next
+        end
+        throw :guessed, _next
+        nil
+      end
+      nil
     end
 
-    def guess_special
-      guess_special_other
-      guess_special_beginning unless @next
-      guess_special_middle unless @next
-      guess_special_end unless @next
+
+    def self.guess_special( tokens, start)
+      guess_special_other tokens, start
+      guess_special_beginning tokens, start
+      guess_special_middle tokens, start
+      guess_special_end tokens, start
+      nil
     end
 
     private
 
-    def guess_special_other
-      @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 self.guess_special_other( tokens, start)
+      if  Token.types(tokens).same?([:special, :day]) &&
+          Token.token_of_type(:special, tokens).start == :other
+            throw :guessed, start.bump(:day, 2)
+            nil
+      end
+
+      if  Token.types(tokens).same?([:special, :week]) &&
+          Token.token_of_type(:special, tokens).start == :other
+            throw :guessed, start.bump(:week, 2)
+            nil
+      end
+
+      if  Token.types(tokens).same?([:special, :month]) &&
+          Token.token_of_type(:special, tokens).start == :other
+            throw :guessed,  chronic_parse_with_start('2 months from now', start)
+            nil
+      end
 
-    def guess_special_beginning
-      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
+      if  Token.types(tokens).same?([:special, :year]) &&
+          Token.token_of_type(:special, tokens).start == :other
+            throw :guessed, chronic_parse_with_start('2 years from now', start)
+            nil
+      end
+      nil
     end
 
-    def guess_special_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
+
+    def self.guess_special_beginning( tokens, start)
+      if  Token.types(tokens).same?([:special, :week]) &&
+          Token.token_of_type(:special, tokens).start == :beginning
+            throw :guessed, chronic_parse_with_start('Sunday', start)
+            nil
+      end
+      if  Token.types(tokens).same?([:special, :month]) &&
+          Token.token_of_type(:special, tokens).start == :beginning
+            throw :guessed, Date.civil(start.year, start.month + 1, 1)
+            nil
+      end
+      if  Token.types(tokens).same?([:special, :year]) &&
+          Token.token_of_type(:special, tokens).start == :beginning
+            throw :guessed, Date.civil(start.year+1, 1, 1)
+            nil
+      end
+      nil
     end
 
-    def guess_special_middle
-      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))
+    def self.guess_special_middle( tokens, start)
+      if  Token.types(tokens).same?([:special, :week]) &&
+          Token.token_of_type(:special, tokens).start == :middle
+            throw :guessed, chronic_parse_with_start('Wednesday', start)
+            nil
       end
-      if token_types.same?([:special, :year]) && token_of_type(:special).start == :middle then
-        @next = (@start.day > 15 && @start.month > 6 ? Date.new(@start.year+1, 6, 15) : Date.new(@start.year, 6, 15))
+
+      if  Token.types(tokens).same?([:special, :month]) &&
+          Token.token_of_type(:special, tokens).start == :middle
+            _next = start.day > 15 ? 
+              Date.civil(start.year, start.month + 1, 15) :
+              Date.civil(start.year, start.month, 15)
+            throw :guessed, _next
+            nil
+      end
+
+      if  Token.types(tokens).same?([:special, :year]) &&
+          Token.token_of_type(:special, tokens).start == :middle
+            _next =
+              start.day > 15 && start.month > 6 ?
+                Date.new(start.year+1, 6, 15) :
+                Date.new(start.year, 6, 15)
+            throw :guessed, _next
+            nil
       end
+      nil
     end
 
-    def token_of_type(type)
-      @tokens.detect {|token| token.type == type}
+
+    def self.guess_special_end( tokens, start)
+      if  Token.types(tokens).same?([:special, :week]) &&
+          (Token.token_of_type(:special, tokens).start == :end)
+            throw :guessed, chronic_parse_with_start('Saturday', start)
+            nil
+      end
+      if  Token.types(tokens).same?([:special, :month]) &&
+          (Token.token_of_type(:special, tokens).start == :end)
+            throw :guessed, Date.civil(start.year, start.month, -1)
+            nil
+      end
+      if  Token.types(tokens).same?([:special, :year]) &&
+          (Token.token_of_type(:special, tokens).start == :end)
+            throw :guessed, Date.new(start.year, 12, 31)
+            nil
+      end
+      nil
     end
 
-    private
 
     # 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)
+    def self.chronic_parse_with_start(exp,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
+    def self.handle_same_day_chronic_issue(year, month, day, start)
+      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)
+      arg_date
     end
-
-
-  end
 end

data/lib/tickle/helpers.rb

@@ -0,0 +1,51 @@
+module Tickle
+
+  require_relative "token.rb"
+
+  # static methods that are used across classes.
+  module Helpers
+
+    # Returns the next available month based on the current day of the 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 self.get_next_month(number,start=nil)
+      start ||= @start || Time.now
+      month =
+        if number.to_i < start.day
+          start.month == 12 ?
+            1 :
+            start.month + 1
+        else
+          start.month
+        end
+    end
+
+
+
+    # Return the number of days in a specified month.
+    # If no month is specified, current month is used.
+    def self.days_in_month(month=nil)
+      month ||= Date.today.month
+      days_in_mon = Date.civil(Date.today.year, month, -1).day
+    end
+
+
+    # Turns compound numbers, like 'twenty first' => 21
+    def self.combine_multiple_numbers(tokens)
+      if  Token.types(tokens).include?(:number) &&
+          Token.types(tokens).include?(:ordinal) 
+            number = Token.token_of_type(:number, tokens)
+            ordinal = Token.token_of_type(:ordinal, tokens)
+            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_original, word: combined_word, type: :ordinal, start: combined_value, interval: 365)
+            tokens.reject! {|token| (token.type == :number || token.type == :ordinal)}
+            tokens << new_number_token
+      end
+      tokens
+    end
+
+
+  end # Helpers
+end