ice_cube 0.6.14 → 0.7.0

data/lib/ice_cube.rb

@@ -1,48 +1,74 @@
-require 'yaml.rb'
-require 'set.rb'
 require 'date'
 
-require 'ice_cube/time_util'
-
-require 'ice_cube/validation'
-require 'ice_cube/validation_types'
-require 'ice_cube/rule'
-require 'ice_cube/schedule'
-require 'ice_cube/rule_occurrence'
+# 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 :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'
-   
-  autoload :HourlyRule, 'ice_cube/rules/hourly_rule'
-  autoload :MinutelyRule, 'ice_cube/rules/minutely_rule'
-  autoload :SecondlyRule, 'ice_cube/rules/secondly_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
 
-  autoload :DayValidation, 'ice_cube/validations/day'
-  autoload :DayOfMonthValidation, 'ice_cube/validations/day_of_month'
-  autoload :DayOfWeekValidation, 'ice_cube/validations/day_of_week'
-  autoload :DayOfYearValidation, 'ice_cube/validations/day_of_year'
-  autoload :HourOfDayValidation, 'ice_cube/validations/hour_of_day'
-  autoload :MinuteOfHourValidation, 'ice_cube/validations/minute_of_hour'
-  autoload :MonthOfYearValidation, 'ice_cube/validations/month_of_year'
-  autoload :SecondOfMinuteValidation, 'ice_cube/validations/second_of_minute'
-
-  # if you're reading this code, you've just been iced
-  # http://brosicingbros.com/
-  
-  IceCube::ONE_DAY = 24 * 60 * 60
-  IceCube::ONE_HOUR = 60 * 60
-  IceCube::ONE_MINUTE = 60
-  IceCube::ONE_SECOND = 1
-  
-  ICAL_DAYS = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA']
-  DAYS = { :sunday => 0, :monday => 1, :tuesday => 2, :wednesday => 3, :thursday => 4, :friday => 5, :saturday => 6 }
-  MONTHS = { :january => 1, :february => 2, :march => 3, :april => 4, :may => 5, :june => 6, :july => 7, :august => 8, 
-             :september => 9, :october => 10, :november => 11, :december => 12 }
-  
-  include TimeUtil
+  # Formatting
+  TO_S_TIME_FORMAT = '%B %e, %Y'
 
 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/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/rule.rb

@@ -1,171 +1,109 @@
+require 'yaml'
+
 module IceCube
-  
+
   class Rule
-    
-    attr_reader :occurrence_count, :until_date
-    attr_reader :interval
-    attr_reader :validations
-    
-    include ValidationTypes
-    include Comparable
 
-    # Compare based on hash representations
-    def <=>(other)
-      to_hash <=> other.to_hash
-    end
+    attr_reader :uses
 
-    def to_hash
-      hash = Hash.new
-      hash[:rule_type] = self.class.name
-      hash[:interval] = @interval
-      hash[:until] = @until_date ? TimeUtil.serialize_time(@until_date) : @until_date
-      hash[:count] = @occurrence_count
-      hash[:validations] = @validations
-      hash
-    end
-    
-    def self.from_hash(hash)
-      rule = hash[:rule_type].split('::').inject(Object) { |namespace, const_name| namespace.const_get(const_name) }.new(hash[:interval])
-      rule.count(hash[:count]) if hash[:count]
-      rule.until(hash[:until]) if hash[:until]
-      hash[:validations].each do |validation, data|
-        data.is_a?(Array) ? rule.send(validation, *data) : rule.send(validation, data)
-      end
-      rule
-    end
-        
-    def to_yaml(options = {})
-      to_hash.to_yaml(options)
+    # Is this a terminating schedule?
+    def terminating?
+      until_time || occurrence_count
     end
 
-    def self.from_yaml(str)
-      from_hash(YAML::load(str))
+    def ==(rule)
+      hash = to_hash
+      hash && hash == rule.to_hash
     end
-    
-    # create a new daily rule
-    def self.daily(interval = 1)
-      DailyRule.new(interval)
+
+    def hash
+      h = to_hash
+      h.nil? ? super : h.hash
     end
 
-    # create a new weekly rule
-    def self.weekly(interval = 1)
-      WeeklyRule.new(interval)
+    # Expected to be overridden by subclasses
+    def to_ical
+      nil
     end
 
-    # create a new monthly rule
-    def self.monthly(interval = 1)
-      MonthlyRule.new(interval)
+    # Yaml implementation
+    def to_yaml(*args)
+      defined?(Psych) ? Psych::dump(to_hash) : YAML::dump(to_hash, *args)
     end
 
-    # create a new yearly rule
-    def self.yearly(interval = 1)
-      YearlyRule.new(interval)
+    # From yaml
+    def self.from_yaml(yaml)
+      from_hash defined?(Psych) ? Psych::load(yaml) : YAML::load(yaml)
     end
-    
-    # create a new hourly rule
-    def self.hourly(interval = 1)
-      HourlyRule.new(interval)
+
+    # Expected to be overridden by subclasses
+    def to_hash
+      nil
     end
-    
-    # create a new minutely rule
-    def self.minutely(interval = 1)
-      MinutelyRule.new(interval)
+
+    # 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
-    
-    # create a new secondly rule
-    def self.secondly(interval = 1)
-      SecondlyRule.new(interval)
+
+    # Reset the uses on the rule to 0
+    def reset
+      @uses = 0
     end
-    
-    # Set the time when this rule will no longer be effective
-    def until(until_date)
-      raise ArgumentError.new('Cannot specify until and count on the same rule') if @count #as per rfc
-      @until_date = until_date
-      self
+
+    def next_time(time, schedule, closing_time)
     end
-    
-    # set the number of occurrences after which this rule is no longer effective
-    def count(count)
-      raise ArgumentError.new('Argument must be a positive integer') unless Integer(count) && count >= 0
-      @occurrence_count = count
-      self
+
+    def on?(time, schedule)
+      next_time(time, schedule, time) == time
     end
-    
-    def validate_single_date(date)
-      @validation_types.values.all? do |validation|
-        response = validation.send(:validate, date)
-        response.nil? || response
+
+    # Convenience methods for creating Rules
+    class << self
+
+      # Secondly Rule
+      def secondly(interval = 1)
+        SecondlyRule.new(interval)
       end
-    end
-    
-    # The key to speed - extremely educated guesses
-    # This spidering behavior will go through look for the next suggestion
-    # by constantly moving the farthest back value forward
-    def next_suggestion(date)
-      # get the next date recommendation set
-      suggestions = {}; 
-      @validation_types.each { |k, validation| suggestions[k] = validation.send(:closest, date) }
-      compact_suggestions = suggestions.values.compact
-      # find the next date to go to
-      if compact_suggestions.empty?
-        attempt_count = 0
-        loop do
-          # keep going through rule suggestions
-          next_date = self.default_jump(date, attempt_count += 1)
-          return next_date if !next_date.nil? && validate_single_date(next_date)
-        end
-      else
-        loop do
-          compact_suggestions = suggestions.values.compact
-          min_suggestion = compact_suggestions.min
-          # validate all against the minimum
-          return min_suggestion if validate_single_date(min_suggestion)
-          # move anything that is the minimum to its next closest
-          @validation_types.each do |k, validation|
-            suggestions[k] = validation.send(:closest, min_suggestion) if min_suggestion == suggestions[k]
-          end
-        end
+
+      # Minutely Rule
+      def minutely(interval = 1)
+        MinutelyRule.new(interval)
       end
-    end
-    
-    attr_reader :validations
-    
-    private
-    
-    def adjust(goal, date)
-      return goal if goal.utc_offset == date.utc_offset
-      goal - goal.utc_offset + date.utc_offset
-    end
-    
-    # get a very meaningful string representation of this rule
-    def to_s_base(singular, plural)
-      representation = ''
-      representation = (@interval == 1 ? singular : plural)
-      representation << @validation_types.values.map { |v| ' ' + v.send(:to_s) }.join()
-      representation << " #{occurrence_count} #{@occurrence_count == 1 ? 'time' : 'times'}" if @occurrence_count
-      representation
-    end
-    
-    # get the icalendar representation of this rule logic
-    # Note: UNTIL dates are always in UTC as per iCalendar
-    def to_ical_base
-      representation = ''
-      representation << ";INTERVAL=#{@interval}" if @interval > 1
-      @validation_types.values.each do |v|
-        representation << ';' << v.send(:to_ical)
-      end      
-      representation << ";COUNT=#{@occurrence_count}" if @occurrence_count
-      representation << ";UNTIL=#{TimeUtil.ical_utc_format(@until_date)}" if @until_date
-      representation
-    end
-    
-    # Set the interval for the rule.  Depending on the type of rule,
-    # interval means every (n) weeks, months, etc. starting on the start_date's
-    def initialize(interval = 1)
-      throw ArgumentError.new('Interval must be > 0') unless interval > 0
-      @validations = {}
-      @validation_types = {}
-      @interval = interval
+
+      # 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)
+        WeeklyRule.new(interval)
+      end
+
+      # Monthly Rule
+      def monthly(interval = 1)
+        MonthlyRule.new(interval)
+      end
+
+      # Yearly Rule
+      def yearly(interval = 1)
+        YearlyRule.new(interval)
+      end
+
     end
     
   end