ice_cube 0.6.14 → 0.7.0

data/lib/ice_cube/validations/hour_of_day.rb

@@ -1,40 +1,52 @@
 module IceCube
 
-  class HourOfDayValidation < Validation
+  module Validations::HourOfDay
 
-    attr_reader :hours_of_day
-  
-    def initialize(rule)
-      @hours_of_day = rule.validations[:hour_of_day]
-    end
-  
-    def validate(date)
-      return true if !@hours_of_day || @hours_of_day.empty?
-      @hours_of_day.include?(date.hour)
-    end
-  
-    def closest(date)
-      return nil if !@hours_of_day || @hours_of_day.empty?
-      # turn hours into hour of day
-      # hour >= 24 should fall into the next day
-      hours = @hours_of_day.map do |h|
-        h > date.hour ? h - date.hour : 24 - date.hour + h
+    include Validations::Lock
+
+    # Add hour of day validations
+    def hour_of_day(*hours)
+      hours.each do |hour|
+        validations_for(:hour_of_day) << Validation.new(hour)
       end
-      hours.compact!
-      # go to the closest distance away, the start of that hour
-      closest_hour = hours.min
-      goal = date + IceCube::ONE_HOUR * closest_hour
-      self.class.adjust(goal, date)
+      clobber_base_validations(:hour)
+      self
     end
 
-    def to_s
-      'on the ' << self.class.nice_numbers(@hours_of_day) << (@hours_of_day.size == 1 ? ' hour' : ' hours') << ' of the day' unless @hours_of_day.empty?
-    end
+    class Validation
+
+      include Validations::Lock
+
+      StringBuilder.register_formatter(:hour_of_day) do |segments|
+        str = "on the #{StringBuilder.sentence(segments)} "
+        str << (segments.size == 1 ? 'hour of the day' : 'hours of the day')
+      end
+
+      attr_reader :hour
+      alias :value :hour
+
+      def initialize(hour)
+        @hour = hour
+      end
+
+      def build_s(builder)
+        builder.piece(:hour_of_day) << StringBuilder.nice_number(hour)
+      end
+
+      def type
+        :hour
+      end
+
+      def build_hash(builder)
+        builder.validations_array(:hour_of_day) << hour
+      end
+
+      def build_ical(builder)
+        builder['BYHOUR'] << hour
+      end
 
-    def to_ical
-      'BYHOUR=' << @hours_of_day.join(',') unless @hours_of_day.empty?
     end
-  
+
   end
-  
+
 end

data/lib/ice_cube/validations/hourly_interval.rb

@@ -0,0 +1,50 @@
+module IceCube
+
+  module Validations::HourlyInterval
+
+    def interval(interval)
+      validations_for(:interval) << Validation.new(interval)
+      clobber_base_validations(:hour)
+      self
+    end 
+
+    class Validation
+
+      attr_reader :interval
+
+      def type
+        :hour
+      end
+
+      def build_s(builder)
+        builder.base = interval == 1 ? 'Hourly' : "Every #{interval} hours"
+      end
+
+      def build_hash(builder)
+        builder.validations[:interval] = interval
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'HOURLY'
+      end
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def dst_adjust?
+        false
+      end
+
+      def validate(time, schedule)
+        hours = (time.to_i - schedule.start_time.to_i) / IceCube::ONE_HOUR
+        unless hours % interval == 0
+          interval - (hours % interval)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/lock.rb

@@ -0,0 +1,47 @@
+module IceCube
+
+  # A validation mixin that will lock the +type field to
+  # +value or +schedule.start_time.send(type) if value is nil
+
+  module Validations::Lock
+
+    INTERVALS = { :hour => 24, :min => 60, :sec => 60, :month => 12, :wday => 7 }
+    def validate(time, schedule)
+      return send(:"validate_#{type}_lock", time, schedule) unless INTERVALS[type]
+      start = value || schedule.start_time.send(type)
+      start = INTERVALS[type] + start if start < 0 # handle negative values
+      start >= time.send(type) ? start - time.send(type) : INTERVALS[type] - time.send(type) + start
+    end
+
+    private
+
+    # Needs to be custom since we don't know the days in the month
+    # (meaning, its not a fixed interval)
+    def validate_day_lock(time, schedule)
+      start = value || schedule.start_time.day
+      days_in_this_month = TimeUtil.days_in_month(time)
+      # If this number is positive, then follow our normal procedure
+      if start > 0
+        return start >= time.day ? start - time.day : days_in_this_month - time.day + start
+      end 
+      # If the number is negative, and it resolved against the current month
+      # puts it in the future, just return the difference
+      days_in_this_month = TimeUtil.days_in_month(time)
+      start_one = days_in_this_month + start + 1 
+      if start_one >= time.day
+        return start_one - time.day
+      end
+      # Otherwise, we need to figure out the meaning of the value
+      # in the next month, and then figure out how to get there
+      days_in_next_month = TimeUtil.days_in_next_month(time)
+      start_two = days_in_next_month + start + 1
+      if start_two >= time.day
+        days_in_this_month + start_two - time.day
+      else
+        days_in_next_month + start_two - time.day
+      end
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/minute_of_hour.rb

@@ -1,40 +1,51 @@
 module IceCube
 
-  class MinuteOfHourValidation < Validation
+  module Validations::MinuteOfHour
 
-    attr_reader :minutes_of_hour
-  
-    def initialize(rule)
-      @minutes_of_hour = rule.validations[:minute_of_hour]
-    end
-  
-    def validate(date)
-      return true if !@minutes_of_hour || @minutes_of_hour.empty?
-      @minutes_of_hour.include?(date.min)
-    end
-  
-    def closest(date)
-      return nil if !@minutes_of_hour || @minutes_of_hour.empty?
-      # turn minutes into minutes of hour
-      # minute >= 60 should fall into the next hour
-      minutes = @minutes_of_hour.map do |m|
-        m > date.min ? m - date.min : 60 - date.min + m
+    include Validations::Lock
+
+    def minute_of_hour(*minutes)
+      minutes.each do |minute|
+        validations_for(:minute_of_hour) << Validation.new(minute)
       end
-      minutes.compact!
-      # go to the closest distance away, the beginning of that minute
-      closest_minute = minutes.min
-      goal = date + closest_minute * IceCube::ONE_MINUTE
-      self.class.adjust(goal, date)
-    end
-    
-    def to_s
-      'on the ' << self.class.nice_numbers(@minutes_of_hour) << (@minutes_of_hour.size == 1 ? ' minute' : ' minutes') << ' of the hour' unless @minutes_of_hour.empty?
+      clobber_base_validations(:min)
+      self
     end
 
-    def to_ical
-      'BYMINUTE=' << @minutes_of_hour.join(',') unless @minutes_of_hour.empty?
+    class Validation
+
+      include Validations::Lock
+
+      StringBuilder.register_formatter(:minute_of_hour) do |segments|
+        str = "on the #{StringBuilder.sentence(segments)} "
+        str << (segments.size == 1 ? 'minute of the hour' : 'minutes of the hour')
+      end
+
+      attr_reader :minute
+      alias :value :minute
+
+      def initialize(minute)
+        @minute = minute
+      end
+
+      def build_s(builder)
+        builder.piece(:minute_of_hour) << StringBuilder.nice_number(minute)
+      end
+
+      def type
+        :min
+      end
+
+      def build_hash(builder)
+        builder.validations_array(:minute_of_hour) << minute
+      end
+
+      def build_ical(builder)
+        builder['BYMINUTE'] << minute
+      end
+
     end
-    
+
   end
-  
+
 end

data/lib/ice_cube/validations/minutely_interval.rb

@@ -0,0 +1,50 @@
+module IceCube
+
+  module Validations::MinutelyInterval
+
+    def interval(interval)
+      validations_for(:interval) << Validation.new(interval)
+      clobber_base_validations(:min)
+      self
+    end
+
+    class Validation
+
+      attr_reader :interval
+
+      def type
+        :min
+      end
+
+      def dst_adjust?
+        false
+      end
+
+      def build_s(builder)
+        builder.base = interval == 1 ? 'Minutely' : "Every #{interval} minutes"
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'MINUTELY'
+      end
+
+      def build_hash(builder)
+        builder.validations[:interval] = interval
+      end
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def validate(time, schedule)
+        minutes = (time.to_i - schedule.start_time.to_i) / IceCube::ONE_MINUTE
+        unless minutes % interval == 0
+          interval - (minutes % interval)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/month_of_year.rb

@@ -1,40 +1,49 @@
 module IceCube
 
-  class MonthOfYearValidation < Validation
+  module Validations::MonthOfYear
 
-    attr_reader :months_of_year
-  
-    def initialize(rule)
-      @months_of_year = rule.validations[:month_of_year]
-    end
-  
-    def validate(date)
-      return true if !@months_of_year || @months_of_year.empty?
-      @months_of_year.include?(date.month)
-    end
-  
-    def closest(date)
-      return nil if !@months_of_year || @months_of_year.empty?
-      # turn months into month of year
-      # month > 12 should fall into the next year
-      months = @months_of_year.map do |m|
-        m > date.month ? m - date.month : 12 - date.month + m
+    def month_of_year(*months)
+      months.each do |month|
+        month = TimeUtil.symbol_to_month(month) if month.is_a?(Symbol)
+        validations_for(:month_of_year) << Validation.new(month)
       end
-      months.compact!
-      # go to the closest distance away
-      goal = date
-      months.min.times { goal += TimeUtil.days_in_month(goal) * IceCube::ONE_DAY }
-      self.class.adjust(goal, date)
+      clobber_base_validations :month
+      self
     end
 
-    def to_s
-      'in ' << self.class.sentence(@months_of_year.map { |m| Date::MONTHNAMES[m] }) unless @months_of_year.empty?
-    end
+    class Validation
+
+      include Validations::Lock
+
+      attr_reader :month
+      alias :value :month
+
+      def initialize(month)
+        @month = month
+      end
+
+      def build_s(builder)
+        builder.piece(:month_of_year) << Date::MONTHNAMES[month]
+      end
+
+      def build_hash(builder)
+        builder.validations_array(:month_of_year) << month
+      end
+
+      def build_ical(builder)
+        builder['BYMONTH'] << month
+      end
+
+      def type
+        :month
+      end
+
+      StringBuilder.register_formatter(:month_of_year) do |segments|
+        "in #{StringBuilder.sentence(segments)}"
+      end
 
-    def to_ical
-      'BYMONTH=' << @months_of_year.join(',') unless @months_of_year.empty?
     end
-    
+
   end
-  
+
 end

data/lib/ice_cube/validations/monthly_interval.rb

@@ -0,0 +1,47 @@
+module IceCube
+
+  module Validations::MonthlyInterval
+
+    def interval(interval = 1)
+      validations_for(:interval) << Validation.new(interval)
+      clobber_base_validations(:month)
+      self
+    end
+
+    class Validation
+
+      attr_reader :interval
+
+      def type
+        :month
+      end
+
+      def build_s(builder)
+        builder.base = interval == 1 ? 'Monthly' : "Every #{interval} months"
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'MONTHLY'
+      end
+
+      def build_hash(builder)
+        builder.validations[:interval] = interval
+      end
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def validate(time, schedule)
+        start_time = schedule.start_time
+        months_to_start = (time.month - start_time.month) + (time.year - start_time.year) * 12
+        unless months_to_start % interval == 0
+          interval - (months_to_start % interval)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/schedule_lock.rb

@@ -0,0 +1,41 @@
+module IceCube
+
+  module Validations::ScheduleLock
+
+    # Lock the given times down the schedule's start_time for that position
+    # 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
+
+    # A validation used for locking time into a certain value
+    class Validation
+
+      include Validations::Lock
+
+      attr_reader :type, :value
+
+      def initialize(type)
+        @type = type
+      end
+
+      # no -op
+      def build_s(builder)
+      end
+
+      # no -op
+      def build_ical(builder)
+      end
+
+      # no -op
+      def build_hash(builder)
+      end
+
+    end
+
+  end
+
+end