chronic 0.3.0 → 0.4.0

data/lib/chronic/repeaters/repeater_season.rb

@@ -1,150 +1,128 @@
-class Time
-  def to_minidate
-    MiniDate.new(self.month, self.day)
-  end
-end
-
-class Season
-  attr_reader :start, :end
-
-  def initialize(myStart, myEnd)
-    @start = myStart
-    @end = myEnd
-  end
+module Chronic
+  class Season
+    attr_reader :start, :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 initialize(myStart, myEnd)
+      @start = myStart
+      @end = myEnd
+    end
 
-class MiniDate
-  attr_accessor :month, :day
+    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 initialize(month, day)
-    @month = month
-    @day = day
+    def self.season_after(season); find_next_season(season, +1); end
+    def self.season_before(season); find_next_season(season, -1); end
   end
 
-  def is_between?(md_start, md_end)
-    return true if (@month == md_start.month and @day >= md_start.day) ||
-                   (@month == md_end.month and @day <= md_end.day)
+  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))
+    }
 
-    i = md_start.month + 1
-    until i == md_end.month
-      return true if @month == i
-      i = (i+1) % 12
+    def initialize(type)
+      super
+      @next_season_start = nil
     end
 
-    return false
-  end
+    def next(pointer)
+      super
 
-  def equals?(other)
-    @month == other.month and day == other.day
-  end
-end
-
-class Chronic::RepeaterSeason < Chronic::Repeater #:nodoc:
-  YEAR_SEASONS = 4
-  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
+      direction = pointer == :future ? 1 : -1
+      next_season = Season.find_next_season(find_current_season(@now.to_minidate), direction)
 
-  def next(pointer)
-    super
+      find_next_season_span(direction, next_season)
+    end
 
-    direction = pointer == :future ? 1 : -1
-    next_season = Season.find_next_season(find_current_season(@now.to_minidate), direction)
+    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
 
-    find_next_season_span(direction, next_season)
-  end
+    def offset(span, amount, pointer)
+      Span.new(offset_by(span.begin, amount, pointer), offset_by(span.end, amount, pointer))
+    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 + Chronic::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)
+    def offset_by(time, amount, pointer)
+      direction = pointer == :future ? 1 : -1
+      time + amount * direction * SEASON_SECONDS
     end
 
-    Chronic::Span.new(this_ssn_start, this_ssn_end)
-  end
+    def width
+      SEASON_SECONDS
+    end
 
-  def offset(span, amount, pointer)
-    Chronic::Span.new(offset_by(span.begin, amount, pointer), offset_by(span.end, amount, pointer))
-  end
+    def to_s
+      super << '-season'
+    end
 
-  def offset_by(time, amount, pointer)
-    direction = pointer == :future ? 1 : -1
-    time + amount * direction * SEASON_SECONDS
-  end
+    private
 
-  def width
-    SEASON_SECONDS
-  end
+    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
 
-  def to_s
-    super << '-season'
-  end
+      @next_season_start += direction * num_seconds_til_start(next_season, direction)
+      @next_season_end += direction * num_seconds_til_end(next_season, direction)
 
-  private
+      construct_season(@next_season_start, @next_season_end)
+    end
 
-  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)
+    def find_current_season(md)
+      [:spring, :summer, :autumn, :winter].find do |season|
+        md.is_between?(SEASONS[season].start, SEASONS[season].end)
+      end
     end
 
-    @next_season_start += direction * num_seconds_til_start(next_season, direction)
-    @next_season_end += direction * num_seconds_til_end(next_season, direction)
+    def num_seconds_til(goal, direction)
+      start = Time.construct(@now.year, @now.month, @now.day)
+      seconds = 0
 
-    Chronic::Span.new(@next_season_start, @next_season_end)
-  end
+      until (start + direction * seconds).to_minidate.equals?(goal)
+        seconds += RepeaterDay::DAY_SECONDS
+      end
 
-  def find_current_season(md)
-    [:spring, :summer, :autumn, :winter].each do |season|
-      return season if md.is_between?(SEASONS[season].start, SEASONS[season].end)
+      seconds
     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 += Chronic::RepeaterDay::DAY_SECONDS
+    def num_seconds_til_start(season_symbol, direction)
+      num_seconds_til(SEASONS[season_symbol].start, direction)
     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 num_seconds_til_end(season_symbol, direction)
-    num_seconds_til(SEASONS[season_symbol].end, direction)
+    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
+end

data/lib/chronic/repeaters/repeater_season_name.rb

@@ -1,45 +1,45 @@
-require 'chronic/repeaters/repeater_season.rb'
-
-class Chronic::RepeaterSeasonName < Chronic::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
+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 + Chronic::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
+    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
 
-    Chronic::Span.new(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(span, amount, pointer)
-    Chronic::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
 
-  def offset_by(time, amount, pointer)
-    direction = pointer == :future ? 1 : -1
-    time + amount * direction * Chronic::RepeaterYear::YEAR_SECONDS
   end
-
-end
+end

data/lib/chronic/repeaters/repeater_second.rb

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

data/lib/chronic/repeaters/repeater_time.rb

@@ -1,124 +1,129 @@
-class Chronic::RepeaterTime < Chronic::Repeater #:nodoc:
-  class Tick #:nodoc:
-    attr_accessor :time
+module Chronic
+  class RepeaterTime < Repeater #:nodoc:
+    class Tick #:nodoc:
+      attr_accessor :time
+
+      def initialize(time, ambiguous = false)
+        @time = time
+        @ambiguous = ambiguous
+      end
 
-    def initialize(time, ambiguous = false)
-      @time = time
-      @ambiguous = ambiguous
-    end
+      def ambiguous?
+        @ambiguous
+      end
 
-    def ambiguous?
-      @ambiguous
-    end
+      def *(other)
+        Tick.new(@time * other, @ambiguous)
+      end
 
-    def *(other)
-      Tick.new(@time * other, @ambiguous)
-    end
+      def to_f
+        @time.to_f
+      end
 
-    def to_f
-      @time.to_f
-    end
+      def to_s
+        @time.to_s + (@ambiguous ? '?' : '')
+      end
 
-    def to_s
-      @time.to_s + (@ambiguous ? '?' : '')
     end
-  end
 
-  def initialize(time, options = {})
-    @current_time = nil
-    t = time.gsub(/\:/, '')
-
-    @type =
-    case t.size
-      when 1..2
-        hours = t.to_i
-        hours == 12 ? Tick.new(0 * 60 * 60, true) : Tick.new(hours * 60 * 60, true)
-      when 3
-        Tick.new((t[0..0].to_i * 60 * 60) + (t[1..2].to_i * 60), true)
-      when 4
-        ambiguous = time =~ /:/ && t[0..0].to_i != 0 && t[0..1].to_i <= 12
-        hours = t[0..1].to_i
-        hours == 12 ? Tick.new(0 * 60 * 60 + t[2..3].to_i * 60, ambiguous) : Tick.new(hours * 60 * 60 + t[2..3].to_i * 60, ambiguous)
-      when 5
-        Tick.new(t[0..0].to_i * 60 * 60 + t[1..2].to_i * 60 + t[3..4].to_i, true)
-      when 6
-        ambiguous = time =~ /:/ && t[0..0].to_i != 0 && t[0..1].to_i <= 12
-        hours = t[0..1].to_i
-        hours == 12 ? Tick.new(0 * 60 * 60 + t[2..3].to_i * 60 + t[4..5].to_i, ambiguous) : Tick.new(hours * 60 * 60 + t[2..3].to_i * 60 + t[4..5].to_i, ambiguous)
-      else
-        raise("Time cannot exceed six digits")
+    def initialize(time)
+      @current_time = nil
+      t = time.gsub(/\:/, '')
+
+      @type =
+      case t.size
+        when 1..2
+          hours = t.to_i
+          hours == 12 ? Tick.new(0 * 60 * 60, true) : Tick.new(hours * 60 * 60, true)
+        when 3
+          hours = t[0..0].to_i
+          ambiguous = hours > 1
+          Tick.new((hours * 60 * 60) + (t[1..2].to_i * 60), ambiguous)
+        when 4
+          ambiguous = time =~ /:/ && t[0..0].to_i != 0 && t[0..1].to_i <= 12
+          hours = t[0..1].to_i
+          hours == 12 ? Tick.new(0 * 60 * 60 + t[2..3].to_i * 60, ambiguous) : Tick.new(hours * 60 * 60 + t[2..3].to_i * 60, ambiguous)
+        when 5
+          Tick.new(t[0..0].to_i * 60 * 60 + t[1..2].to_i * 60 + t[3..4].to_i, true)
+        when 6
+          ambiguous = time =~ /:/ && t[0..0].to_i != 0 && t[0..1].to_i <= 12
+          hours = t[0..1].to_i
+          hours == 12 ? Tick.new(0 * 60 * 60 + t[2..3].to_i * 60 + t[4..5].to_i, ambiguous) : Tick.new(hours * 60 * 60 + t[2..3].to_i * 60 + t[4..5].to_i, ambiguous)
+        else
+          raise("Time cannot exceed six digits")
+      end
     end
-  end
-
-  # Return the next past or future Span for the time that this Repeater represents
-  #   pointer - Symbol representing which temporal direction to fetch the next day
-  #             must be either :past or :future
-  def next(pointer)
-    super
-
-    half_day = 60 * 60 * 12
-    full_day = 60 * 60 * 24
-
-    first = false
-
-    unless @current_time
-      first = true
-      midnight = Chronic.time_class.local(@now.year, @now.month, @now.day)
 
-      yesterday_midnight = midnight - full_day
-      tomorrow_midnight = midnight + full_day
-
-      offset_fix = midnight.gmt_offset - tomorrow_midnight.gmt_offset
-      tomorrow_midnight += offset_fix
-
-      catch :done do
-        if pointer == :future
-          if @type.ambiguous?
-            [midnight + @type + offset_fix, midnight + half_day + @type + offset_fix, tomorrow_midnight + @type].each do |t|
-              (@current_time = t; throw :done) if t >= @now
-            end
-          else
-            [midnight + @type + offset_fix, tomorrow_midnight + @type].each do |t|
-              (@current_time = t; throw :done) if t >= @now
-            end
-          end
-        else # pointer == :past
-          if @type.ambiguous?
-            [midnight + half_day + @type + offset_fix, midnight + @type + offset_fix, yesterday_midnight + @type + half_day].each do |t|
-              (@current_time = t; throw :done) if t <= @now
+    # Return the next past or future Span for the time that this Repeater represents
+    #   pointer - Symbol representing which temporal direction to fetch the next day
+    #             must be either :past or :future
+    def next(pointer)
+      super
+
+      half_day = 60 * 60 * 12
+      full_day = 60 * 60 * 24
+
+      first = false
+
+      unless @current_time
+        first = true
+        midnight = Chronic.time_class.local(@now.year, @now.month, @now.day)
+
+        yesterday_midnight = midnight - full_day
+        tomorrow_midnight = midnight + full_day
+
+        offset_fix = midnight.gmt_offset - tomorrow_midnight.gmt_offset
+        tomorrow_midnight += offset_fix
+
+        catch :done do
+          if pointer == :future
+            if @type.ambiguous?
+              [midnight + @type.time + offset_fix, midnight + half_day + @type.time + offset_fix, tomorrow_midnight + @type.time].each do |t|
+                (@current_time = t; throw :done) if t >= @now
+              end
+            else
+              [midnight + @type.time + offset_fix, tomorrow_midnight + @type.time].each do |t|
+                (@current_time = t; throw :done) if t >= @now
+              end
             end
-          else
-            [midnight + @type + offset_fix, yesterday_midnight + @type].each do |t|
-              (@current_time = t; throw :done) if t <= @now
+          else # pointer == :past
+            if @type.ambiguous?
+              [midnight + half_day + @type.time + offset_fix, midnight + @type.time + offset_fix, yesterday_midnight + @type.time + half_day].each do |t|
+                (@current_time = t; throw :done) if t <= @now
+              end
+            else
+              [midnight + @type.time + offset_fix, yesterday_midnight + @type.time].each do |t|
+                (@current_time = t; throw :done) if t <= @now
+              end
             end
           end
         end
+
+        @current_time || raise("Current time cannot be nil at this point")
       end
 
-      @current_time || raise("Current time cannot be nil at this point")
-    end
+      unless first
+        increment = @type.ambiguous? ? half_day : full_day
+        @current_time += pointer == :future ? increment : -increment
+      end
 
-    unless first
-      increment = @type.ambiguous? ? half_day : full_day
-      @current_time += pointer == :future ? increment : -increment
+      Span.new(@current_time, @current_time + width)
     end
 
-    Chronic::Span.new(@current_time, @current_time + width)
-  end
-
-  def this(context = :future)
-    super
+    def this(context = :future)
+      super
 
-    context = :future if context == :none
+      context = :future if context == :none
 
-    self.next(context)
-  end
+      self.next(context)
+    end
 
-  def width
-    1
-  end
+    def width
+      1
+    end
 
-  def to_s
-    super << '-time-' << @type.to_s
+    def to_s
+      super << '-time-' << @type.to_s
+    end
   end
-end
+end