ice_cube 0.6.14 → 0.7.0

data/lib/ice_cube/validations/daily_interval.rb

@@ -0,0 +1,51 @@
+module IceCube
+
+  module Validations::DailyInterval
+
+    # Add a new interval validation
+    def interval(interval)
+      validations_for(:interval) << Validation.new(interval)
+      clobber_base_validations(:wday, :day)
+      self
+    end
+
+    # A validation for checking to make sure that a time
+    # is inside of a certain DailyInterval
+    class Validation
+
+      attr_reader :interval
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def build_s(builder)
+        builder.base = interval == 1 ? 'Daily' : "Every #{interval} days"
+      end
+
+      def build_hash(builder)
+        builder.validations[:interval] = interval
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'DAILY'
+      end
+
+      def type
+        :day
+      end
+
+      def validate(time, schedule)
+        time_date = Date.new(time.year, time.month, time.day)
+        start_date = Date.new(schedule.start_time.year, schedule.start_time.month, schedule.start_time.day)
+        days = time_date - start_date
+        unless days % interval === 0
+          interval - (days % interval)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/day.rb

@@ -1,41 +1,55 @@
-module IceCube
+require 'date'
 
-  class DayValidation < Validation
+module IceCube
 
-    attr_reader :days
-  
-    def initialize(rule)
-      @days = rule.validations[:day]
-      @rule = rule
-    end
+  module Validations::Day
   
-    def validate(date)
-      return true if !@days || @days.empty?
-      @days.include?(date.wday)
-    end
-  
-    def closest(date)
-      return nil if !@days || @days.empty?
-      # turn days into distances
-      days = @days.map do |d| 
-        d > date.wday ? (d - date.wday) : (7 - date.wday + d)
+    def day(*days)
+      days.each do |day|
+        day = TimeUtil.symbol_to_day(day) if day.is_a?(Symbol)
+        validations_for(:day) << Validation.new(day)
       end
-      days.compact!
-      # go to the closest distance away, the start of that day
-      goal = date + days.min * IceCube::ONE_DAY
-      self.class.adjust(goal, date)
-    end
-  
-    def to_s
-      days_dup = (@days - @rule.validations[:day_of_week].keys if @rule.validations[:day_of_week]) || @days # don't list twice
-      'on ' << self.class.sentence(days_dup.map { |d| Date::DAYNAMES[d] + 's' }) unless days_dup.empty?
+      clobber_base_validations(:wday, :day)
+      self
     end
 
-    def to_ical
-      days_dup = (@days - @rule.validations[:day_of_week].keys if @rule.validations[:day_of_week]) || @days # don't list twice
-      'BYDAY=' << days_dup.map { |d| IceCube::ICAL_DAYS[d] }.join(',') unless days_dup.empty?
+    class Validation
+
+      include Validations::Lock
+
+      attr_reader :day
+      alias :value :day
+
+      def initialize(day)
+        @day = day
+      end
+
+      def build_s(builder)
+        builder.piece(:day) << "#{Date::DAYNAMES[day]}s"
+      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
+
+      def type
+        :wday
+      end
+
+      StringBuilder.register_formatter(:day) do |segments|
+        "on #{StringBuilder.sentence(segments)}"
+      end
+
     end
-  
+
   end
 
 end

data/lib/ice_cube/validations/day_of_month.rb

@@ -1,52 +1,52 @@
 module IceCube
 
-  class DayOfMonthValidation < Validation
+  module Validations::DayOfMonth
 
-    attr_reader :days_of_month
-    
-    def initialize(rule)
-      @days_of_month = rule.validations[:day_of_month]
-    end
-    
-    def validate(date)
-      return true if !@days_of_month || @days_of_month.empty?
-      @days_of_month.include?(date.mday) || @days_of_month.include?(date.mday - TimeUtil.days_in_month(date) - 1)
-    end
-  
-    def closest(date)
-      return nil if !@days_of_month || @days_of_month.empty?
-      #get some variables we need
-      days_in_month = TimeUtil.days_in_month(date)
-      days_left_in_this_month = days_in_month - date.mday
-      next_month, next_year = date.month == 12 ? [1, date.year + 1] : [date.month + 1, date.year] #clean way to wrap over years
-      days_in_next_month = TimeUtil.days_in_month(Time.utc(next_year, next_month, 1))
-      # create a list of distances
-      distances = []
-      @days_of_month.each do |d|
-        if d > 0
-          distances << d - date.mday #today is 1, we want 20 (19)
-          distances << days_left_in_this_month + d #(364 + 20)
-        elsif d < 0
-          distances << (days_in_month + d + 1) - date.mday #today is 30, we want -1
-          distances << (days_in_next_month + d + 1) + days_left_in_this_month #today is 300, we want -70
-        end
+    include Validations::Lock
+
+    def day_of_month(*days)
+      days.each do |day|
+        validations_for(:day_of_month) << Validation.new(day)
       end
-      #return the lowest distance
-      distances = distances.select { |d| d > 0 }
-      return nil if distances.empty?
-      # return the start of the proper day
-      goal = date + distances.min * IceCube::ONE_DAY
-      self.class.adjust(goal, date)
+      clobber_base_validations(:day, :wday)
+      self
     end
-    
-    def to_s
-      'on the ' << self.class.nice_numbers(@days_of_month) << (@days_of_month.size == 1 ? ' day' : ' days') << ' of the month' unless @days_of_month.empty?
-    end
-  
-    def to_ical
-      'BYMONTHDAY=' << @days_of_month.join(',') unless @days_of_month.empty?
+
+    class Validation
+
+      include Validations::Lock
+
+      StringBuilder.register_formatter(:day_of_month) do |entries|
+        str = "on the #{StringBuilder.sentence(entries)} "
+        str << (entries.size == 1 ? 'day of the month' : 'days of the month')
+        str
+      end
+
+      attr_reader :day
+      alias :value :day
+
+      def initialize(day)
+        @day = day
+      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
+
+      def type
+        :day
+      end
+
     end
-    
+
   end
-  
+
 end

data/lib/ice_cube/validations/day_of_week.rb

@@ -1,57 +1,70 @@
 module IceCube
 
-  class DayOfWeekValidation < Validation
+  module Validations::DayOfWeek
 
-    attr_reader :days_of_week
-
-    def initialize(rule)
-      @days_of_week = rule.validations[:day_of_week]
-      @rule = rule
-    end
-  
-    def validate(date)
-      # is it even one of the valid days?
-      return true if !@days_of_week || @days_of_week.empty?
-      return false unless @days_of_week.has_key?(date.wday) #shortcut
-      # does this fall on one of the occurrences?
-      first_occurrence = ((7 - Time.utc(date.year, date.month, 1).wday) + date.wday) % 7 + 1 #day of first occurrence of a wday in a month
-      this_weekday_in_month_count = ((TimeUtil.days_in_month(date) - first_occurrence + 1) / 7.0).ceil #how many of these in the month
-      nth_occurrence_of_weekday = (date.mday - first_occurrence) / 7 + 1 #what occurrence of the weekday is +date+
-      @days_of_week[date.wday].include?(nth_occurrence_of_weekday) || @days_of_week[date.wday].include?(nth_occurrence_of_weekday - this_weekday_in_month_count - 1)
-    end
-  
-
-    # note - temporary implementation
-    # instead - once we know what weekday starts the month, we should be able to figure out
-    # the rest with basic math
-    def closest(date)
-      return nil if !@days_of_week || @days_of_week.empty?
-      goal = date
-      while (next_date = goal + IceCube::ONE_DAY)
-        # DST hack.  If our day starts at midnight, when DST ends it will be pushed to 11 PM on the previous day.
-        check_date = next_date.day == goal.day ? next_date + IceCube::ONE_HOUR : next_date
-        return self.class.adjust(next_date, date) if validate(check_date)
-        goal = next_date
+    def day_of_week(dows)
+      dows.each do |day, occs|
+        occs.each do |occ|
+          day = TimeUtil.symbol_to_day(day) if day.is_a?(Symbol)
+          validations_for(:day_of_week) << Validation.new(day, occ)
+        end
       end
+      clobber_base_validations :day, :wday
+      self
     end
 
-    def to_s
-      representation = ''
-      representation << 'on the '
-      representation << @days_of_week.map do |day, occ| 
-        self.class.nice_numbers(occ) << ' ' << Date::DAYNAMES[day] << (occ.size != 1 ? 's' : '') unless @days_of_week.empty?
-      end.join(' when it is the ')
-      representation
-    end
-  
-    def to_ical
-      representation = 'BYDAY='
-      representation << @days_of_week.map do |day, occ|
-        occ.map { |o| o.to_s + IceCube::ICAL_DAYS[day] }.join(',')
-      end.join(',')
-      representation
+    class Validation
+
+      attr_reader :day, :occ
+
+      StringBuilder.register_formatter(:day_of_week) do |segments|
+        'on the ' + segments.join(' when it is the ')
+      end
+
+      def type
+        :day
+      end
+
+      def build_s(builder)
+        builder.piece(:day_of_week) << "#{StringBuilder.nice_number(occ)} #{Date::DAYNAMES[day]}"
+      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
+
+      def build_hash(builder)
+        builder.validations[:day_of_week] ||= {}
+        arr = (builder.validations[:day_of_week][day] ||= [])
+        arr << occ
+      end
+
+      def initialize(day, occ)
+        @day = day
+        @occ = occ
+      end
+
+      def validate(time, schedule)
+        # count the days to the weekday
+        sum = day >= time.wday ? day - time.wday : 7 - time.wday + day
+        wrapper = TimeUtil::TimeWrapper.new(time)
+        wrapper.add :day, sum
+        # and then count the week until a viable occ
+        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 if which_occ == this_occ
+          sum += 7
+          wrapper.add :day, 7 # one week
+        end
+        sum
+      end
+
     end
 
   end
-  
+
 end

data/lib/ice_cube/validations/day_of_year.rb

@@ -1,51 +1,55 @@
 module IceCube
-  
-  class DayOfYearValidation < Validation
 
-    attr_reader :days_of_year
-    
-    def initialize(rule)
-      @days_of_year = rule.validations[:day_of_year]
-    end
-  
-    def validate(date)
-      return true if !@days_of_year || @days_of_year.empty?
-      @days_of_year.include?(date.yday) || @days_of_year.include?(date.yday - TimeUtil.days_in_year(date) - 1)
-    end
-  
-    def closest(date)
-      return nil if !@days_of_year || @days_of_year.empty?
-      #get some variables we need
-      days_in_year = TimeUtil.days_in_year(date)
-      days_left_in_this_year = days_in_year - date.yday
-      days_in_next_year = TimeUtil.days_in_year(Time.utc(date.year + 1, 1, 1))
-      # create a list of distances
-      distances = []
-      @days_of_year.each do |d|
-        if d > 0
-          distances << d - date.yday #today is 1, we want 20 (19)
-          distances << days_left_in_this_year + d #(364 + 20)
-        elsif d < 0
-          distances << (days_in_year + d + 1) - date.yday #today is 300, we want -1
-          distances << (days_in_next_year + d + 1) + days_left_in_this_year #today is 300, we want -70
-        end
-      end
-      #return the lowest distance
-      distances = distances.select { |d| d > 0 }
-      return nil if distances.empty?
-      # return the start of the proper day
-      goal = date + distances.min * IceCube::ONE_DAY
-      self.class.adjust(goal, date)
-    end
-  
-    def to_s
-      'on the ' << self.class.nice_numbers(@days_of_year) << (@days_of_year.size == 1 ? ' day' : ' days') << ' of the year' unless @days_of_year.empty?
+  module Validations::DayOfYear
+
+    def day_of_year(*days)
+      days.each do |day|
+        validations_for(:day_of_year) << Validation.new(day)
+      end
+      clobber_base_validations(:month, :day, :wday)
+      self
     end
-  
-    def to_ical
-      'BYYEARDAY=' << @days_of_year.join(',') unless @days_of_year.empty?
+
+    class Validation
+
+      attr_reader :day
+
+      StringBuilder.register_formatter(:day_of_year) do |entries|
+        str = "on the #{StringBuilder.sentence(entries)} "
+        str << (entries.size == 1 ? 'day of the year' : 'days of the year')
+        str
+      end
+
+      def initialize(day)
+        @day = day
+      end
+
+      def type
+        :day
+      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
+
+      def validate(time, schedule)
+        days_in_year = TimeUtil.days_in_year(time)
+        the_day = day < 0 ? day + days_in_year : day
+        # compute the diff
+        diff = the_day - time.yday
+        diff >= 0 ? diff : diff + days_in_year
+      end
+
     end
-  
+
   end
 
 end