ice_cube_conrad 0.8.0

data/lib/ice_cube/validations/day.rb

@@ -0,0 +1,65 @@
+require 'date'
+
+module IceCube
+
+  module Validations::Day
+  
+    def day(*days)
+      days.each do |day|
+        day = TimeUtil.symbol_to_day(day.to_sym) if day.is_a?(Symbol) or day.is_a?(String)
+        validations_for(:day) << Validation.new(day)
+      end
+      clobber_base_validations(:wday, :day)
+      self
+    end
+
+    class Validation
+
+      include Validations::Lock
+
+      attr_reader :day
+      alias :value :day
+
+      def initialize(day)
+        @day = day
+      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
+
+      def type
+        :wday
+      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]
+          'on Weekends'
+        elsif validation_days == (1..5).to_a
+          'on Weekdays'
+        else
+          segments = validation_days.map { |d| "#{Date::DAYNAMES[d]}s" }
+          "on #{StringBuilder.sentence(segments)}"
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/day_of_month.rb

@@ -0,0 +1,52 @@
+module IceCube
+
+  module Validations::DayOfMonth
+
+    include Validations::Lock
+
+    def day_of_month(*days)
+      days.each do |day|
+        validations_for(:day_of_month) << Validation.new(day)
+      end
+      clobber_base_validations(:day, :wday)
+      self
+    end
+
+    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

@@ -0,0 +1,70 @@
+module IceCube
+
+  module Validations::DayOfWeek
+
+    def day_of_week(dows)
+      dows.each do |day, occs|
+        occs.each do |occ|
+          day = TimeUtil.symbol_to_day(day.to_sym) if day.is_a?(Symbol) or day.is_a?(String)
+          validations_for(:day_of_week) << Validation.new(day, occ)
+        end
+      end
+      clobber_base_validations :day, :wday
+      self
+    end
+
+    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

@@ -0,0 +1,55 @@
+module IceCube
+
+  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
+
+    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

data/lib/ice_cube/validations/hour_of_day.rb

@@ -0,0 +1,52 @@
+module IceCube
+
+  module Validations::HourOfDay
+
+    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
+      clobber_base_validations(:hour)
+      self
+    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
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/hourly_interval.rb

@@ -0,0 +1,57 @@
+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[:interval] = interval
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'HOURLY'
+        unless interval == 1
+          builder['INTERVAL'] << interval
+        end
+      end
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def dst_adjust?
+        false
+      end
+
+      def validate(time, schedule)
+        raise ZeroInterval if interval == 0
+        start_time = schedule.start_time
+        sec = (time.to_i - time.to_i % ONE_HOUR) - 
+          (start_time.to_i - start_time.to_i % ONE_HOUR)
+        hours = sec / 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

@@ -0,0 +1,51 @@
+module IceCube
+
+  module Validations::MinuteOfHour
+
+    include Validations::Lock
+
+    def minute_of_hour(*minutes)
+      minutes.each do |minute|
+        validations_for(:minute_of_hour) << Validation.new(minute)
+      end
+      clobber_base_validations(:min)
+      self
+    end
+
+    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