ice_cube_chosko 0.1.0

data/lib/ice_cube/validations/count.rb

@@ -0,0 +1,61 @@
+module IceCube
+
+  module Validations::Count
+
+    # Value reader for limit
+    def occurrence_count
+      @count
+    end
+
+    def count(max)
+      unless max.nil? || max.is_a?(Fixnum)
+        raise ArgumentError, "Expecting Fixnum or nil value for count, got #{max.inspect}"
+      end
+      @count = max
+      replace_validations_for(:count, max && [Validation.new(max, self)])
+      self
+    end
+
+    class Validation
+
+      attr_reader :rule, :count
+
+      def initialize(count, rule)
+        @count = count
+        @rule = rule
+      end
+
+      def type
+        :limit
+      end
+
+      def dst_adjust?
+        false
+      end
+
+      def validate(time, schedule)
+        raise CountExceeded if rule.uses && rule.uses >= count
+      end
+
+      def build_s(builder)
+        builder.piece(:count) << count
+      end
+
+      def build_hash(builder)
+        builder[:count] = count
+      end
+
+      def build_ical(builder)
+        builder['COUNT'] << count
+      end
+
+      StringBuilder.register_formatter(:count) do |segments|
+        count = segments.first
+        IceCube::I18n.t('ice_cube.times', count: count)
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/daily_interval.rb

@@ -0,0 +1,54 @@
+module IceCube
+
+  module Validations::DailyInterval
+
+    # Add a new interval validation
+    def interval(interval)
+      @interval = normalized_interval(interval)
+      replace_validations_for(:interval, [Validation.new(@interval)])
+      clobber_base_validations(:wday, :day)
+      self
+    end
+
+    class Validation
+
+      attr_reader :interval
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def type
+        :day
+      end
+
+      def dst_adjust?
+        true
+      end
+
+      def validate(step_time, schedule)
+        t0, t1 = schedule.start_time, step_time
+        days = Date.new(t1.year, t1.month, t1.day) -
+               Date.new(t0.year, t0.month, t0.day)
+        offset = (days % interval).nonzero?
+        interval - offset if offset
+      end
+
+      def build_s(builder)
+        builder.base = IceCube::I18n.t('ice_cube.each_day', count: interval)
+      end
+
+      def build_hash(builder)
+        builder[:interval] = interval
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'DAILY'
+        builder['INTERVAL'] << interval unless interval == 1
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/day.rb

@@ -0,0 +1,71 @@
+require 'date'
+
+module IceCube
+
+  module Validations::Day
+
+    def day(*days)
+      days.flatten.each do |day|
+        unless day.is_a?(Fixnum) || day.is_a?(Symbol)
+          raise ArgumentError, "expecting Fixnum or Symbol value for day, got #{day.inspect}"
+        end
+        day = TimeUtil.sym_to_wday(day)
+        validations_for(:day) << Validation.new(day)
+      end
+      clobber_base_validations(:wday, :day)
+      self
+    end
+
+    class Validation < Validations::FixedValue
+
+      attr_reader :day
+      alias :value :day
+
+      def initialize(day)
+        @day = day
+      end
+
+      def type
+        :wday
+      end
+
+      def dst_adjust?
+        true
+      end
+
+      def build_s(builder)
+        builder.piece(:day) << day
+      end
+
+      def build_hash(builder)
+        builder.validations_array(:day) << day
+      end
+
+      def build_ical(builder)
+        ical_day = IcalBuilder.fixnum_to_ical_day(day)
+        # Only add if there aren't others from day_of_week that override
+        if builder['BYDAY'].none? { |b| b.end_with?(ical_day) }
+          builder['BYDAY'] << ical_day
+        end
+      end
+
+      StringBuilder.register_formatter(:day) do |validation_days|
+        # sort the days
+        validation_days.sort!
+        # pick the right shortening, if applicable
+        if validation_days == [0, 6]
+          IceCube::I18n.t('ice_cube.on_weekends')
+        elsif validation_days == (1..5).to_a
+          IceCube::I18n.t('ice_cube.on_weekdays')
+        else
+          day_names = ->(d){ "#{IceCube::I18n.t("ice_cube.days_on")[d]}" }
+          segments = validation_days.map(&day_names)
+          IceCube::I18n.t('ice_cube.on_days', days: StringBuilder.sentence(segments))
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/day_of_month.rb

@@ -0,0 +1,55 @@
+module IceCube
+
+  module Validations::DayOfMonth
+
+    def day_of_month(*days)
+      days.flatten.each do |day|
+        unless day.is_a?(Fixnum)
+          raise ArgumentError, "expecting Fixnum value for day, got #{day.inspect}"
+        end
+        validations_for(:day_of_month) << Validation.new(day)
+      end
+      clobber_base_validations(:day, :wday)
+      self
+    end
+
+    class Validation < Validations::FixedValue
+
+      attr_reader :day
+      alias :value :day
+
+      def initialize(day)
+        @day = day
+      end
+
+      def type
+        :day
+      end
+
+      def dst_adjust?
+        true
+      end
+
+      def build_s(builder)
+        builder.piece(:day_of_month) << StringBuilder.nice_number(day)
+      end
+
+      def build_hash(builder)
+        builder.validations_array(:day_of_month) << day
+      end
+
+      def build_ical(builder)
+        builder['BYMONTHDAY'] << day
+      end
+
+      StringBuilder.register_formatter(:day_of_month) do |entries|
+        sentence = StringBuilder.sentence(entries)
+        str = IceCube::I18n.t('ice_cube.days_of_month', count: entries.size, segments: sentence)
+        IceCube::I18n.t('ice_cube.on', sentence: str)
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/day_of_week.rb

@@ -0,0 +1,77 @@
+module IceCube
+
+  module Validations::DayOfWeek
+
+    def day_of_week(dows)
+      dows.each do |day, occs|
+        occs.each do |occ|
+          day = TimeUtil.sym_to_wday(day)
+          validations_for(:day_of_week) << Validation.new(day, occ)
+        end
+      end
+      clobber_base_validations :day, :wday
+      self
+    end
+
+    class Validation
+
+      attr_reader :day, :occ
+
+      def initialize(day, occ)
+        @day = day
+        @occ = occ
+      end
+
+      def type
+        :day
+      end
+
+      def dst_adjust?
+        true
+      end
+
+      def validate(step_time, schedule)
+        wday = step_time.wday
+        offset = (day < wday) ? (7 - wday + day) : (day - wday)
+        wrapper = TimeUtil::TimeWrapper.new(step_time)
+        wrapper.add :day, offset
+        loop do
+          which_occ, num_occ = TimeUtil.which_occurrence_in_month(wrapper.to_time, day)
+          this_occ = (occ < 0) ? (num_occ + occ + 1) : (occ)
+          break offset if which_occ == this_occ
+          wrapper.add :day, 7
+          offset += 7
+        end
+      end
+
+      def build_s(builder)
+        builder.piece(:day_of_week) << IceCube::I18n.t(
+          'ice_cube.days_of_week',
+          segments: StringBuilder.nice_number(occ),
+          day: IceCube::I18n.t('ice_cube.date.day_names')[day]
+        )
+      end
+
+      def build_hash(builder)
+        builder.validations[:day_of_week] ||= {}
+        arr = (builder.validations[:day_of_week][day] ||= [])
+        arr << occ
+      end
+
+      def build_ical(builder)
+        ical_day = IcalBuilder.fixnum_to_ical_day(day)
+        # Delete any with this day and no occ first
+        builder['BYDAY'].delete_if { |d| d == ical_day }
+        builder['BYDAY'] << "#{occ}#{ical_day}"
+      end
+
+      StringBuilder.register_formatter(:day_of_week) do |segments|
+        sentence = segments.join(IceCube::I18n.t('ice_cube.array.two_words_connector'))
+        IceCube::I18n.t('ice_cube.on', sentence: sentence)
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/day_of_year.rb

@@ -0,0 +1,61 @@
+module IceCube
+
+  module Validations::DayOfYear
+
+    def day_of_year(*days)
+      days.flatten.each do |day|
+        unless day.is_a?(Fixnum)
+          raise ArgumentError, "expecting Fixnum value for day, got #{day.inspect}"
+        end
+        validations_for(:day_of_year) << Validation.new(day)
+      end
+      clobber_base_validations(:month, :day, :wday)
+      self
+    end
+
+    class Validation
+
+      attr_reader :day
+
+      def initialize(day)
+        @day = day
+      end
+
+      def type
+        :day
+      end
+
+      def dst_adjust?
+        true
+      end
+
+      def validate(step_time, schedule)
+        days_in_year = TimeUtil.days_in_year(step_time)
+        yday = day < 0 ? day + days_in_year : day
+        offset = yday - step_time.yday
+        offset >= 0 ? offset : offset + days_in_year
+      end
+
+      def build_s(builder)
+        builder.piece(:day_of_year) << StringBuilder.nice_number(day)
+      end
+
+      def build_hash(builder)
+        builder.validations_array(:day_of_year) << day
+      end
+
+      def build_ical(builder)
+        builder['BYYEARDAY'] << day
+      end
+
+      StringBuilder.register_formatter(:day_of_year) do |entries|
+        str =  StringBuilder.sentence(entries)
+        sentence = IceCube::I18n.t('ice_cube.days_of_year', count: entries.size, segments: str)
+        IceCube::I18n.t('ice_cube.on', sentence: sentence)
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/fixed_value.rb

@@ -0,0 +1,95 @@
+module IceCube
+
+  # This abstract validation class is used by the various "fixed-time" (e.g.
+  # day, day_of_month, hour_of_day) Validation and ScheduleLock::Validation
+  # modules. It is not a standalone rule validation module like the others.
+  #
+  # Given the including Validation's defined +type+ field, it will lock to the
+  # specified +value+ or else the corresponding time unit from the schedule's
+  # start_time
+  #
+  class Validations::FixedValue
+
+    INTERVALS = {:min => 60, :sec => 60, :hour => 24, :month => 12, :wday => 7}
+
+    def validate(time, schedule)
+      case type
+      when :day  then validate_day_lock(time, schedule)
+      when :hour then validate_hour_lock(time, schedule)
+      else validate_interval_lock(time, schedule)
+      end
+    end
+
+    private
+
+    # Validate if the current time unit matches the same unit from the schedule
+    # start time, returning the difference to the interval
+    #
+    def validate_interval_lock(time, schedule)
+      t0 = starting_unit(schedule.start_time)
+      t1 = time.send(type)
+      t0 >= t1 ? t0 - t1 : INTERVALS[type] - t1 + t0
+    end
+
+    # Lock the hour if explicitly set by hour_of_day, but allow for the nearest
+    # hour during DST start to keep the correct interval.
+    #
+    def validate_hour_lock(time, schedule)
+      h0 = starting_unit(schedule.start_time)
+      h1 = time.hour
+      if h0 >= h1
+        h0 - h1
+      else
+        if dst_offset = TimeUtil.dst_change(time)
+          h0 - h1 + dst_offset
+        else
+          24 - h1 + h0
+        end
+      end
+    end
+
+    # For monthly rules that have no specified day value, the validation relies
+    # on the schedule start time and jumps to include every month even if it
+    # has fewer days than the schedule's start day.
+    #
+    # Negative day values (from month end) also include all months.
+    #
+    # Positive day values are taken literally so months with fewer days will
+    # be skipped.
+    #
+    def validate_day_lock(time, schedule)
+      days_in_month = TimeUtil.days_in_month(time)
+      date = Date.new(time.year, time.month, time.day)
+
+      if value && value < 0
+        start = TimeUtil.day_of_month(value, date)
+        month_overflow = days_in_month - TimeUtil.days_in_next_month(time)
+      elsif value && value > 0
+        start = value
+        month_overflow = 0
+      else
+        start = TimeUtil.day_of_month(schedule.start_time.day, date)
+        month_overflow = 0
+      end
+
+      sleeps = start - date.day
+
+      if value && value > 0
+        until_next_month = days_in_month + sleeps
+      else
+        until_next_month = start < 28 ? days_in_month : TimeUtil.days_to_next_month(date)
+        until_next_month += sleeps - month_overflow
+      end
+
+      sleeps >= 0 ? sleeps : until_next_month
+    end
+
+    def starting_unit(start_time)
+      start = value || start_time.send(type)
+      start = start % INTERVALS[type] if start < 0
+      start
+    end
+
+  end
+
+end