chronic-mmlac 0.6.4.2

data/lib/chronic/repeater.rb

@@ -0,0 +1,135 @@
+module Chronic
+  class Repeater < Tag
+
+    # Scan an Array of {Token}s and apply any necessary Repeater tags to
+    # each token
+    #
+    # @param [Array<Token>] tokens Array of tokens to scan
+    # @param [Hash] options Options specified in {Chronic.parse}
+    # @return [Array] list 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
+      end
+    end
+
+    # @param [Token] token
+    # @return [RepeaterSeasonName, nil]
+    def self.scan_for_season_names(token)
+      scan_for token, RepeaterSeasonName,
+      {
+        /^springs?$/ => :spring,
+        /^summers?$/ => :summer,
+        /^(autumn)|(fall)s?$/ => :autumn,
+        /^winters?$/ => :winter
+      }
+    end
+
+    # @param [Token] token
+    # @return [RepeaterMonthName, nil]
+    def self.scan_for_month_names(token)
+      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
+      }
+    end
+
+    # @param [Token] token
+    # @return [RepeaterDayName, nil]
+    def self.scan_for_day_names(token)
+      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(?:rs)?|ers)(day)?$/ => :thursday,
+        /^fr[iy](day)?$/ => :friday,
+        /^sat(t?[ue]rday)?$/ => :saturday,
+        /^su[nm](day)?$/ => :sunday
+      }
+    end
+
+    # @param [Token] token
+    # @return [RepeaterDayPortion, nil]
+    def self.scan_for_day_portions(token)
+      scan_for token, RepeaterDayPortion,
+      {
+        /^ams?$/ => :am,
+        /^pms?$/ => :pm,
+        /^mornings?$/ => :morning,
+        /^afternoons?$/ => :afternoon,
+        /^evenings?$/ => :evening,
+        /^(night|nite)s?$/ => :night
+      }
+    end
+
+    # @param [Token] token
+    # @return [RepeaterTime, nil]
+    def self.scan_for_times(token)
+      scan_for token, RepeaterTime, /^\d{1,2}(:?\d{2})?([\.:]?\d{2})?$/
+    end
+
+    # @param [Token] token
+    # @return [Repeater] A new instance of a subclass of Repeater
+    def self.scan_for_units(token)
+      {
+        /^years?$/ => :year,
+        /^seasons?$/ => :season,
+        /^months?$/ => :month,
+        /^fortnights?$/ => :fortnight,
+        /^weeks?$/ => :week,
+        /^weekends?$/ => :weekend,
+        /^(week|business)days?$/ => :weekday,
+        /^days?$/ => :day,
+        /^hours?$/ => :hour,
+        /^minutes?$/ => :minute,
+        /^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)
+        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
+  end
+end

data/lib/chronic/repeaters/repeater_day.rb

@@ -0,0 +1,53 @@
+module Chronic
+  class RepeaterDay < Repeater #:nodoc:
+    DAY_SECONDS = 86_400 # (24 * 60 * 60)
+
+    def initialize(type)
+      super
+    end
+
+    def next(pointer)
+      super
+
+      if !@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
+  end
+end

data/lib/chronic/repeaters/repeater_day_name.rb

@@ -0,0 +1,52 @@
+module Chronic
+  class RepeaterDayName < Repeater #:nodoc:
+    DAY_SECONDS = 86400 # (24 * 60 * 60)
+
+    def initialize(type)
+      super
+    end
+
+    def next(pointer)
+      super
+
+      direction = pointer == :future ? 1 : -1
+
+      if !@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
+      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
+  end
+end

data/lib/chronic/repeaters/repeater_day_portion.rb

@@ -0,0 +1,94 @@
+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)
+      super
+
+      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
+
+    def next(pointer)
+      super
+
+      full_day = 60 * 60 * 24
+
+      if !@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) - full_day + @range.begin
+          end
+        elsif now_seconds > @range.end
+          case pointer
+          when :future
+            range_start = Chronic.construct(@now.year, @now.month, @now.day) + full_day + @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) + full_day + @range.begin
+          when :past
+            range_start = Chronic.construct(@now.year, @now.month, @now.day) - full_day + @range.begin
+          end
+        end
+
+        @current_span = 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
+      end
+    end
+
+    def this(context = :future)
+      super
+
+      range_start = Chronic.construct(@now.year, @now.month, @now.day) + @range.begin
+      @current_span = 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) * 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
+
+    def to_s
+      super << '-dayportion-' << @type.to_s
+    end
+  end
+end

data/lib/chronic/repeaters/repeater_fortnight.rb

@@ -0,0 +1,71 @@
+module Chronic
+  class RepeaterFortnight < Repeater #:nodoc:
+    FORTNIGHT_SECONDS = 1_209_600 # (14 * 24 * 60 * 60)
+
+    def initialize(type)
+      super
+    end
+
+    def next(pointer)
+      super
+
+      if !@current_fortnight_start
+        case pointer
+        when :future
+          sunday_repeater = RepeaterDayName.new(:sunday)
+          sunday_repeater.start = @now
+          next_sunday_span = sunday_repeater.next(:future)
+          @current_fortnight_start = next_sunday_span.begin
+        when :past
+          sunday_repeater = RepeaterDayName.new(:sunday)
+          sunday_repeater.start = (@now + RepeaterDay::DAY_SECONDS)
+          2.times { sunday_repeater.next(:past) }
+          last_sunday_span = sunday_repeater.next(:past)
+          @current_fortnight_start = last_sunday_span.begin
+        end
+      else
+        direction = pointer == :future ? 1 : -1
+        @current_fortnight_start += direction * FORTNIGHT_SECONDS
+      end
+
+      Span.new(@current_fortnight_start, @current_fortnight_start + FORTNIGHT_SECONDS)
+    end
+
+    def this(pointer = :future)
+      super
+
+      pointer = :future if pointer == :none
+
+      case pointer
+      when :future
+        this_fortnight_start = Chronic.construct(@now.year, @now.month, @now.day, @now.hour) + RepeaterHour::HOUR_SECONDS
+        sunday_repeater = RepeaterDayName.new(:sunday)
+        sunday_repeater.start = @now
+        sunday_repeater.this(:future)
+        this_sunday_span = sunday_repeater.this(:future)
+        this_fortnight_end = this_sunday_span.begin
+        Span.new(this_fortnight_start, this_fortnight_end)
+      when :past
+        this_fortnight_end = Chronic.construct(@now.year, @now.month, @now.day, @now.hour)
+        sunday_repeater = RepeaterDayName.new(:sunday)
+        sunday_repeater.start = @now
+        last_sunday_span = sunday_repeater.next(:past)
+        this_fortnight_start = last_sunday_span.begin
+        Span.new(this_fortnight_start, this_fortnight_end)
+      end
+    end
+
+    def offset(span, amount, pointer)
+      direction = pointer == :future ? 1 : -1
+      span + direction * amount * FORTNIGHT_SECONDS
+    end
+
+    def width
+      FORTNIGHT_SECONDS
+    end
+
+    def to_s
+      super << '-fortnight'
+    end
+  end
+end

data/lib/chronic/repeaters/repeater_hour.rb

@@ -0,0 +1,58 @@
+module Chronic
+  class RepeaterHour < Repeater #:nodoc:
+    HOUR_SECONDS = 3600 # 60 * 60
+
+    def initialize(type)
+      super
+    end
+
+    def next(pointer)
+      super
+
+      if !@current_hour_start
+        case pointer
+        when :future
+          @current_hour_start = Chronic.construct(@now.year, @now.month, @now.day, @now.hour + 1)
+        when :past
+          @current_hour_start = Chronic.construct(@now.year, @now.month, @now.day, @now.hour - 1)
+        end
+      else
+        direction = pointer == :future ? 1 : -1
+        @current_hour_start += direction * HOUR_SECONDS
+      end
+
+      Span.new(@current_hour_start, @current_hour_start + HOUR_SECONDS)
+    end
+
+    def this(pointer = :future)
+      super
+
+      case pointer
+      when :future
+        hour_start = Chronic.construct(@now.year, @now.month, @now.day, @now.hour, @now.min + 1)
+        hour_end = Chronic.construct(@now.year, @now.month, @now.day, @now.hour + 1)
+      when :past
+        hour_start = Chronic.construct(@now.year, @now.month, @now.day, @now.hour)
+        hour_end = Chronic.construct(@now.year, @now.month, @now.day, @now.hour, @now.min)
+      when :none
+        hour_start = Chronic.construct(@now.year, @now.month, @now.day, @now.hour)
+        hour_end = hour_start + HOUR_SECONDS
+      end
+
+      Span.new(hour_start, hour_end)
+    end
+
+    def offset(span, amount, pointer)
+      direction = pointer == :future ? 1 : -1
+      span + direction * amount * HOUR_SECONDS
+    end
+
+    def width
+      HOUR_SECONDS
+    end
+
+    def to_s
+      super << '-hour'
+    end
+  end
+end

data/lib/chronic/repeaters/repeater_minute.rb

@@ -0,0 +1,58 @@
+module Chronic
+  class RepeaterMinute < Repeater #:nodoc:
+    MINUTE_SECONDS = 60
+
+    def initialize(type)
+      super
+    end
+
+    def next(pointer = :future)
+      super
+
+      if !@current_minute_start
+        case pointer
+        when :future
+          @current_minute_start = Chronic.construct(@now.year, @now.month, @now.day, @now.hour, @now.min + 1)
+        when :past
+          @current_minute_start = Chronic.construct(@now.year, @now.month, @now.day, @now.hour, @now.min - 1)
+        end
+      else
+        direction = pointer == :future ? 1 : -1
+        @current_minute_start += direction * MINUTE_SECONDS
+      end
+
+      Span.new(@current_minute_start, @current_minute_start + MINUTE_SECONDS)
+    end
+
+    def this(pointer = :future)
+      super
+
+      case pointer
+      when :future
+        minute_begin = @now
+        minute_end = Chronic.construct(@now.year, @now.month, @now.day, @now.hour, @now.min)
+      when :past
+        minute_begin = Chronic.construct(@now.year, @now.month, @now.day, @now.hour, @now.min)
+        minute_end = @now
+      when :none
+        minute_begin = Chronic.construct(@now.year, @now.month, @now.day, @now.hour, @now.min)
+        minute_end = Chronic.construct(@now.year, @now.month, @now.day, @now.hour, @now.min) + MINUTE_SECONDS
+      end
+
+      Span.new(minute_begin, minute_end)
+    end
+
+    def offset(span, amount, pointer)
+      direction = pointer == :future ? 1 : -1
+      span + direction * amount * MINUTE_SECONDS
+    end
+
+    def width
+      MINUTE_SECONDS
+    end
+
+    def to_s
+      super << '-minute'
+    end
+  end
+end

data/lib/chronic/repeaters/repeater_month.rb

@@ -0,0 +1,79 @@
+module Chronic
+  class RepeaterMonth < Repeater #:nodoc:
+    MONTH_SECONDS = 2_592_000 # 30 * 24 * 60 * 60
+    YEAR_MONTHS = 12
+    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)
+      super
+    end
+
+    def next(pointer)
+      super
+
+      if !@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)
+      end
+
+      Span.new(@current_month_start, Chronic.construct(@current_month_start.year, @current_month_start.month + 1))
+    end
+
+    def this(pointer = :future)
+      super
+
+      case pointer
+      when :future
+        month_start = Chronic.construct(@now.year, @now.month, @now.day + 1)
+        month_end = self.offset_by(Chronic.construct(@now.year, @now.month), 1, :future)
+      when :past
+        month_start = Chronic.construct(@now.year, @now.month)
+        month_end = Chronic.construct(@now.year, @now.month, @now.day)
+      when :none
+        month_start = Chronic.construct(@now.year, @now.month)
+        month_end = self.offset_by(Chronic.construct(@now.year, @now.month), 1, :future)
+      end
+
+      Span.new(month_start, month_end)
+    end
+
+    def offset(span, amount, pointer)
+      Span.new(offset_by(span.begin, amount, pointer), offset_by(span.end, amount, pointer))
+    end
+
+    def offset_by(time, amount, pointer)
+      direction = pointer == :future ? 1 : -1
+
+      amount_years = direction * amount / YEAR_MONTHS
+      amount_months = direction * amount % YEAR_MONTHS
+
+      new_year = time.year + amount_years
+      new_month = time.month + amount_months
+      if new_month > YEAR_MONTHS
+        new_year += 1
+        new_month -= YEAR_MONTHS
+      end
+
+      days = month_days(new_year, new_month)
+      new_day = time.day > days ? days : time.day
+
+      Chronic.construct(new_year, new_month, new_day, time.hour, time.min, time.sec)
+    end
+
+    def width
+      MONTH_SECONDS
+    end
+
+    def to_s
+      super << '-month'
+    end
+
+    private
+
+    def month_days(year, month)
+      Date.leap?(year) ? MONTH_DAYS_LEAP[month - 1] : MONTH_DAYS[month - 1]
+    end
+  end
+end

data/lib/chronic/repeaters/repeater_month_name.rb

@@ -0,0 +1,94 @@
+module Chronic
+  class RepeaterMonthName < Repeater #:nodoc:
+    MONTH_SECONDS = 2_592_000 # 30 * 24 * 60 * 60
+    MONTHS = {
+      :january => 1,
+      :february => 2,
+      :march => 3,
+      :april => 4,
+      :may => 5,
+      :june => 6,
+      :july => 7,
+      :august => 8,
+      :september => 9,
+      :october => 10,
+      :november => 11,
+      :december => 12
+    }
+
+    def initialize(type)
+      super
+    end
+
+    def next(pointer)
+      super
+
+      if !@current_month_begin
+        case pointer
+        when :future
+          if @now.month < index
+            @current_month_begin = Chronic.construct(@now.year, index)
+          elsif @now.month > index
+            @current_month_begin = Chronic.construct(@now.year + 1, index)
+          end
+        when :none
+          if @now.month <= index
+            @current_month_begin = Chronic.construct(@now.year, index)
+          elsif @now.month > index
+            @current_month_begin = Chronic.construct(@now.year + 1, index)
+          end
+        when :past
+          if @now.month >= index
+            @current_month_begin = Chronic.construct(@now.year, index)
+          elsif @now.month < index
+            @current_month_begin = Chronic.construct(@now.year - 1, index)
+          end
+        end
+        @current_month_begin || raise("Current month should be set by now")
+      else
+        case pointer
+        when :future
+          @current_month_begin = Chronic.construct(@current_month_begin.year + 1, @current_month_begin.month)
+        when :past
+          @current_month_begin = Chronic.construct(@current_month_begin.year - 1, @current_month_begin.month)
+        end
+      end
+
+      cur_month_year = @current_month_begin.year
+      cur_month_month = @current_month_begin.month
+
+      if cur_month_month == 12
+        next_month_year = cur_month_year + 1
+        next_month_month = 1
+      else
+        next_month_year = cur_month_year
+        next_month_month = cur_month_month + 1
+      end
+
+      Span.new(@current_month_begin, Chronic.construct(next_month_year, next_month_month))
+    end
+
+    def this(pointer = :future)
+      super
+
+      case pointer
+      when :past
+        self.next(pointer)
+      when :future, :none
+        self.next(:none)
+      end
+    end
+
+    def width
+      MONTH_SECONDS
+    end
+
+    def index
+      @index ||= MONTHS[@type]
+    end
+
+    def to_s
+      super << '-monthname-' << @type.to_s
+    end
+  end
+end