ice_cube_conrad 0.8.0

data/lib/ice_cube.rb

@@ -0,0 +1,80 @@
+require 'date'
+require 'ice_cube/deprecated'
+
+# Use psych if we can
+begin
+  require 'psych'
+rescue LoadError
+  require 'yaml'
+end
+
+module IceCube
+
+  autoload :VERSION, 'ice_cube/version'
+
+  autoload :TimeUtil, 'ice_cube/time_util'
+
+  autoload :Rule, 'ice_cube/rule'
+  autoload :Schedule, 'ice_cube/schedule'
+
+  autoload :IcalBuilder, 'ice_cube/builders/ical_builder'
+  autoload :HashBuilder, 'ice_cube/builders/hash_builder'
+  autoload :StringBuilder, 'ice_cube/builders/string_builder'
+
+  autoload :CountExceeded, 'ice_cube/errors/count_exceeded'
+  autoload :UntilExceeded, 'ice_cube/errors/until_exceeded'
+  autoload :ZeroInterval, 'ice_cube/errors/zero_interval'
+
+  autoload :ValidatedRule, 'ice_cube/validated_rule'
+  autoload :SingleOccurrenceRule, 'ice_cube/single_occurrence_rule'
+
+  autoload :SecondlyRule, 'ice_cube/rules/secondly_rule'
+  autoload :MinutelyRule, 'ice_cube/rules/minutely_rule'
+  autoload :HourlyRule, 'ice_cube/rules/hourly_rule'
+  autoload :DailyRule, 'ice_cube/rules/daily_rule'
+  autoload :WeeklyRule, 'ice_cube/rules/weekly_rule'
+  autoload :MonthlyRule, 'ice_cube/rules/monthly_rule'
+  autoload :YearlyRule, 'ice_cube/rules/yearly_rule'
+
+  module Validations
+
+    autoload :Lock, 'ice_cube/validations/lock'
+    autoload :ScheduleLock, 'ice_cube/validations/schedule_lock'
+
+    autoload :Count, 'ice_cube/validations/count'
+    autoload :Until, 'ice_cube/validations/until'
+
+    autoload :SecondlyInterval, 'ice_cube/validations/secondly_interval'
+    autoload :MinutelyInterval, 'ice_cube/validations/minutely_interval'
+    autoload :DailyInterval, 'ice_cube/validations/daily_interval'
+    autoload :WeeklyInterval, 'ice_cube/validations/weekly_interval'
+    autoload :MonthlyInterval, 'ice_cube/validations/monthly_interval'
+    autoload :YearlyInterval, 'ice_cube/validations/yearly_interval'
+    autoload :HourlyInterval, 'ice_cube/validations/hourly_interval'
+
+    autoload :HourOfDay, 'ice_cube/validations/hour_of_day'
+    autoload :MonthOfYear, 'ice_cube/validations/month_of_year'
+    autoload :MinuteOfHour, 'ice_cube/validations/minute_of_hour'
+    autoload :SecondOfMinute, 'ice_cube/validations/second_of_minute'
+    autoload :DayOfMonth, 'ice_cube/validations/day_of_month'
+    autoload :DayOfWeek, 'ice_cube/validations/day_of_week'
+    autoload :Day, 'ice_cube/validations/day'
+    autoload :DayOfYear, 'ice_cube/validations/day_of_year'
+
+  end
+
+  # Define some useful constants
+  ONE_SECOND = 1
+  ONE_MINUTE = ONE_SECOND * 60
+  ONE_HOUR =   ONE_MINUTE * 60
+  ONE_DAY =    ONE_HOUR   * 24
+  ONE_WEEK =   ONE_DAY    * 7
+
+  # Formatting
+  TO_S_TIME_FORMAT = '%B %e, %Y'
+
+  def self.use_psych?
+    @use_psych ||= defined?(Psych) && defined?(Psych::VERSION)
+  end
+
+end

data/lib/ice_cube/builders/hash_builder.rb

@@ -0,0 +1,27 @@
+module IceCube
+
+  class HashBuilder
+  
+    def initialize(rule = nil)
+      @hash = { :validations => {}, :rule_type => rule.class.name }
+    end
+
+    def validations
+      @hash[:validations]
+    end
+
+    def []=(key, value)
+      @hash[key] = value
+    end
+
+    def validations_array(type)
+      validations[type] ||= []
+    end
+
+    def to_hash
+      @hash
+    end
+
+  end
+
+end

data/lib/ice_cube/builders/ical_builder.rb

@@ -0,0 +1,59 @@
+module IceCube
+
+  class IcalBuilder
+
+    ICAL_DAYS = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA']
+
+    def initialize
+      @hash = {}
+    end
+
+    def self.fixnum_to_ical_day(num)
+      ICAL_DAYS[num]
+    end
+
+    def [](key)
+      @hash[key] ||= []
+    end
+
+    # Build for a single rule entry
+    def to_s
+      arr = []
+      if freq = @hash.delete('FREQ')
+        arr << "FREQ=#{freq.join(',')}"
+      end
+      arr.concat(@hash.map do |key, value|
+        if value.is_a?(Array)
+          "#{key}=#{value.join(',')}"
+        end
+      end.compact)
+      arr.join(';')
+    end
+
+    def self.ical_utc_format(time)
+      time = time.dup.utc
+      "#{time.strftime('%Y%m%dT%H%M%SZ')}" # utc time
+    end
+
+    def self.ical_format(time, force_utc)
+      time = time.dup.utc if force_utc
+      if time.utc?
+        ":#{time.strftime('%Y%m%dT%H%M%SZ')}" # utc time
+      else
+        ";TZID=#{time.strftime('%Z:%Y%m%dT%H%M%S')}" # local time specified
+      end
+    end
+
+    def self.ical_duration(duration)
+      hours = duration / 3600; duration %= 3600
+      minutes = duration / 60; duration %= 60
+      repr = ''
+      repr << "#{hours}H" if hours > 0
+      repr << "#{minutes}M" if minutes > 0
+      repr << "#{duration}S" if duration > 0
+      "PT#{repr}"
+    end
+
+  end
+
+end

data/lib/ice_cube/builders/string_builder.rb

@@ -0,0 +1,74 @@
+module IceCube
+
+  class StringBuilder
+
+    attr_writer :base
+
+    def initialize
+      @types = {}
+    end
+
+    def piece(type, prefix = nil, suffix = nil)
+      @types[type] ||= []
+    end
+
+    def to_s
+      str = @base || ''
+      res = @types.map do |type, segments|
+        if f = self.class.formatter(type)
+          str << ' ' + f.call(segments)
+        else
+          next if segments.empty?
+          str << ' ' + self.class.sentence(segments)
+        end
+      end
+      str
+    end
+
+    class << self
+
+      def formatter(type)
+        @formatters[type]
+      end
+
+      def register_formatter(type, &formatter)
+        @formatters ||= {}
+        @formatters[type] = formatter
+      end
+
+    end
+
+    class << self
+
+      NUMBER_SUFFIX = ['th', 'st', 'nd', 'rd', 'th', 'th', 'th', 'th', 'th', 'th']
+      SPECIAL_SUFFIX = { 11 => 'th', 12 => 'th', 13 => 'th', 14 => 'th' } 
+ 
+      # influenced by ActiveSupport's to_sentence
+      def sentence(array)
+        case array.length
+        when 0 ; ''
+        when 1 ; array[0].to_s
+        when 2 ; "#{array[0]} and #{array[1]}"
+        else ; "#{array[0...-1].join(', ')}, and #{array[-1]}"
+        end
+      end
+
+      def nice_number(number)
+        if number == -1
+          'last'
+        elsif number < -1
+          suffix = SPECIAL_SUFFIX.include?(number) ?
+            SPECIAL_SUFFIX[number] : NUMBER_SUFFIX[number.abs % 10]
+          number.abs.to_s << suffix << ' to last'
+        else
+          suffix = SPECIAL_SUFFIX.include?(number) ?
+            SPECIAL_SUFFIX[number] : NUMBER_SUFFIX[number.abs % 10]
+          number.to_s << suffix  
+        end
+      end
+
+    end
+  
+  end
+
+end

data/lib/ice_cube/deprecated.rb

@@ -0,0 +1,28 @@
+module Deprecated
+
+  # Define a deprecated alias for a method
+  # @param [Symbol] name - name of method to define
+  # @param [Symbol] replacement - name of method to replace (alias)
+  def deprecated_alias(name, replacement)
+    # Create a wrapped version
+    define_method(name) do |*args, &block|
+      warn "IceCube: ##{name} deprecated (please use ##{replacement})"
+      send replacement, *args, &block
+    end
+  end
+
+  # Deprecate a defined method
+  # @param [Symbol] name - name of deprecated method
+  # @param [Symbol] replacement - name of the desired replacement
+  def deprecated(name, replacement)
+    # Replace old method
+    old_name = :"#{name}_without_deprecation"
+    alias_method old_name, name
+    # And replace it with a wrapped version
+    define_method(name) do |*args, &block|
+      warn "IceCube: ##{name} deprecated (please use ##{replacement})"
+      send old_name, *args, &block
+    end
+  end
+
+end

data/lib/ice_cube/errors/count_exceeded.rb

@@ -0,0 +1,7 @@
+module IceCube
+
+  # An exception for when a count on a Rule is passed
+  class CountExceeded < Exception
+  end
+
+end

data/lib/ice_cube/errors/until_exceeded.rb

@@ -0,0 +1,7 @@
+module IceCube
+
+  # An exception for when an until date on a Rule is passed
+  class UntilExceeded < Exception
+  end
+
+end

data/lib/ice_cube/errors/zero_interval.rb

@@ -0,0 +1,7 @@
+module IceCube
+
+  # An exception for when interval is set to zero
+  class ZeroInterval < Exception
+  end
+
+end

data/lib/ice_cube/rule.rb

@@ -0,0 +1,182 @@
+require 'yaml'
+
+module IceCube
+
+  class Rule
+
+    attr_reader :uses
+
+    # Is this a terminating schedule?
+    def terminating?
+      until_time || occurrence_count
+    end
+
+    def ==(rule)
+      if rule.is_a? Rule
+        hash = to_hash
+        hash && hash == rule.to_hash
+      end
+    end
+
+    def hash
+      h = to_hash
+      h.nil? ? super : h.hash
+    end
+
+    # Expected to be overridden by subclasses
+    def to_ical
+      nil
+    end
+
+    def self.from_ical ical
+      params = {:validations => {}}
+      
+      ical.split(';').each do |rule|
+        (name, value) = rule.split('=')
+        case name
+        when 'FREQ'
+          params[:freq] = value.downcase
+        when 'INTERVAL'
+          params[:interval] = value.to_i
+        when 'COUNT'
+          params[:count] = value.to_i
+        when 'UNTIL'
+          params[:until] = DateTime.parse(value).to_time.utc
+        when 'WKST'
+          params[:wkst] = TimeUtil.ical_day_to_symbol(value)
+          
+        when 'BYSECOND'
+          params[:validations][:second_of_minute] = value.split(',').collect{ |v| v.to_i }
+        when "BYMINUTE"
+          params[:validations][:minute_of_hour] = value.split(',').collect{ |v| v.to_i }
+        when "BYHOUR"
+          params[:validations][:hour_of_day] = value.split(',').collect{ |v| v.to_i }
+        when "BYDAY"
+          dows = {}
+          days = []
+          value.split(',').each do |expr|
+              day = TimeUtil.ical_day_to_symbol(expr.strip[-2..-1])
+              if expr.strip.length > 2  # day with occurence
+                occ = expr[0..-3].to_i 
+                dows[day].nil? ? dows[day] = [occ] : dows[day].push(occ)
+                days.delete(TimeUtil.symbol_to_day(day))
+              else
+                days.push TimeUtil.symbol_to_day(day) if dows[day].nil?
+              end
+          end
+          params[:validations][:day_of_week] = dows unless dows.empty?
+          params[:validations][:day] = days unless days.empty?
+        when "BYMONTHDAY"
+          params[:validations][:day_of_month] = value.split(',').collect{ |v| v.to_i }
+        when "BYMONTH"
+          params[:validations][:month_of_year] = value.split(',').collect{ |v| v.to_i }
+        when "BYYEARDAY"
+          params[:validations][:day_of_year] = value.split(',').collect{ |v| v.to_i }
+          
+        else
+          raise "Invalid or unsupported rrule command : #{name}"
+        end
+      end
+
+      params[:interval] ||= 1
+      # WKST only valid for weekly rules
+      params.delete(:wkst) unless params[:freq] == 'weekly'
+
+      rule = IceCube::Rule.send(*params.values_at(:freq, :interval, :wkst).compact)
+      rule.count(params[:count]) if params[:count]
+      rule.until(params[:until]) if params[:until]
+      params[:validations].each do |key, value|
+        value.is_a?(Array) ? rule.send(key, *value) : rule.send(key, value)
+      end
+
+      rule
+    end
+
+    # Yaml implementation
+    def to_yaml(*args)
+      IceCube::use_psych? ? Psych::dump(to_hash) : YAML::dump(to_hash, *args)
+    end
+
+    # From yaml
+    def self.from_yaml(yaml)
+      from_hash IceCube::use_psych? ? Psych::load(yaml) : YAML::load(yaml)
+    end
+
+    # Expected to be overridden by subclasses
+    def to_hash
+      nil
+    end
+
+    # Convert from a hash and create a rule
+    def self.from_hash(hash)
+      return nil unless match = hash[:rule_type].match(/\:\:(.+?)Rule/)
+      rule = IceCube::Rule.send(match[1].downcase.to_sym, hash[:interval] || 1)
+      rule.until(TimeUtil.deserialize_time(hash[:until])) if hash[:until]
+      rule.count(hash[:count]) if hash[:count]
+      hash[:validations] && hash[:validations].each do |key, value|
+        key = key.to_sym unless key.is_a?(Symbol)
+        value.is_a?(::Array) ? rule.send(key, *value) : rule.send(key, value)
+      end
+      rule
+    end
+
+    # Reset the uses on the rule to 0
+    def reset
+      @uses = 0
+    end
+
+    def next_time(time, schedule, closing_time)
+    end
+
+    def on?(time, schedule)
+      next_time(time, schedule, time) == time
+    end
+
+    # Whether this rule requires a full run
+    def full_required?
+      !@count.nil?
+    end
+
+    # Convenience methods for creating Rules
+    class << self
+
+      # Secondly Rule
+      def secondly(interval = 1)
+        SecondlyRule.new(interval)
+      end
+
+      # Minutely Rule
+      def minutely(interval = 1)
+        MinutelyRule.new(interval)
+      end
+
+      # Hourly Rule
+      def hourly(interval = 1)
+        HourlyRule.new(interval)
+      end
+
+      # Daily Rule
+      def daily(interval = 1)
+        DailyRule.new(interval)
+      end
+
+      # Weekly Rule
+      def weekly(interval = 1, week_start = :sunday)
+        WeeklyRule.new(interval, week_start)
+      end
+
+      # Monthly Rule
+      def monthly(interval = 1)
+        MonthlyRule.new(interval)
+      end
+
+      # Yearly Rule
+      def yearly(interval = 1)
+        YearlyRule.new(interval)
+      end
+
+    end
+    
+  end
+
+end