ice_cube_conrad 0.8.0

data/lib/ice_cube/validations/minutely_interval.rb

@@ -0,0 +1,57 @@
+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'
+        unless interval == 1
+          builder['INTERVAL'] << interval
+        end
+      end
+
+      def build_hash(builder)
+        builder[:interval] = interval
+      end
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def validate(time, schedule)
+        raise ZeroInterval if interval == 0
+        start_time = schedule.start_time
+        sec = (time.to_i - time.to_i % ONE_MINUTE) -
+          (start_time.to_i - start_time.to_i % ONE_MINUTE)
+        minutes = sec / ONE_MINUTE
+        unless minutes % interval == 0
+          interval - (minutes % interval)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/month_of_year.rb

@@ -0,0 +1,49 @@
+module IceCube
+
+  module Validations::MonthOfYear
+
+    def month_of_year(*months)
+      months.each do |month|
+        month = TimeUtil.symbol_to_month(month.to_sym) if month.is_a?(Symbol) or month.is_a?(String)
+        validations_for(:month_of_year) << Validation.new(month)
+      end
+      clobber_base_validations :month
+      self
+    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
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/monthly_interval.rb

@@ -0,0 +1,51 @@
+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'
+        unless interval == 1
+          builder['INTERVAL'] << interval
+        end
+      end
+
+      def build_hash(builder)
+        builder[:interval] = interval
+      end
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def validate(time, schedule)
+        raise ZeroInterval if interval == 0
+        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

data/lib/ice_cube/validations/second_of_minute.rb

@@ -0,0 +1,49 @@
+module IceCube
+
+  module Validations::SecondOfMinute
+
+    def second_of_minute(*seconds)
+      seconds.each do |second|
+        validations_for(:second_of_minute) << Validation.new(second)
+      end
+      clobber_base_validations :sec
+      self
+    end
+
+    class Validation
+
+      include Validations::Lock
+
+      StringBuilder.register_formatter(:second_of_minute) do |segments|
+        str = "on the #{StringBuilder.sentence(segments)} "
+        str << (segments.size == 1 ? 'second of the minute' : 'seconds of the minute')
+      end
+
+      attr_reader :second
+      alias :value :second
+
+      def initialize(second)
+        @second = second
+      end
+
+      def type
+        :sec
+      end
+
+      def build_s(builder)
+        builder.piece(:second_of_minute) << StringBuilder.nice_number(second)
+      end
+
+      def build_hash(builder)
+        builder.validations_array(:second_of_minute) << second
+      end
+
+      def build_ical(builder)
+        builder['BYSECOND'] << second
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/secondly_interval.rb

@@ -0,0 +1,54 @@
+module IceCube
+
+  module Validations::SecondlyInterval
+
+    def interval(interval)
+      validations_for(:interval) << Validation.new(interval)
+      clobber_base_validations(:sec)
+      self
+    end
+
+    class Validation
+
+      attr_reader :interval
+
+      def type
+        :sec
+      end
+
+      def dst_adjust?
+        false
+      end
+
+      def build_s(builder)
+        builder.base = interval == 1 ? 'Secondly' : "Every #{interval} seconds"
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'SECONDLY'
+        unless interval == 1
+          builder['INTERVAL'] << interval
+        end
+      end
+
+      def build_hash(builder)
+        builder[:interval] = interval
+      end
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def validate(time, schedule)
+        raise ZeroInterval if interval == 0
+        seconds = time.to_i - schedule.start_time.to_i
+        unless seconds % interval == 0
+          interval - (seconds % interval)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/until.rb

@@ -0,0 +1,51 @@
+module IceCube
+
+  module Validations::Until
+
+    extend ::Deprecated
+
+    # accessor
+    def until_time
+      @until
+    end
+    deprecated_alias :until_date, :until_time
+
+    def until(time)
+      @until = time
+      replace_validations_for(:until, [Validation.new(time)])
+      self
+    end
+
+    class Validation
+
+      attr_reader :time
+
+      def type
+        :dealbreaker
+      end
+
+      def initialize(time)
+        @time = time
+      end
+
+      def build_ical(builder)
+        builder['UNTIL'] << IcalBuilder.ical_utc_format(time)
+      end
+
+      def build_hash(builder)
+        builder[:until] = TimeUtil.serialize_time(time)
+      end
+
+      def build_s(builder)
+        builder.piece(:until) << "until #{time.strftime(TO_S_TIME_FORMAT)}"
+      end
+
+      def validate(t, schedule)
+        raise UntilExceeded if t > time 
+      end
+
+    end
+      
+  end
+
+end

data/lib/ice_cube/validations/weekly_interval.rb

@@ -0,0 +1,60 @@
+require 'date'
+
+module IceCube
+
+  module Validations::WeeklyInterval
+
+    def interval(interval, week_start = :sunday)
+      validations_for(:interval) << Validation.new(interval, week_start)
+      clobber_base_validations(:day)
+      self
+    end
+
+    class Validation
+
+      attr_reader :interval, :week_start
+
+      def type
+        :day
+      end
+
+      def build_s(builder)
+        builder.base = interval == 1 ? 'Weekly' : "Every #{interval} weeks"
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'WEEKLY'
+        unless interval == 1
+          builder['INTERVAL'] << interval
+          builder['WKST'] << TimeUtil.week_start(week_start)
+        end
+      end
+
+      def build_hash(builder)
+        builder[:interval] = interval
+      end
+
+      def initialize(interval, week_start)
+        @interval = interval
+        @week_start = week_start
+      end
+
+      def validate(time, schedule)
+        raise ZeroInterval if interval == 0
+        date = Date.new(time.year, time.month, time.day)
+        st = schedule.start_time
+        start_date = Date.new(st.year, st.month, st.day)
+        weeks = (
+          (date - TimeUtil.normalize_weekday(date.wday, week_start)) - 
+          (start_date - TimeUtil.normalize_weekday(start_date.wday, week_start))
+        ) / 7
+        unless weeks % interval == 0
+          (interval - (weeks % interval)) * 7
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/yearly_interval.rb

@@ -0,0 +1,49 @@
+module IceCube
+
+  module Validations::YearlyInterval
+
+    def interval(interval = 1)
+      validations_for(:interval) << Validation.new(interval)
+      clobber_base_validations(:year)
+    end
+
+    class Validation
+
+      attr_reader :interval
+
+      def type
+        :year
+      end
+
+      def build_s(builder)
+        builder.base = interval == 1 ? 'Yearly' : "Every #{interval} years"
+      end
+
+      def build_hash(builder)
+        builder[:interval] = interval
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'YEARLY'
+        unless interval == 1
+          builder['INTERVAL'] << interval
+        end
+      end
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def validate(time, schedule)
+        raise ZeroInterval if interval == 0
+        years_to_start = time.year - schedule.start_time.year
+        unless years_to_start % interval == 0
+          interval - (years_to_start % interval)
+        end
+      end
+
+    end
+
+  end
+
+end