gitlab-chronic 0.10.3

data/lib/chronic/repeaters/repeater_season.rb

@@ -0,0 +1,111 @@
+module Chronic
+  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, width = nil, options = {})
+      super
+      @next_season_start = nil
+      @next_season_end = nil
+    end
+
+    def next(pointer)
+      super
+
+      direction = pointer == :future ? 1 : -1
+      next_season = Season.find_next_season(find_current_season(MiniDate.from_time(@now)), direction)
+
+      find_next_season_span(direction, next_season)
+    end
+
+    def this(pointer = :future)
+      super
+
+      direction = pointer == :future ? 1 : -1
+
+      today = Chronic.construct(@now.year, @now.month, @now.day)
+      this_ssn = find_current_season(MiniDate.from_time(@now))
+      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)
+      unless @next_season_start || @next_season_end
+        @next_season_start = Chronic.construct(@now.year, @now.month, @now.day)
+        @next_season_end = Chronic.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 = Chronic.construct(@now.year, @now.month, @now.day)
+      seconds = 0
+
+      until MiniDate.from_time(start + direction * seconds).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(
+        Chronic.construct(start.year, start.month, start.day),
+        Chronic.construct(finish.year, finish.month, finish.day)
+      )
+    end
+  end
+end

data/lib/chronic/repeaters/repeater_season_name.rb

@@ -0,0 +1,43 @@
+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)
+      direction = pointer == :future ? 1 : -1
+
+      today = Chronic.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(MiniDate.from_time(@now))
+      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

@@ -0,0 +1,43 @@
+module Chronic
+  class RepeaterSecond < Repeater #:nodoc:
+    SECOND_SECONDS = 1 # haha, awesome
+
+    def initialize(type, width = nil, options = {})
+      super
+      @second_start = nil
+    end
+
+    def next(pointer = :future)
+      super
+
+      direction = pointer == :future ? 1 : -1
+
+      unless @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
+  end
+end

data/lib/chronic/repeaters/repeater_time.rb

@@ -0,0 +1,159 @@
+module Chronic
+  class RepeaterTime < 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, width = nil, options = {})
+      @current_time = nil
+      @options = options
+      time_parts = time.split(':')
+      raise ArgumentError, "Time cannot have more than 4 groups of ':'" if time_parts.count > 4
+
+      if time_parts.first.length > 2 and time_parts.count == 1
+        if time_parts.first.length > 4
+          second_index = time_parts.first.length - 2
+          time_parts.insert(1, time_parts.first[second_index..time_parts.first.length])
+          time_parts[0] = time_parts.first[0..second_index - 1]
+        end
+        minute_index = time_parts.first.length - 2
+        time_parts.insert(1, time_parts.first[minute_index..time_parts.first.length])
+        time_parts[0] = time_parts.first[0..minute_index - 1]
+      end
+
+      ambiguous = false
+      hours = time_parts.first.to_i
+
+      if @options[:hours24].nil? or (not @options[:hours24].nil? and @options[:hours24] != true)
+          ambiguous = true if (time_parts.first.length == 1 and hours > 0) or (hours >= 10 and hours <= 12) or (@options[:hours24] == false and hours > 0)
+          hours = 0 if hours == 12 and ambiguous
+      end
+
+      hours *= 60 * 60
+      minutes = 0
+      seconds = 0
+      subseconds = 0
+
+      minutes = time_parts[1].to_i * 60 if time_parts.count > 1
+      seconds = time_parts[2].to_i if time_parts.count > 2
+      subseconds = time_parts[3].to_f / (10 ** time_parts[3].length) if time_parts.count > 3
+
+      @type = Tick.new(hours + minutes + seconds + subseconds, ambiguous)
+    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
+
+        catch :done do
+          if pointer == :future
+            if @type.ambiguous?
+              [midnight, midnight + half_day, tomorrow_midnight].each do |base_time|
+                t = adjust_daylight_savings_offset(midnight, base_time + @type.time)
+                (@current_time = t; throw :done) if t >= @now
+              end
+            else
+              [midnight, tomorrow_midnight].each do |base_time|
+                t = adjust_daylight_savings_offset(midnight, base_time + @type.time)
+                (@current_time = t; throw :done) if t >= @now
+              end
+            end
+          else # pointer == :past
+            if @type.ambiguous?
+              [midnight + half_day, midnight, yesterday_midnight + half_day].each do |base_time|
+                t = adjust_daylight_savings_offset(midnight, base_time + @type.time)
+                (@current_time = t; throw :done) if t <= @now
+              end
+            else
+              [midnight, yesterday_midnight].each do |base_time|
+                t = adjust_daylight_savings_offset(midnight, base_time + @type.time)
+                (@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
+
+      Span.new(@current_time, @current_time + width)
+    end
+
+    # Every time a time crosses a Daylight Savings interval we must adjust the
+    # current time by that amount. For example, if we take midnight of Daylight
+    # Savings and only add an hour, the offset does not change:
+    #
+    # Time.parse('2008-03-09 00:00')
+    # => 2008-03-09 00:00:00 -0800
+    # Time.parse('2008-03-09 00:00') + (60 * 60)
+    # => 2008-03-09 01:00:00 -0800
+    #
+    # However, if we add 2 hours, we notice the time advances to 03:00 instead of 02:00:
+    #
+    # Time.parse('2008-03-09 00:00') + (60 * 60 * 2)
+    # => 2008-03-09 03:00:00 -0700
+    #
+    # Since we gained an hour and we actually want 02:00, we subtract an hour.
+    def adjust_daylight_savings_offset(base_time, current_time)
+      offset_fix = base_time.gmt_offset - current_time.gmt_offset
+      current_time + offset_fix
+    end
+
+    def this(context = :future)
+      super
+
+      context = :future if context == :none
+
+      self.next(context)
+    end
+
+    def width
+      1
+    end
+
+    def to_s
+      super << '-time-' << @type.to_s
+    end
+  end
+end

data/lib/chronic/repeaters/repeater_week.rb

@@ -0,0 +1,76 @@
+module Chronic
+  class RepeaterWeek < Repeater #:nodoc:
+    WEEK_SECONDS = 604800 # (7 * 24 * 60 * 60)
+
+    def initialize(type, width = nil, options = {})
+      super
+      @repeater_day_name = options[:week_start] || :sunday
+      @current_week_start = nil
+    end
+
+    def next(pointer)
+      super
+
+      unless @current_week_start
+        case pointer
+        when :future
+          first_week_day_repeater = RepeaterDayName.new(@repeater_day_name)
+          first_week_day_repeater.start = @now
+          next_span = first_week_day_repeater.next(:future)
+          @current_week_start = next_span.begin
+        when :past
+          first_week_day_repeater = RepeaterDayName.new(@repeater_day_name)
+          first_week_day_repeater.start = (@now + RepeaterDay::DAY_SECONDS)
+          first_week_day_repeater.next(:past)
+          last_span = first_week_day_repeater.next(:past)
+          @current_week_start = last_span.begin
+        end
+      else
+        direction = pointer == :future ? 1 : -1
+        @current_week_start += direction * WEEK_SECONDS
+      end
+
+      Span.new(@current_week_start, @current_week_start + WEEK_SECONDS)
+    end
+
+    def this(pointer = :future)
+      super
+
+      case pointer
+      when :future
+        this_week_start = Chronic.time_class.local(@now.year, @now.month, @now.day, @now.hour) + RepeaterHour::HOUR_SECONDS
+        first_week_day_repeater = RepeaterDayName.new(@repeater_day_name)
+        first_week_day_repeater.start = @now
+        this_span = first_week_day_repeater.this(:future)
+        this_week_end = this_span.begin
+        Span.new(this_week_start, this_week_end)
+      when :past
+        this_week_end = Chronic.time_class.local(@now.year, @now.month, @now.day, @now.hour)
+        first_week_day_repeater = RepeaterDayName.new(@repeater_day_name)
+        first_week_day_repeater.start = @now
+        last_span = first_week_day_repeater.next(:past)
+        this_week_start = last_span.begin
+        Span.new(this_week_start, this_week_end)
+      when :none
+        first_week_day_repeater = RepeaterDayName.new(@repeater_day_name)
+        first_week_day_repeater.start = @now
+        last_span = first_week_day_repeater.next(:past)
+        this_week_start = last_span.begin
+        Span.new(this_week_start, this_week_start + WEEK_SECONDS)
+      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
+end

data/lib/chronic/repeaters/repeater_weekday.rb

@@ -0,0 +1,86 @@
+module Chronic
+  class RepeaterWeekday < Repeater #:nodoc:
+    DAY_SECONDS = 86400 # (24 * 60 * 60)
+    DAYS = {
+      :sunday => 0,
+      :monday => 1,
+      :tuesday => 2,
+      :wednesday => 3,
+      :thursday => 4,
+      :friday => 5,
+      :saturday => 6
+    }
+
+    def initialize(type, width = nil, options = {})
+      super
+      @current_weekday_start = nil
+    end
+
+    def next(pointer)
+      super
+
+      direction = pointer == :future ? 1 : -1
+
+      unless @current_weekday_start
+        @current_weekday_start = Chronic.construct(@now.year, @now.month, @now.day)
+        @current_weekday_start += direction * DAY_SECONDS
+
+        until is_weekday?(@current_weekday_start.wday)
+          @current_weekday_start += direction * DAY_SECONDS
+        end
+      else
+        loop do
+          @current_weekday_start += direction * DAY_SECONDS
+          break if is_weekday?(@current_weekday_start.wday)
+        end
+      end
+
+      Span.new(@current_weekday_start, @current_weekday_start + DAY_SECONDS)
+    end
+
+    def this(pointer = :future)
+      super
+
+      case pointer
+      when :past
+        self.next(:past)
+      when :future, :none
+        self.next(:future)
+      end
+    end
+
+    def offset(span, amount, pointer)
+      direction = pointer == :future ? 1 : -1
+
+      num_weekdays_passed = 0; offset = 0
+      until num_weekdays_passed == amount
+        offset += direction * DAY_SECONDS
+        num_weekdays_passed += 1 if is_weekday?((span.begin+offset).wday)
+      end
+
+      span + offset
+    end
+
+    def width
+      DAY_SECONDS
+    end
+
+    def to_s
+      super << '-weekday'
+    end
+
+    private
+
+    def is_weekend?(day)
+      day == symbol_to_number(:saturday) || day == symbol_to_number(:sunday)
+    end
+
+    def is_weekday?(day)
+      !is_weekend?(day)
+    end
+
+    def symbol_to_number(sym)
+      DAYS[sym] || raise('Invalid symbol specified')
+    end
+  end
+end