chronic 0.9.1 → 0.10.0

data/lib/chronic/parser.rb

@@ -8,6 +8,7 @@ module Chronic
     DEFAULT_OPTIONS = {
       :context => :future,
       :now => nil,
+      :hours24 => nil,
       :guess => true,
       :ambiguous_time_range => 6,
       :endian_precedence    => [:middle, :little],
@@ -23,10 +24,13 @@ module Chronic
     #                   given, it will assume it is in the past.
     #        :now - Time, all computations will be based off of time
     #               instead of Time.now.
+    #        :hours24 - Time will be parsed as it would be 24 hour clock.
     #        :guess - By default the parser will guess a single point in time
     #                 for the given date or time. If you'd rather have the
     #                 entire time span returned, set this to false
-    #                 and a Chronic::Span will be returned.
+    #                 and a Chronic::Span will be returned. Setting :guess to :end
+    #                 will return last time from Span, to :middle for middle (same as just true)
+    #                 and :begin for first time from span.
     #        :ambiguous_time_range - If an Integer is given, ambiguous times
     #                  (like 5:00) will be assumed to be within the range of
     #                  that time in the AM to that time in the PM. For
@@ -58,9 +62,7 @@ module Chronic
 
       puts "+#{'-' * 51}\n| #{tokens}\n+#{'-' * 51}" if Chronic.debug
 
-      if span
-        options[:guess] ? guess(span) : span
-      end
+      guess(span, options[:guess]) if span
     end
 
     # Clean up the specified text ready for parsing.
@@ -86,14 +88,16 @@ module Chronic
     # Returns a new String ready for Chronic to parse.
     def pre_normalize(text)
       text = text.to_s.downcase
+      text.gsub!(/\b(\d{2})\.(\d{2})\.(\d{4})\b/, '\3 / \2 / \1')
       text.gsub!(/\b([ap])\.m\.?/, '\1m')
+      text.gsub!(/(?<=:\d{2}|:\d{2}\.\d{3})\-(\d{2}:?\d{2})\b/, 'tzminus\1')
       text.gsub!(/\./, ':')
+      text.gsub!(/([ap]):m:?/, '\1m')
       text.gsub!(/['"]/, '')
       text.gsub!(/,/, ' ')
       text.gsub!(/^second /, '2nd ')
       text.gsub!(/\bsecond (of|day|month|hour|minute|second)\b/, '2nd \1')
       text = Numerizer.numerize(text)
-      text.gsub!(/\-(\d{2}:?\d{2})\b/, 'tzminus\1')
       text.gsub!(/([\/\-\,\@])/) { ' ' + $1 + ' ' }
       text.gsub!(/(?:^|\s)0(\d+:\d+\s*pm?\b)/, ' \1')
       text.gsub!(/\btoday\b/, 'this day')
@@ -126,12 +130,11 @@ module Chronic
     # span - The Chronic::Span object to calcuate a guess from.
     #
     # Returns a new Time object.
-    def guess(span)
-      if span.width > 1
-        span.begin + (span.width / 2)
-      else
-        span.begin
-      end
+    def guess(span, mode = :middle)
+      return span if not mode
+      return span.begin + span.width / 2 if span.width > 1 and (mode == true or mode == :middle)
+      return span.end if mode == :end
+      span.begin
     end
 
     # List of Handler definitions. See Chronic.parse for a list of options this
@@ -149,19 +152,21 @@ module Chronic
         ],
 
         :date => [
-          Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :repeater_time, :separator_slash_or_dash?, :time_zone, :scalar_year], :handle_generic),
+          Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :repeater_time, [:separator_slash?, :separator_dash?], :time_zone, :scalar_year], :handle_generic),
           Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day], :handle_rdn_rmn_sd),
           Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :scalar_year], :handle_rdn_rmn_sd_sy),
           Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day], :handle_rdn_rmn_od),
+          Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day, :scalar_year], :handle_rdn_rmn_od_sy),
           Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :separator_at?, 'time?'], :handle_rdn_rmn_sd),
           Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day, :separator_at?, 'time?'], :handle_rdn_rmn_od),
           Handler.new([:repeater_day_name, :ordinal_day, :separator_at?, 'time?'], :handle_rdn_od),
-          Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_day, :repeater_time, :time_zone], :handle_generic),
+          Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar_day, :repeater_time, :time_zone], :handle_generic),
+          Handler.new([:ordinal_day], :handle_generic),
           Handler.new([:repeater_month_name, :scalar_day, :scalar_year], :handle_rmn_sd_sy),
           Handler.new([:repeater_month_name, :ordinal_day, :scalar_year], :handle_rmn_od_sy),
           Handler.new([:repeater_month_name, :scalar_day, :scalar_year, :separator_at?, 'time?'], :handle_rmn_sd_sy),
           Handler.new([:repeater_month_name, :ordinal_day, :scalar_year, :separator_at?, 'time?'], :handle_rmn_od_sy),
-          Handler.new([:repeater_month_name, :separator_slash_or_dash?, :scalar_day, :separator_at?, 'time?'], :handle_rmn_sd),
+          Handler.new([:repeater_month_name, [:separator_slash?, :separator_dash?], :scalar_day, :separator_at?, 'time?'], :handle_rmn_sd),
           Handler.new([:repeater_time, :repeater_day_portion?, :separator_on?, :repeater_month_name, :scalar_day], :handle_rmn_sd_on),
           Handler.new([:repeater_month_name, :ordinal_day, :separator_at?, 'time?'], :handle_rmn_od),
           Handler.new([:ordinal_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_od_rmn_sy),
@@ -171,12 +176,12 @@ module Chronic
           Handler.new([:repeater_time, :repeater_day_portion?, :separator_on?, :repeater_month_name, :ordinal_day], :handle_rmn_od_on),
           Handler.new([:repeater_month_name, :scalar_year], :handle_rmn_sy),
           Handler.new([:scalar_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_sd_rmn_sy),
-          Handler.new([:scalar_day, :separator_slash_or_dash?, :repeater_month_name, :separator_at?, 'time?'], :handle_sd_rmn),
-          Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_day, :separator_at?, 'time?'], :handle_sy_sm_sd),
-          Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month], :handle_sy_sm),
-          Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_year], :handle_sm_sy),
-          Handler.new([:scalar_day, :separator_slash_or_dash, :repeater_month_name, :separator_slash_or_dash, :scalar_year, :repeater_time?], :handle_sm_rmn_sy),
-          Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar?, :time_zone], :handle_generic),
+          Handler.new([:scalar_day, [:separator_slash?, :separator_dash?], :repeater_month_name, :separator_at?, 'time?'], :handle_sd_rmn),
+          Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar_day, :separator_at?, 'time?'], :handle_sy_sm_sd),
+          Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month], :handle_sy_sm),
+          Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_year], :handle_sm_sy),
+          Handler.new([:scalar_day, [:separator_slash, :separator_dash], :repeater_month_name, [:separator_slash, :separator_dash], :scalar_year, :repeater_time?], :handle_sm_rmn_sy),
+          Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar?, :time_zone], :handle_generic),
         ],
 
         :anchor => [
@@ -199,10 +204,10 @@ module Chronic
       }
 
       endians = [
-        Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_day, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sm_sd_sy),
-        Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_day, :separator_at?, 'time?'], :handle_sm_sd),
-        Handler.new([:scalar_day, :separator_slash_or_dash, :scalar_month, :separator_at?, 'time?'], :handle_sd_sm),
-        Handler.new([:scalar_day, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy)
+        Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_day, [:separator_slash, :separator_dash], :scalar_year, :separator_at?, 'time?'], :handle_sm_sd_sy),
+        Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_day, :separator_at?, 'time?'], :handle_sm_sd),
+        Handler.new([:scalar_day, [:separator_slash, :separator_dash], :scalar_month, :separator_at?, 'time?'], :handle_sd_sm),
+        Handler.new([:scalar_day, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy)
       ]
 
       case endian = Array(options[:endian_precedence]).first
@@ -220,7 +225,7 @@ module Chronic
     def tokenize(text, options)
       text = pre_normalize(text)
       tokens = text.split(' ').map { |word| Token.new(word) }
-      [Repeater, Grabber, Pointer, Scalar, Ordinal, Separator, TimeZone].each do |tok|
+      [Repeater, Grabber, Pointer, Scalar, Ordinal, Separator, Sign, TimeZone].each do |tok|
         tok.scan(tokens, options)
       end
       tokens.select { |token| token.tagged? }
@@ -245,7 +250,7 @@ module Chronic
 
       definitions[:arrow].each do |handler|
         if handler.match(tokens, definitions)
-          good_tokens = tokens.reject { |o| o.get_tag(SeparatorAt) || o.get_tag(SeparatorSlashOrDash) || o.get_tag(SeparatorComma) || o.get_tag(SeparatorAnd) }
+          good_tokens = tokens.reject { |o| o.get_tag(SeparatorAt) || o.get_tag(SeparatorSlash) || o.get_tag(SeparatorDash) || o.get_tag(SeparatorComma) || o.get_tag(SeparatorAnd) }
           return handler.invoke(:arrow, good_tokens, self, options)
         end
       end

data/lib/chronic/repeater.rb

@@ -10,32 +10,32 @@ module Chronic
     # Returns an Array of tokens.
     def self.scan(tokens, options)
       tokens.each do |token|
-        if t = scan_for_season_names(token) then token.tag(t); next end
-        if t = scan_for_month_names(token) then token.tag(t); next end
-        if t = scan_for_day_names(token) then token.tag(t); next end
-        if t = scan_for_day_portions(token) then token.tag(t); next end
-        if t = scan_for_times(token) then token.tag(t); next end
-        if t = scan_for_units(token) then token.tag(t); next end
+        if t = scan_for_season_names(token, options) then token.tag(t); next end
+        if t = scan_for_month_names(token, options) then token.tag(t); next end
+        if t = scan_for_day_names(token, options) then token.tag(t); next end
+        if t = scan_for_day_portions(token, options) then token.tag(t); next end
+        if t = scan_for_times(token, options) then token.tag(t); next end
+        if t = scan_for_units(token, options) then token.tag(t); next end
       end
     end
 
     # token - The Token object we want to scan.
     #
     # Returns a new Repeater object.
-    def self.scan_for_season_names(token)
+    def self.scan_for_season_names(token, options = {})
       scan_for token, RepeaterSeasonName,
       {
         /^springs?$/ => :spring,
         /^summers?$/ => :summer,
         /^(autumn)|(fall)s?$/ => :autumn,
         /^winters?$/ => :winter
-      }
+      }, options
     end
 
     # token - The Token object we want to scan.
     #
     # Returns a new Repeater object.
-    def self.scan_for_month_names(token)
+    def self.scan_for_month_names(token, options = {})
       scan_for token, RepeaterMonthName,
       {
         /^jan[:\.]?(uary)?$/ => :january,
@@ -50,13 +50,13 @@ module Chronic
         /^oct[:\.]?(ober)?$/ => :october,
         /^nov[:\.]?(ember)?$/ => :november,
         /^dec[:\.]?(ember)?$/ => :december
-      }
+      }, options
     end
 
     # token - The Token object we want to scan.
     #
     # Returns a new Repeater object.
-    def self.scan_for_day_names(token)
+    def self.scan_for_day_names(token, options = {})
       scan_for token, RepeaterDayName,
       {
         /^m[ou]n(day)?$/ => :monday,
@@ -66,13 +66,13 @@ module Chronic
         /^fr[iy](day)?$/ => :friday,
         /^sat(t?[ue]rday)?$/ => :saturday,
         /^su[nm](day)?$/ => :sunday
-      }
+      }, options
     end
 
     # token - The Token object we want to scan.
     #
     # Returns a new Repeater object.
-    def self.scan_for_day_portions(token)
+    def self.scan_for_day_portions(token, options = {})
       scan_for token, RepeaterDayPortion,
       {
         /^ams?$/ => :am,
@@ -81,20 +81,20 @@ module Chronic
         /^afternoons?$/ => :afternoon,
         /^evenings?$/ => :evening,
         /^(night|nite)s?$/ => :night
-      }
+      }, options
     end
 
     # token - The Token object we want to scan.
     #
     # Returns a new Repeater object.
-    def self.scan_for_times(token)
-      scan_for token, RepeaterTime, /^\d{1,2}(:?\d{1,2})?([\.:]?\d{1,2})?$/
+    def self.scan_for_times(token, options = {})
+      scan_for token, RepeaterTime, /^\d{1,2}(:?\d{1,2})?([\.:]?\d{1,2}([\.:]\d{1,6})?)?$/, options
     end
 
     # token - The Token object we want to scan.
     #
     # Returns a new Repeater object.
-    def self.scan_for_units(token)
+    def self.scan_for_units(token, options = {})
       {
         /^years?$/ => :year,
         /^seasons?$/ => :season,
@@ -114,7 +114,7 @@ module Chronic
         if item =~ token.word
           klass_name = 'Repeater' + symbol.to_s.capitalize
           klass = Chronic.const_get(klass_name)
-          return klass.new(symbol)
+          return klass.new(symbol, options)
         end
       end
       return nil

data/lib/chronic/repeaters/repeater_day.rb

@@ -2,14 +2,15 @@ module Chronic
   class RepeaterDay < Repeater #:nodoc:
     DAY_SECONDS = 86_400 # (24 * 60 * 60)
 
-    def initialize(type)
+    def initialize(type, options = {})
       super
+      @current_day_start = nil
     end
 
     def next(pointer)
       super
 
-      if !@current_day_start
+      unless @current_day_start
         @current_day_start = Chronic.time_class.local(@now.year, @now.month, @now.day)
       end
 
@@ -50,4 +51,4 @@ module Chronic
       super << '-day'
     end
   end
-end
+end

data/lib/chronic/repeaters/repeater_day_name.rb

@@ -2,8 +2,9 @@ module Chronic
   class RepeaterDayName < Repeater #:nodoc:
     DAY_SECONDS = 86400 # (24 * 60 * 60)
 
-    def initialize(type)
+    def initialize(type, options = {})
       super
+      @current_date = nil
     end
 
     def next(pointer)
@@ -11,8 +12,8 @@ module Chronic
 
       direction = pointer == :future ? 1 : -1
 
-      if !@current_date
-        @current_date = Date.new(@now.year, @now.month, @now.day)
+      unless @current_date
+        @current_date = ::Date.new(@now.year, @now.month, @now.day)
         @current_date += direction
 
         day_num = symbol_to_number(@type)
@@ -49,4 +50,4 @@ module Chronic
       lookup[sym] || raise("Invalid symbol specified")
     end
   end
-end
+end

data/lib/chronic/repeaters/repeater_day_portion.rb

@@ -9,8 +9,9 @@ module Chronic
       :night => (20 * 60 * 60)..(24 * 60 * 60),     # 8pm-12pm
     }
 
-    def initialize(type)
+    def initialize(type, options = {})
       super
+      @current_span = nil
 
       if type.kind_of? Integer
         @range = (@type * 60 * 60)..((@type + 12) * 60 * 60)
@@ -25,7 +26,7 @@ module Chronic
     def next(pointer)
       super
 
-      if !@current_span
+      unless @current_span
         now_seconds = @now - Chronic.construct(@now.year, @now.month, @now.day)
         if now_seconds < @range.begin
           case pointer
@@ -105,4 +106,4 @@ module Chronic
       Chronic.construct(reference.year, reference.month, reference.day, hour_hand, minute_hand, second_hand)
     end
   end
-end
+end

data/lib/chronic/repeaters/repeater_fortnight.rb

@@ -2,14 +2,15 @@ module Chronic
   class RepeaterFortnight < Repeater #:nodoc:
     FORTNIGHT_SECONDS = 1_209_600 # (14 * 24 * 60 * 60)
 
-    def initialize(type)
+    def initialize(type, options = {})
       super
+      @current_fortnight_start = nil
     end
 
     def next(pointer)
       super
 
-      if !@current_fortnight_start
+      unless @current_fortnight_start
         case pointer
         when :future
           sunday_repeater = RepeaterDayName.new(:sunday)
@@ -68,4 +69,4 @@ module Chronic
       super << '-fortnight'
     end
   end
-end
+end

data/lib/chronic/repeaters/repeater_hour.rb

@@ -2,14 +2,15 @@ module Chronic
   class RepeaterHour < Repeater #:nodoc:
     HOUR_SECONDS = 3600 # 60 * 60
 
-    def initialize(type)
+    def initialize(type, options = {})
       super
+      @current_hour_start = nil
     end
 
     def next(pointer)
       super
 
-      if !@current_hour_start
+      unless @current_hour_start
         case pointer
         when :future
           @current_hour_start = Chronic.construct(@now.year, @now.month, @now.day, @now.hour + 1)
@@ -55,4 +56,4 @@ module Chronic
       super << '-hour'
     end
   end
-end
+end

data/lib/chronic/repeaters/repeater_minute.rb

@@ -2,14 +2,15 @@ module Chronic
   class RepeaterMinute < Repeater #:nodoc:
     MINUTE_SECONDS = 60
 
-    def initialize(type)
+    def initialize(type, options = {})
       super
+      @current_minute_start = nil
     end
 
     def next(pointer = :future)
       super
 
-      if !@current_minute_start
+      unless @current_minute_start
         case pointer
         when :future
           @current_minute_start = Chronic.construct(@now.year, @now.month, @now.day, @now.hour, @now.min + 1)
@@ -55,4 +56,4 @@ module Chronic
       super << '-minute'
     end
   end
-end
+end

data/lib/chronic/repeaters/repeater_month.rb

@@ -5,14 +5,15 @@ module Chronic
     MONTH_DAYS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
     MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
 
-    def initialize(type)
+    def initialize(type, options = {})
       super
+      @current_month_start = nil
     end
 
     def next(pointer)
       super
 
-      if !@current_month_start
+      unless @current_month_start
         @current_month_start = offset_by(Chronic.construct(@now.year, @now.month), 1, pointer)
       else
         @current_month_start = offset_by(Chronic.construct(@current_month_start.year, @current_month_start.month), 1, pointer)
@@ -73,7 +74,7 @@ module Chronic
     private
 
     def month_days(year, month)
-      Date.leap?(year) ? MONTH_DAYS_LEAP[month - 1] : MONTH_DAYS[month - 1]
+      ::Date.leap?(year) ? MONTH_DAYS_LEAP[month - 1] : MONTH_DAYS[month - 1]
     end
   end
-end
+end

data/lib/chronic/repeaters/repeater_month_name.rb

@@ -16,14 +16,15 @@ module Chronic
       :december => 12
     }
 
-    def initialize(type)
+    def initialize(type, options = {})
       super
+      @current_month_begin = nil
     end
 
     def next(pointer)
       super
 
-      if !@current_month_begin
+      unless @current_month_begin
         case pointer
         when :future
           if @now.month < index
@@ -91,4 +92,4 @@ module Chronic
       super << '-monthname-' << @type.to_s
     end
   end
-end
+end