chronic 0.2.3 → 0.4.0

data/lib/chronic/repeaters/repeater_month_name.rb

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

data/lib/chronic/repeaters/repeater_season.rb

@@ -1,23 +1,128 @@
-class Chronic::RepeaterSeason < Chronic::Repeater #:nodoc:
-  SEASON_SECONDS = 7_862_400 # 91 * 24 * 60 * 60
-  
-  def next(pointer)
-    super
-    
-    raise 'Not implemented'
+module Chronic
+  class Season
+    attr_reader :start, :end
+
+    def initialize(myStart, myEnd)
+      @start = myStart
+      @end = myEnd
+    end
+
+    def self.find_next_season(season, pointer)
+      lookup = {:spring => 0, :summer => 1, :autumn => 2, :winter => 3}
+      next_season_num = (lookup[season]+1*pointer) % 4
+      lookup.invert[next_season_num]
+    end
+
+    def self.season_after(season); find_next_season(season, +1); end
+    def self.season_before(season); find_next_season(season, -1); end
   end
-  
-  def this(pointer = :future)
-    super
-    
-    raise 'Not implemented'
-  end
-  
-  def width
-    SEASON_SECONDS
-  end
-  
-  def to_s
-    super << '-season'
+
+  class RepeaterSeason < Repeater #:nodoc:
+    SEASON_SECONDS = 7_862_400 # 91 * 24 * 60 * 60
+    SEASONS = {
+      :spring => Season.new(MiniDate.new(3,20), MiniDate.new(6,20)),
+      :summer => Season.new(MiniDate.new(6,21), MiniDate.new(9,22)),
+      :autumn => Season.new(MiniDate.new(9,23), MiniDate.new(12,21)),
+      :winter => Season.new(MiniDate.new(12,22), MiniDate.new(3,19))
+    }
+
+    def initialize(type)
+      super
+      @next_season_start = nil
+    end
+
+    def next(pointer)
+      super
+
+      direction = pointer == :future ? 1 : -1
+      next_season = Season.find_next_season(find_current_season(@now.to_minidate), direction)
+
+      find_next_season_span(direction, next_season)
+    end
+
+    def this(pointer = :future)
+      super
+
+      direction = pointer == :future ? 1 : -1
+
+      today = Time.construct(@now.year, @now.month, @now.day)
+      this_ssn = find_current_season(@now.to_minidate)
+      case pointer
+      when :past
+        this_ssn_start = today + direction * num_seconds_til_start(this_ssn, direction)
+        this_ssn_end = today
+      when :future
+        this_ssn_start = today + RepeaterDay::DAY_SECONDS
+        this_ssn_end = today + direction * num_seconds_til_end(this_ssn, direction)
+      when :none
+        this_ssn_start = today + direction * num_seconds_til_start(this_ssn, direction)
+        this_ssn_end = today + direction * num_seconds_til_end(this_ssn, direction)
+      end
+
+      construct_season(this_ssn_start, this_ssn_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
+      time + amount * direction * SEASON_SECONDS
+    end
+
+    def width
+      SEASON_SECONDS
+    end
+
+    def to_s
+      super << '-season'
+    end
+
+    private
+
+    def find_next_season_span(direction, next_season)
+      if !@next_season_start or !@next_season_end
+        @next_season_start = Time.construct(@now.year, @now.month, @now.day)
+        @next_season_end = Time.construct(@now.year, @now.month, @now.day)
+      end
+
+      @next_season_start += direction * num_seconds_til_start(next_season, direction)
+      @next_season_end += direction * num_seconds_til_end(next_season, direction)
+
+      construct_season(@next_season_start, @next_season_end)
+    end
+
+    def find_current_season(md)
+      [:spring, :summer, :autumn, :winter].find do |season|
+        md.is_between?(SEASONS[season].start, SEASONS[season].end)
+      end
+    end
+
+    def num_seconds_til(goal, direction)
+      start = Time.construct(@now.year, @now.month, @now.day)
+      seconds = 0
+
+      until (start + direction * seconds).to_minidate.equals?(goal)
+        seconds += RepeaterDay::DAY_SECONDS
+      end
+
+      seconds
+    end
+
+    def num_seconds_til_start(season_symbol, direction)
+      num_seconds_til(SEASONS[season_symbol].start, direction)
+    end
+
+    def num_seconds_til_end(season_symbol, direction)
+      num_seconds_til(SEASONS[season_symbol].end, direction)
+    end
+
+    def construct_season(start, finish)
+      Span.new(
+        Time.construct(start.year, start.month, start.day),
+        Time.construct(finish.year, finish.month, finish.day)
+      )
+    end
   end
 end

data/lib/chronic/repeaters/repeater_season_name.rb

@@ -1,24 +1,45 @@
-class Chronic::RepeaterSeasonName < Chronic::RepeaterSeason #:nodoc:
-  @summer = ['jul 21', 'sep 22']
-  @autumn = ['sep 23', 'dec 21']
-  @winter = ['dec 22', 'mar 19']
-  @spring = ['mar 20', 'jul 20']
-  
-  def next(pointer)
-    super
-    raise 'Not implemented'
-  end
-  
-  def this(pointer = :future)
-    super
-    raise 'Not implemented'
-  end
-  
-  def width
-    (91 * 24 * 60 * 60)
-  end
-  
-  def to_s
-    super << '-season-' << @type.to_s
+module Chronic
+  class RepeaterSeasonName < RepeaterSeason #:nodoc:
+    SEASON_SECONDS = 7_862_400 # 91 * 24 * 60 * 60
+    DAY_SECONDS = 86_400 # (24 * 60 * 60)
+
+    def next(pointer)
+      direction = pointer == :future ? 1 : -1
+      find_next_season_span(direction, @type)
+    end
+
+    def this(pointer = :future)
+      # super
+
+      direction = pointer == :future ? 1 : -1
+
+      today = Time.construct(@now.year, @now.month, @now.day)
+      goal_ssn_start = today + direction * num_seconds_til_start(@type, direction)
+      goal_ssn_end = today + direction * num_seconds_til_end(@type, direction)
+      curr_ssn = find_current_season(@now.to_minidate)
+      case pointer
+      when :past
+        this_ssn_start = goal_ssn_start
+        this_ssn_end = (curr_ssn == @type) ? today : goal_ssn_end
+      when :future
+        this_ssn_start = (curr_ssn == @type) ? today + RepeaterDay::DAY_SECONDS : goal_ssn_start
+        this_ssn_end = goal_ssn_end
+      when :none
+        this_ssn_start = goal_ssn_start
+        this_ssn_end = goal_ssn_end
+      end
+
+      construct_season(this_ssn_start, this_ssn_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
+      time + amount * direction * RepeaterYear::YEAR_SECONDS
+    end
+
   end
 end

data/lib/chronic/repeaters/repeater_second.rb

@@ -1,36 +1,43 @@
-class Chronic::RepeaterSecond < Chronic::Repeater #:nodoc:
-  SECOND_SECONDS = 1 # haha, awesome
-  
-  def next(pointer = :future)
-    super
-    
-    direction = pointer == :future ? 1 : -1
-    
-    if !@second_start
-      @second_start = @now + (direction * SECOND_SECONDS)
-    else
-      @second_start += SECOND_SECONDS * direction
+module Chronic
+  class RepeaterSecond < Repeater #:nodoc:
+    SECOND_SECONDS = 1 # haha, awesome
+
+    def initialize(type)
+      super
+      @second_start = nil
+    end
+
+    def next(pointer = :future)
+      super
+
+      direction = pointer == :future ? 1 : -1
+
+      if !@second_start
+        @second_start = @now + (direction * SECOND_SECONDS)
+      else
+        @second_start += SECOND_SECONDS * direction
+      end
+
+      Span.new(@second_start, @second_start + SECOND_SECONDS)
+    end
+
+    def this(pointer = :future)
+      super
+
+      Span.new(@now, @now + 1)
+    end
+
+    def offset(span, amount, pointer)
+      direction = pointer == :future ? 1 : -1
+      span + direction * amount * SECOND_SECONDS
+    end
+
+    def width
+      SECOND_SECONDS
+    end
+
+    def to_s
+      super << '-second'
     end
-    
-    Chronic::Span.new(@second_start, @second_start + SECOND_SECONDS)
-  end
-  
-  def this(pointer = :future)
-    super
-    
-    Chronic::Span.new(@now, @now + 1)
-  end
-  
-  def offset(span, amount, pointer)
-    direction = pointer == :future ? 1 : -1
-    span + direction * amount * SECOND_SECONDS
-  end
-  
-  def width
-    SECOND_SECONDS
-  end
-  
-  def to_s
-    super << '-second'
   end
 end