chronic 0.2.2 → 0.10.2

data/lib/chronic/repeater.rb

@@ -1,115 +1,145 @@
-class Chronic::Repeater < Chronic::Tag #:nodoc:
-  def self.scan(tokens, options)
-    # for each token
-    tokens.each_index do |i|
-      if t = self.scan_for_month_names(tokens[i]) then tokens[i].tag(t); next end
-      if t = self.scan_for_day_names(tokens[i]) then tokens[i].tag(t); next end
-      if t = self.scan_for_day_portions(tokens[i]) then tokens[i].tag(t); next end
-      if t = self.scan_for_times(tokens[i], options) then tokens[i].tag(t); next end
-      if t = self.scan_for_units(tokens[i]) then tokens[i].tag(t); next end
+module Chronic
+  class Repeater < Tag
+
+    # Scan an Array of Token objects and apply any necessary Repeater
+    # tags to each token.
+    #
+    # tokens - An Array of tokens to scan.
+    # options - The Hash of options specified in Chronic::parse.
+    #
+    # Returns an Array of tokens.
+    def self.scan(tokens, options)
+      tokens.each do |token|
+        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
-    tokens
-  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.keys.each do |scanner_item|
-      return Chronic::RepeaterMonthName.new(scanner[scanner_item]) if scanner_item =~ token.word
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_season_names(token, options = {})
+      scan_for token, RepeaterSeasonName,
+      {
+        /^springs?$/ => :spring,
+        /^summers?$/ => :summer,
+        /^(autumn)|(fall)s?$/ => :autumn,
+        /^winters?$/ => :winter
+      }, options
     end
-    return nil
-  end
-  
-  def self.scan_for_day_names(token)
-    scanner = {/^m[ou]n(day)?$/ => :monday,
-               /^t(ue|eu|oo|u|)s(day)?$/ => :tuesday,
-               /^tue$/ => :tuesday,
-               /^we(dnes|nds|nns)day$/ => :wednesday,
-               /^wed$/ => :wednesday,
-               /^th(urs|ers)day$/ => :thursday,
-               /^thu$/ => :thursday,
-               /^fr[iy](day)?$/ => :friday,
-               /^sat(t?[ue]rday)?$/ => :saturday,
-               /^su[nm](day)?$/ => :sunday}
-    scanner.keys.each do |scanner_item|
-      return Chronic::RepeaterDayName.new(scanner[scanner_item]) if scanner_item =~ token.word
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_month_names(token, options = {})
+      scan_for token, RepeaterMonthName,
+      {
+        /^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
+      }, options
     end
-    return nil
-  end
-  
-  def self.scan_for_day_portions(token)
-    scanner = {/^ams?$/ => :am,
-               /^pms?$/ => :pm,
-               /^mornings?$/ => :morning,
-               /^afternoons?$/ => :afternoon,
-               /^evenings?$/ => :evening,
-               /^(night|nite)s?$/ => :night}
-    scanner.keys.each do |scanner_item|
-      return Chronic::RepeaterDayPortion.new(scanner[scanner_item]) if scanner_item =~ token.word
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_day_names(token, options = {})
+      scan_for token, RepeaterDayName,
+      {
+        /^m[ou]n(day)?$/ => :monday,
+        /^t(ue|eu|oo|u|)s?(day)?$/ => :tuesday,
+        /^we(d|dnes|nds|nns)(day)?$/ => :wednesday,
+        /^th(u|ur|urs|ers)(day)?$/ => :thursday,
+        /^fr[iy](day)?$/ => :friday,
+        /^sat(t?[ue]rday)?$/ => :saturday,
+        /^su[nm](day)?$/ => :sunday
+      }, options
     end
-    return nil
-  end
-  
-  def self.scan_for_times(token, options)
-    if token.word =~ /^\d{1,2}(:?\d{2})?([\.:]?\d{2})?$/
-      return Chronic::RepeaterTime.new(token.word, options)
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_day_portions(token, options = {})
+      scan_for token, RepeaterDayPortion,
+      {
+        /^ams?$/ => :am,
+        /^pms?$/ => :pm,
+        /^mornings?$/ => :morning,
+        /^afternoons?$/ => :afternoon,
+        /^evenings?$/ => :evening,
+        /^(night|nite)s?$/ => :night
+      }, options
     end
-    return nil
-  end
-  
-  def self.scan_for_units(token)
-    scanner = {/^years?$/ => :year,
-               /^seasons?$/ => :season,
-               /^months?$/ => :month,
-               /^fortnights?$/ => :fortnight,
-               /^weeks?$/ => :week,
-               /^weekends?$/ => :weekend,
-               /^days?$/ => :day,
-               /^hours?$/ => :hour,
-               /^minutes?$/ => :minute,
-               /^seconds?$/ => :second}
-    scanner.keys.each do |scanner_item|
-      if scanner_item =~ token.word
-        klass_name = 'Chronic::Repeater' + scanner[scanner_item].to_s.capitalize
-        klass = eval(klass_name)
-        return klass.new(scanner[scanner_item]) 
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    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, options = {})
+      {
+        /^years?$/ => :year,
+        /^seasons?$/ => :season,
+        /^months?$/ => :month,
+        /^fortnights?$/ => :fortnight,
+        /^weeks?$/ => :week,
+        /^weekends?$/ => :weekend,
+        /^(week|business)days?$/ => :weekday,
+        /^days?$/ => :day,
+	      /^hrs?$/ => :hour,
+        /^hours?$/ => :hour,
+	      /^mins?$/ => :minute,
+        /^minutes?$/ => :minute,
+	      /^secs?$/ => :second,
+        /^seconds?$/ => :second
+      }.each do |item, symbol|
+        if item =~ token.word
+          klass_name = 'Repeater' + symbol.to_s.capitalize
+          klass = Chronic.const_get(klass_name)
+          return klass.new(symbol, options)
+        end
       end
+      return nil
+    end
+
+    def <=>(other)
+      width <=> other.width
+    end
+
+    # returns the width (in seconds or months) of this repeatable.
+    def width
+      raise("Repeater#width must be overridden in subclasses")
+    end
+
+    # returns the next occurance of this repeatable.
+    def next(pointer)
+      raise("Start point must be set before calling #next") unless @now
+    end
+
+    def this(pointer)
+      raise("Start point must be set before calling #this") unless @now
+    end
+
+    def to_s
+      'repeater'
     end
-    return nil
-  end
-  
-  def <=>(other)
-    width <=> other.width
-  end
-  
-  # returns the width (in seconds or months) of this repeatable.
-  def width
-    raise("Repeatable#width must be overridden in subclasses")
-  end
-  
-  # returns the next occurance of this repeatable.
-  def next(pointer)
-    !@now.nil? || raise("Start point must be set before calling #next")
-    [:future, :none, :past].include?(pointer) || raise("First argument 'pointer' must be one of :past or :future")
-    #raise("Repeatable#next must be overridden in subclasses")
-  end
-  
-  def this(pointer)
-    !@now.nil? || raise("Start point must be set before calling #this")
-    [:future, :past, :none].include?(pointer) || raise("First argument 'pointer' must be one of :past, :future, :none")
-  end
-  
-  def to_s
-    'repeater'
   end
-end
+end

data/lib/chronic/repeaters/repeater_day.rb

@@ -1,47 +1,54 @@
-class Chronic::RepeaterDay < Chronic::Repeater #:nodoc:
-  DAY_SECONDS = 86_400 # (24 * 60 * 60)
-  
-  def next(pointer)
-    super
-    
-    if !@current_day_start
-      @current_day_start = Time.local(@now.year, @now.month, @now.day)
+module Chronic
+  class RepeaterDay < Repeater #:nodoc:
+    DAY_SECONDS = 86_400 # (24 * 60 * 60)
+
+    def initialize(type, options = {})
+      super
+      @current_day_start = nil
     end
-    
-    direction = pointer == :future ? 1 : -1
-    @current_day_start += direction * DAY_SECONDS
-    
-    Chronic::Span.new(@current_day_start, @current_day_start + DAY_SECONDS)
-  end
-  
-  def this(pointer = :future)
-    super
-    
-    case pointer
-    when :future
-      day_begin = Time.construct(@now.year, @now.month, @now.day, @now.hour + 1)
-      day_end = Time.construct(@now.year, @now.month, @now.day) + DAY_SECONDS
-    when :past
-      day_begin = Time.construct(@now.year, @now.month, @now.day)
-      day_end = Time.construct(@now.year, @now.month, @now.day, @now.hour)
-    when :none
-      day_begin = Time.construct(@now.year, @now.month, @now.day)
-      day_end = Time.construct(@now.year, @now.month, @now.day) + DAY_SECONDS
+
+    def next(pointer)
+      super
+
+      unless @current_day_start
+        @current_day_start = Chronic.time_class.local(@now.year, @now.month, @now.day)
+      end
+
+      direction = pointer == :future ? 1 : -1
+      @current_day_start += direction * DAY_SECONDS
+
+      Span.new(@current_day_start, @current_day_start + DAY_SECONDS)
+    end
+
+    def this(pointer = :future)
+      super
+
+      case pointer
+      when :future
+        day_begin = Chronic.construct(@now.year, @now.month, @now.day, @now.hour)
+        day_end = Chronic.construct(@now.year, @now.month, @now.day) + DAY_SECONDS
+      when :past
+        day_begin = Chronic.construct(@now.year, @now.month, @now.day)
+        day_end = Chronic.construct(@now.year, @now.month, @now.day, @now.hour)
+      when :none
+        day_begin = Chronic.construct(@now.year, @now.month, @now.day)
+        day_end = Chronic.construct(@now.year, @now.month, @now.day) + DAY_SECONDS
+      end
+
+      Span.new(day_begin, day_end)
+    end
+
+    def offset(span, amount, pointer)
+      direction = pointer == :future ? 1 : -1
+      span + direction * amount * DAY_SECONDS
+    end
+
+    def width
+      DAY_SECONDS
+    end
+
+    def to_s
+      super << '-day'
     end
-    
-    Chronic::Span.new(day_begin, day_end)
-  end
-  
-  def offset(span, amount, pointer)
-    direction = pointer == :future ? 1 : -1
-    span + direction * amount * DAY_SECONDS
-  end
-  
-  def width
-    DAY_SECONDS
-  end
-  
-  def to_s
-    super << '-day'
   end
-end
+end

data/lib/chronic/repeaters/repeater_day_name.rb

@@ -1,46 +1,53 @@
-class Chronic::RepeaterDayName < Chronic::Repeater #:nodoc:
-  DAY_SECONDS = 86400 # (24 * 60 * 60)
-  
-  def next(pointer)
-    super
-    
-    direction = pointer == :future ? 1 : -1
-    
-    if !@current_day_start
-      @current_day_start = Time.construct(@now.year, @now.month, @now.day)
-      @current_day_start += direction * DAY_SECONDS
-
-      day_num = symbol_to_number(@type)
-      
-      while @current_day_start.wday != day_num
-        @current_day_start += direction * DAY_SECONDS
+module Chronic
+  class RepeaterDayName < Repeater #:nodoc:
+    DAY_SECONDS = 86400 # (24 * 60 * 60)
+
+    def initialize(type, options = {})
+      super
+      @current_date = nil
+    end
+
+    def next(pointer)
+      super
+
+      direction = pointer == :future ? 1 : -1
+
+      unless @current_date
+        @current_date = ::Date.new(@now.year, @now.month, @now.day)
+        @current_date += direction
+
+        day_num = symbol_to_number(@type)
+
+        while @current_date.wday != day_num
+          @current_date += direction
+        end
+      else
+        @current_date += direction * 7
       end
-    else
-      @current_day_start += direction * 7 * DAY_SECONDS
+      next_date = @current_date.succ
+      Span.new(Chronic.construct(@current_date.year, @current_date.month, @current_date.day), Chronic.construct(next_date.year, next_date.month, next_date.day))
+    end
+
+    def this(pointer = :future)
+      super
+
+      pointer = :future if pointer == :none
+      self.next(pointer)
+    end
+
+    def width
+      DAY_SECONDS
+    end
+
+    def to_s
+      super << '-dayname-' << @type.to_s
+    end
+
+    private
+
+    def symbol_to_number(sym)
+      lookup = {:sunday => 0, :monday => 1, :tuesday => 2, :wednesday => 3, :thursday => 4, :friday => 5, :saturday => 6}
+      lookup[sym] || raise("Invalid symbol specified")
     end
-    
-    Chronic::Span.new(@current_day_start, @current_day_start + DAY_SECONDS)
-  end
-  
-  def this(pointer = :future)
-    super
-    
-    pointer = :future if pointer == :none
-    self.next(pointer)
-  end
-  
-  def width
-    DAY_SECONDS
-  end
-  
-  def to_s
-    super << '-dayname-' << @type.to_s
-  end
-  
-  private
-  
-  def symbol_to_number(sym)
-    lookup = {:sunday => 0, :monday => 1, :tuesday => 2, :wednesday => 3, :thursday => 4, :friday => 5, :saturday => 6}
-    lookup[sym] || raise("Invalid symbol specified")
   end
-end
+end

data/lib/chronic/repeaters/repeater_day_portion.rb

@@ -1,93 +1,109 @@
-class Chronic::RepeaterDayPortion < Chronic::Repeater #:nodoc:
-  @@morning = (6 * 60 * 60)..(12 * 60 * 60) # 6am-12am
-  @@afternoon = (13 * 60 * 60)..(17 * 60 * 60) # 1pm-5pm
-  @@evening = (17 * 60 * 60)..(20 * 60 * 60) # 5pm-8pm
-  @@night = (20 * 60 * 60)..(24 * 60 * 60) # 8pm-12pm
-  
-  def initialize(type)
-    super
-    
-    if type.kind_of? Integer
-      @range = (@type * 60 * 60)..((@type + 12) * 60 * 60)
-    else
-      lookup = {:am => 1..(12 * 60 * 60),
-                :pm => (12 * 60 * 60)..(24 * 60 * 60),
-                :morning => @@morning,
-                :afternoon => @@afternoon,
-                :evening => @@evening,
-                :night => @@night}
-      @range = lookup[type]
-      lookup[type] || raise("Invalid type '#{type}' for RepeaterDayPortion")
+module Chronic
+  class RepeaterDayPortion < Repeater #:nodoc:
+    PORTIONS = {
+      :am => 0..(12 * 60 * 60 - 1),
+      :pm => (12 * 60 * 60)..(24 * 60 * 60 - 1),
+      :morning => (6 * 60 * 60)..(12 * 60 * 60),    # 6am-12am,
+      :afternoon => (13 * 60 * 60)..(17 * 60 * 60), # 1pm-5pm,
+      :evening => (17 * 60 * 60)..(20 * 60 * 60),   # 5pm-8pm,
+      :night => (20 * 60 * 60)..(24 * 60 * 60),     # 8pm-12pm
+    }
+
+    def initialize(type, options = {})
+      super
+      @current_span = nil
+
+      if type.kind_of? Integer
+        @range = (@type * 60 * 60)..((@type + 12) * 60 * 60)
+      else
+        @range = PORTIONS[type]
+        @range || raise("Invalid type '#{type}' for RepeaterDayPortion")
+      end
+
+      @range || raise("Range should have been set by now")
     end
-    @range || raise("Range should have been set by now")
-  end
-  
-  def next(pointer)
-    super
-    
-    full_day = 60 * 60 * 24
-    
-    if !@current_span
-      now_seconds = @now - Time.construct(@now.year, @now.month, @now.day)
-      if now_seconds < @range.begin
-        case pointer
-        when :future
-          range_start = Time.construct(@now.year, @now.month, @now.day) + @range.begin
-        when :past
-          range_start = Time.construct(@now.year, @now.month, @now.day) - full_day + @range.begin
-        end
-      elsif now_seconds > @range.end
-        case pointer
-        when :future
-          range_start = Time.construct(@now.year, @now.month, @now.day) + full_day + @range.begin
-        when :past
-          range_start = Time.construct(@now.year, @now.month, @now.day) + @range.begin
+
+    def next(pointer)
+      super
+
+      unless @current_span
+        now_seconds = @now - Chronic.construct(@now.year, @now.month, @now.day)
+        if now_seconds < @range.begin
+          case pointer
+          when :future
+            range_start = Chronic.construct(@now.year, @now.month, @now.day) + @range.begin
+          when :past
+            range_start = Chronic.construct(@now.year, @now.month, @now.day - 1) + @range.begin
+          end
+        elsif now_seconds > @range.end
+          case pointer
+          when :future
+            range_start = Chronic.construct(@now.year, @now.month, @now.day + 1) + @range.begin
+          when :past
+            range_start = Chronic.construct(@now.year, @now.month, @now.day) + @range.begin
+          end
+        else
+          case pointer
+          when :future
+            range_start = Chronic.construct(@now.year, @now.month, @now.day + 1) + @range.begin
+          when :past
+            range_start = Chronic.construct(@now.year, @now.month, @now.day - 1) + @range.begin
+          end
         end
+        offset = (@range.end - @range.begin)
+        range_end = construct_date_from_reference_and_offset(range_start, offset)
+        @current_span = Span.new(range_start, range_end)
       else
+        days_to_shift_window =
         case pointer
         when :future
-          range_start = Time.construct(@now.year, @now.month, @now.day) + full_day + @range.begin
+          1
         when :past
-          range_start = Time.construct(@now.year, @now.month, @now.day) - full_day + @range.begin
+          -1
         end
+
+        new_begin = Chronic.construct(@current_span.begin.year, @current_span.begin.month, @current_span.begin.day + days_to_shift_window, @current_span.begin.hour, @current_span.begin.min, @current_span.begin.sec)
+        new_end = Chronic.construct(@current_span.end.year, @current_span.end.month, @current_span.end.day + days_to_shift_window, @current_span.end.hour, @current_span.end.min, @current_span.end.sec)
+        @current_span = Span.new(new_begin, new_end)
       end
-      
-      @current_span = Chronic::Span.new(range_start, range_start + (@range.end - @range.begin))
-    else
-      case pointer
-      when :future
-        @current_span += full_day
-      when :past
-        @current_span -= full_day
+    end
+
+    def this(context = :future)
+      super
+
+      range_start = Chronic.construct(@now.year, @now.month, @now.day) + @range.begin
+      range_end = construct_date_from_reference_and_offset(range_start)
+      @current_span = Span.new(range_start, range_end)
+    end
+
+    def offset(span, amount, pointer)
+      @now = span.begin
+      portion_span = self.next(pointer)
+      direction = pointer == :future ? 1 : -1
+      portion_span + (direction * (amount - 1) * RepeaterDay::DAY_SECONDS)
+    end
+
+    def width
+      @range || raise("Range has not been set")
+      return @current_span.width if @current_span
+      if @type.kind_of? Integer
+        return (12 * 60 * 60)
+      else
+        @range.end - @range.begin
       end
     end
-  end
-  
-  def this(context = :future)
-    super
-    
-    range_start = Time.construct(@now.year, @now.month, @now.day) + @range.begin
-    @current_span = Chronic::Span.new(range_start, range_start + (@range.end - @range.begin))
-  end
-  
-  def offset(span, amount, pointer)
-    @now = span.begin
-    portion_span = self.next(pointer)
-    direction = pointer == :future ? 1 : -1
-    portion_span + (direction * (amount - 1) * Chronic::RepeaterDay::DAY_SECONDS)
-  end
-  
-  def width
-    @range || raise("Range has not been set")
-    return @current_span.width if @current_span
-    if @type.kind_of? Integer
-      return (12 * 60 * 60)
-    else
-      @range.end - @range.begin
+
+    def to_s
+      super << '-dayportion-' << @type.to_s
+    end
+
+    private
+    def construct_date_from_reference_and_offset(reference, offset = nil)
+      elapsed_seconds_for_range = offset || (@range.end - @range.begin)
+      second_hand = ((elapsed_seconds_for_range - (12 * 60))) % 60
+      minute_hand = (elapsed_seconds_for_range - second_hand) / (60) % 60
+      hour_hand = (elapsed_seconds_for_range - minute_hand - second_hand) / (60 * 60) + reference.hour % 24
+      Chronic.construct(reference.year, reference.month, reference.day, hour_hand, minute_hand, second_hand)
     end
   end
-  
-  def to_s
-    super << '-dayportion-' << @type.to_s
-  end
-end
+end