chronic 0.1.0

data/lib/chronic/repeaters/repeater_minute.rb

@@ -0,0 +1,21 @@
+class Chronic::RepeaterMinute < Chronic::Repeater #:nodoc:
+  MINUTE_SECONDS = 60
+  
+  def this(pointer = :future)
+    minute_begin = Time.local(@now.year, @now.month, @now.day, @now.hour, @now.min)
+    Chronic::Span.new(minute_begin, minute_begin + MINUTE_SECONDS)
+  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

data/lib/chronic/repeaters/repeater_month.rb

@@ -0,0 +1,54 @@
+class Chronic::RepeaterMonth < Chronic::Repeater #:nodoc:
+  MONTH_SECONDS = 2_592_000 # 30 * 24 * 60 * 60
+  YEAR_MONTHS = 12
+  
+  def next(pointer)
+    super
+    
+    if !@current_month_start
+      @current_month_start = offset_by(Time.local(@now.year, @now.month), 1, pointer)
+    else
+      @current_month_start = offset_by(Time.local(@current_month_start.year, @current_month_start.month), 1, pointer)
+    end
+    
+    Chronic::Span.new(@current_month_start, Time.local(@current_month_start.year, @current_month_start.month + 1))
+  end
+  
+  def this(pointer = :future)
+    super
+    
+    case pointer
+    when :future
+      month_start = Time.local(@now.year, @now.month, @now.day + 1)
+      month_end = self.offset_by(Time.local(@now.year, @now.month), 1, :future)
+    when :past
+      month_start = Time.local(@now.year, @now.month)
+      month_end = Time.local(@now.year, @now.month, @now.day)
+    end
+    
+    Chronic::Span.new(month_start, month_end)
+  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
+    
+    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
+    Time.local(new_year, new_month, time.day, time.hour, time.min, time.sec)
+  end
+  
+  def width
+    MONTH_SECONDS
+  end
+end

data/lib/chronic/repeaters/repeater_month_name.rb

@@ -0,0 +1,82 @@
+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.local(@now.year, target_month)
+        else @now.month > target_month
+          @current_month_begin = Time.local(@now.year + 1, target_month)
+        end
+      when :past
+        if @now.month > target_month
+          @current_month_begin = Time.local(@now.year, target_month)
+        else @now.month < target_month
+          @current_month_begin = Time.local(@now.year - 1, target_month)
+        end
+      end
+      @current_month_begin || raise("Current month should be set by now")
+    else
+      case pointer
+      when :future
+        @current_month_begin = Time.local(@current_month_begin.year + 1, @current_month_begin.month)
+      when :past
+        @current_month_begin = Time.local(@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
+      
+    Chronic::Span.new(@current_month_begin, Time.local(next_month_year, next_month_month))
+  end
+  
+  def this(pointer = :future)
+    super
+    
+    self.next(pointer)
+  end
+  
+  def width
+    MONTH_SECONDS
+  end
+  
+  def index
+    symbol_to_number(@type)
+  end
+  
+  def to_s
+    super << '-month-' << @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

@@ -0,0 +1,23 @@
+class Chronic::RepeaterSeason < Chronic::Repeater #:nodoc:
+  SEASON_SECONDS = 7_862_400 # 91 * 24 * 60 * 60
+  
+  def next(pointer)
+    super
+    
+    raise 'Not implemented'
+  end
+  
+  def this(pointer = :future)
+    super
+    
+    raise 'Not implemented'
+  end
+  
+  def width
+    SEASON_SECONDS
+  end
+  
+  def to_s
+    super << '-season'
+  end
+end

data/lib/chronic/repeaters/repeater_season_name.rb

@@ -0,0 +1,24 @@
+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
+  end
+end

data/lib/chronic/repeaters/repeater_second.rb

@@ -0,0 +1,34 @@
+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
+    end
+    
+    Chronic::Span.new(@second_start, @second_start + SECOND_SECONDS)
+  end
+  
+  def this(pointer = :future)
+    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

data/lib/chronic/repeaters/repeater_time.rb

@@ -0,0 +1,106 @@
+class Chronic::RepeaterTime < Chronic::Repeater #:nodoc:
+  class Tick #:nodoc:
+    attr_accessor :time
+    
+    def initialize(time, ambiguous = false)
+      @time = time
+      @ambiguous = ambiguous
+    end
+    
+    def ambiguous?
+      @ambiguous
+    end
+    
+    def *(other)
+      Tick.new(@time * other, @ambiguous)
+    end
+    
+    def to_f
+      @time.to_f
+    end
+    
+    def to_s
+      @time.to_s + (@ambiguous ? '?' : '')
+    end
+  end
+  
+  def initialize(time, options = {})
+    t = time.sub(/\:/, '')
+    @type = 
+    if (1..2) === t.size
+      Tick.new(t.to_i * 60 * 60, true)
+    elsif t.size == 3
+      Tick.new((t[0..0].to_i * 60 * 60) + (t[1..2].to_i * 60), true)
+    elsif t.size == 4
+      ambiguous = time =~ /:/ && t[0..0].to_i != 0 && t[0..1].to_i <= 12
+      Tick.new(t[0..1].to_i * 60 * 60 + t[2..3].to_i * 60, ambiguous)
+    else
+      raise("Time cannot exceed four digits")
+    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 = Time.local(@now.year, @now.month, @now.day)
+      yesterday_midnight = midnight - full_day
+      tomorrow_midnight = midnight + full_day
+
+      catch :done do
+        if pointer == :future
+          if @type.ambiguous?
+            [midnight + @type, midnight + half_day + @type, tomorrow_midnight + @type].each do |t|
+              (@current_time = t; throw :done) if t > @now
+            end
+          else
+            [midnight + @type, 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, midnight + @type, yesterday_midnight + @type * 2].each do |t|
+              (@current_time = t; throw :done) if t < @now
+            end
+          else
+            [midnight + @type, yesterday_midnight + @type].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
+    
+    unless first
+      increment = @type.ambiguous? ? half_day : full_day
+      @current_time += pointer == :future ? increment : -increment
+    end
+    
+    Chronic::Span.new(@current_time, @current_time + width)
+  end
+  
+  def this(context = :future)
+    [:future, :past].include?(context) || raise("First argument 'context' must be one of :past or :future")
+    self.next(context)
+  end
+  
+  def width
+    1
+  end
+  
+  def to_s
+    super << '-time-' << @type.to_s
+  end
+end

data/lib/chronic/repeaters/repeater_week.rb

@@ -0,0 +1,62 @@
+class Chronic::RepeaterWeek < Chronic::Repeater #:nodoc:
+  WEEK_SECONDS = 604800 # (7 * 24 * 60 * 60)
+  
+  def next(pointer)
+    super
+    
+    if !@current_week_start
+      case pointer
+      when :future
+        sunday_repeater = Chronic::RepeaterDayName.new(:sunday)
+        sunday_repeater.start = @now
+        next_sunday_span = sunday_repeater.next(:future)
+        @current_week_start = next_sunday_span.begin
+      when :past
+        sunday_repeater = Chronic::RepeaterDayName.new(:sunday)
+        sunday_repeater.start = (@now + Chronic::RepeaterDay::DAY_SECONDS)
+        sunday_repeater.next(:past)
+        last_sunday_span = sunday_repeater.next(:past)
+        @current_week_start = last_sunday_span.begin
+      end
+    else
+      direction = pointer == :future ? 1 : -1
+      @current_week_start += direction * WEEK_SECONDS
+    end
+    
+    Chronic::Span.new(@current_week_start, @current_week_start + WEEK_SECONDS)
+  end
+  
+  def this(pointer = :future)
+    super
+    
+    case pointer
+    when :future
+      this_week_start = Time.local(@now.year, @now.month, @now.day, @now.hour) + Chronic::RepeaterHour::HOUR_SECONDS
+      sunday_repeater = Chronic::RepeaterDayName.new(:sunday)
+      sunday_repeater.start = @now
+      this_sunday_span = sunday_repeater.this(:future)
+      this_week_end = this_sunday_span.begin
+      Chronic::Span.new(this_week_start, this_week_end)
+    when :past
+      this_week_end = Time.local(@now.year, @now.month, @now.day, @now.hour)
+      sunday_repeater = Chronic::RepeaterDayName.new(:sunday)
+      sunday_repeater.start = @now
+      last_sunday_span = sunday_repeater.next(:past)
+      this_week_start = last_sunday_span.begin
+      Chronic::Span.new(this_week_start, this_week_end)
+    end
+  end
+  
+  def offset(span, amount, pointer)
+    direction = pointer == :future ? 1 : -1
+    span + direction * amount * WEEK_SECONDS
+  end
+  
+  def width
+    WEEK_SECONDS
+  end
+  
+  def to_s
+    super << '-week'
+  end
+end

data/lib/chronic/repeaters/repeater_weekend.rb

@@ -0,0 +1,11 @@
+class Chronic::RepeaterWeekend < Chronic::Repeater #:nodoc:
+  WEEKEND_SECONDS = 172_800 # (2 * 24 * 60 * 60)
+  
+  def width
+    WEEKEND_SECONDS
+  end
+  
+  def to_s
+    super << '-weekend'
+  end
+end

data/lib/chronic/repeaters/repeater_year.rb

@@ -0,0 +1,55 @@
+class Chronic::RepeaterYear < Chronic::Repeater #:nodoc:
+  
+  def next(pointer)
+    super
+    
+    if !@current_year_start
+      case pointer
+      when :future
+        @current_year_start = Time.local(@now.year + 1)
+      when :past
+        @current_year_start = Time.local(@now.year - 1)
+      end
+    else
+      diff = pointer == :future ? 1 : -1
+      @current_year_start = Time.local(@current_year_start.year + diff)
+    end
+    
+    Chronic::Span.new(@current_year_start, Time.local(@current_year_start.year + 1))
+  end
+  
+  def this(pointer = :future)
+    super
+    
+    case pointer
+    when :future
+      this_year_start = Time.local(@now.year, @now.month, @now.day) + Chronic::RepeaterDay::DAY_SECONDS
+      this_year_end = Time.local(@now.year + 1, 1, 1)
+    when :past
+      this_year_start = Time.local(@now.year, 1, 1)
+      this_year_end = Time.local(@now.year, @now.month, @now.day)
+    end
+    
+    Chronic::Span.new(this_year_start, this_year_end)
+  end
+  
+  def offset(span, amount, pointer)
+    direction = pointer == :future ? 1 : -1
+    
+    sb = span.begin
+    new_begin = Time.local(sb.year + (amount * direction), sb.month, sb.day, sb.hour, sb.min, sb.sec)
+    
+    se = span.end
+    new_end = Time.local(se.year + (amount * direction), se.month, se.day, se.hour, se.min, se.sec)
+    
+    Chronic::Span.new(new_begin, new_end)
+  end
+  
+  def width
+    (365 * 24 * 60 * 60)
+  end
+  
+  def to_s
+    super << '-year'
+  end
+end