ice_cube_chosko 0.1.0

data/lib/ice_cube/validations/hour_of_day.rb

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

data/lib/ice_cube/validations/hourly_interval.rb

@@ -0,0 +1,54 @@
+module IceCube
+
+  module Validations::HourlyInterval
+
+    def interval(interval)
+      @interval = normalized_interval(interval)
+      replace_validations_for(:interval, [Validation.new(@interval)])
+      clobber_base_validations(:hour)
+      self
+    end
+
+    class Validation
+
+      attr_reader :interval
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def type
+        :hour
+      end
+
+      def dst_adjust?
+        false
+      end
+
+      def validate(step_time, schedule)
+        t0, t1 = schedule.start_time.to_i, step_time.to_i
+        sec = (t1 - t1 % ONE_HOUR) -
+              (t0 - t0 % ONE_HOUR)
+        hours = sec / ONE_HOUR
+        offset = (hours % interval).nonzero?
+        interval - offset if offset
+      end
+
+      def build_s(builder)
+        builder.base = IceCube::I18n.t("ice_cube.each_hour", count: interval)
+      end
+
+      def build_hash(builder)
+        builder[:interval] = interval
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'HOURLY'
+        builder['INTERVAL'] << interval unless interval == 1
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/lock.rb

@@ -0,0 +1,95 @@
+module IceCube
+
+  # This validation mixin 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 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
+  #
+  module Validations::Lock
+
+    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 += INTERVALS[type] while start < 0
+      start
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/minute_of_hour.rb

@@ -0,0 +1,54 @@
+module IceCube
+
+  module Validations::MinuteOfHour
+
+    def minute_of_hour(*minutes)
+      minutes.flatten.each do |minute|
+        unless minute.is_a?(Fixnum)
+          raise ArgumentError, "expecting Fixnum value for minute, got #{minute.inspect}"
+        end
+        validations_for(:minute_of_hour) << Validation.new(minute)
+      end
+      clobber_base_validations(:min)
+      self
+    end
+
+    class Validation < Validations::FixedValue
+
+      attr_reader :minute
+      alias :value :minute
+
+      def initialize(minute)
+        @minute = minute
+      end
+
+      def type
+        :min
+      end
+
+      def dst_adjust?
+        false
+      end
+
+      def build_s(builder)
+        builder.piece(:minute_of_hour) << StringBuilder.nice_number(minute)
+      end
+
+      def build_hash(builder)
+        builder.validations_array(:minute_of_hour) << minute
+      end
+
+      def build_ical(builder)
+        builder['BYMINUTE'] << minute
+      end
+
+      StringBuilder.register_formatter(:minute_of_hour) do |segments|
+        str = StringBuilder.sentence(segments)
+        IceCube::I18n.t('ice_cube.on_minutes_of_hour', count: segments.size, segments: str)
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/minutely_interval.rb

@@ -0,0 +1,54 @@
+module IceCube
+
+  module Validations::MinutelyInterval
+
+    def interval(interval)
+      @interval = normalized_interval(interval)
+      replace_validations_for(:interval, [Validation.new(@interval)])
+      clobber_base_validations(:min)
+      self
+    end
+
+    class Validation
+
+      attr_reader :interval
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def type
+        :min
+      end
+
+      def dst_adjust?
+        false
+      end
+
+      def validate(step_time, schedule)
+        t0, t1 = schedule.start_time.to_i, step_time.to_i
+        sec = (t1 - t1 % ONE_MINUTE) -
+              (t0 - t0 % ONE_MINUTE)
+        minutes = sec / ONE_MINUTE
+        offset = (minutes % interval).nonzero?
+        interval - offset if offset
+      end
+
+      def build_s(builder)
+        builder.base = IceCube::I18n.t('ice_cube.each_minute', count: interval)
+      end
+
+      def build_hash(builder)
+        builder[:interval] = interval
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'MINUTELY'
+        builder['INTERVAL'] << interval unless interval == 1
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/month_of_year.rb

@@ -0,0 +1,54 @@
+module IceCube
+
+  module Validations::MonthOfYear
+
+    def month_of_year(*months)
+      months.flatten.each do |month|
+        unless month.is_a?(Fixnum) || month.is_a?(Symbol)
+          raise ArgumentError, "expecting Fixnum or Symbol value for month, got #{month.inspect}"
+        end
+        month = TimeUtil.sym_to_month(month)
+        validations_for(:month_of_year) << Validation.new(month)
+      end
+      clobber_base_validations :month
+      self
+    end
+
+    class Validation < Validations::FixedValue
+
+      attr_reader :month
+      alias :value :month
+
+      def initialize(month)
+        @month = month
+      end
+
+      def type
+        :month
+      end
+
+      def dst_adjust?
+        true
+      end
+
+      def build_s(builder)
+        builder.piece(:month_of_year) << IceCube::I18n.t("ice_cube.date.month_names")[month]
+      end
+
+      def build_hash(builder)
+        builder.validations_array(:month_of_year) << month
+      end
+
+      def build_ical(builder)
+        builder['BYMONTH'] << month
+      end
+
+      StringBuilder.register_formatter(:month_of_year) do |segments|
+        IceCube::I18n.t("ice_cube.in", target: StringBuilder.sentence(segments))
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/monthly_interval.rb

@@ -0,0 +1,53 @@
+module IceCube
+
+  module Validations::MonthlyInterval
+
+    def interval(interval)
+      @interval = normalized_interval(interval)
+      replace_validations_for(:interval, [Validation.new(@interval)])
+      clobber_base_validations(:month)
+      self
+    end
+
+    class Validation
+
+      attr_reader :interval
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def type
+        :month
+      end
+
+      def dst_adjust?
+        true
+      end
+
+      def validate(step_time, schedule)
+        t0, t1 = schedule.start_time, step_time
+        months = (t1.month - t0.month) +
+                 (t1.year - t0.year) * 12
+        offset = (months % interval).nonzero?
+        interval - offset if offset
+      end
+
+      def build_s(builder)
+        builder.base = IceCube::I18n.t('ice_cube.each_month', count: interval)
+      end
+
+      def build_hash(builder)
+        builder[:interval] = interval
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'MONTHLY'
+        builder['INTERVAL'] << interval unless interval == 1
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/schedule_lock.rb

@@ -0,0 +1,46 @@
+module IceCube
+
+  module Validations::ScheduleLock
+
+    # Lock the given time units to the units from schedule's +start_time+
+    # These locks are all clobberable by other rules of the same #type
+    # using +clobber_base_validation+
+    #
+    def schedule_lock(*types)
+      types.each do |type|
+        validations_for(:"base_#{type}") << Validation.new(type)
+      end
+    end
+
+    class Validation < Validations::FixedValue
+
+      attr_reader :type, :value
+
+      def initialize(type)
+        @type = type
+      end
+
+      def dst_adjust?
+        case @type
+        when :sec, :min then false
+        else true
+        end
+      end
+
+      # no -op
+      def build_s(builder)
+      end
+
+      # no -op
+      def build_hash(builder)
+      end
+
+      # no -op
+      def build_ical(builder)
+      end
+
+    end
+
+  end
+
+end