ice_cube_chosko 0.1.0

data/lib/ice_cube/parsers/hash_parser.rb

@@ -0,0 +1,91 @@
+module IceCube
+  class HashParser
+
+    attr_reader :hash
+
+    def initialize(original_hash)
+      @hash = original_hash
+    end
+
+    def to_schedule
+      data = normalize_keys(hash)
+      schedule = IceCube::Schedule.new parse_time(data[:start_time])
+      apply_duration schedule, data
+      apply_end_time schedule, data
+      apply_rrules schedule, data
+      apply_exrules schedule, data
+      apply_rtimes schedule, data
+      apply_extimes schedule, data
+      yield schedule if block_given?
+      schedule
+    end
+
+    private
+
+    def normalize_keys(hash)
+      data = IceCube::FlexibleHash.new(hash.dup)
+
+      if (start_date = data.delete(:start_date))
+        warn "IceCube: :start_date is deprecated, please use :start_time at: #{ caller[0] }"
+        data[:start_time] = start_date
+      end
+
+      {:rdates => :rtimes, :exdates => :extimes}.each do |old_key, new_key|
+        if (times = data.delete(old_key))
+          warn "IceCube: :#{old_key} is deprecated, please use :#{new_key} at: #{ caller[0] }"
+          (data[new_key] ||= []).concat times
+        end
+      end
+
+      data
+    end
+
+    def apply_duration(schedule, data)
+      return unless data[:duration]
+      schedule.duration = data[:duration].to_i
+    end
+
+    def apply_end_time(schedule, data)
+      return unless data[:end_time]
+      schedule.end_time = parse_time(data[:end_time])
+    end
+
+    def apply_rrules(schedule, data)
+      return unless data[:rrules]
+      data[:rrules].each do |h|
+        rrule = h.is_a?(IceCube::Rule) ? h : IceCube::Rule.from_hash(h)
+
+        schedule.rrule(rrule)
+      end
+    end
+
+    def apply_exrules(schedule, data)
+      return unless data[:exrules]
+      warn "IceCube: :exrules is deprecated, and will be removed in a future release. at: #{ caller[0] }"
+      data[:exrules].each do |h|
+        rrule = h.is_a?(IceCube::Rule) ? h : IceCube::Rule.from_hash(h)
+
+        schedule.exrule(rrule)
+      end
+    end
+
+    def apply_rtimes(schedule, data)
+      return unless data[:rtimes]
+      data[:rtimes].each do |t|
+        schedule.add_recurrence_time TimeUtil.deserialize_time(t)
+      end
+    end
+
+    def apply_extimes(schedule, data)
+      return unless data[:extimes]
+      data[:extimes].each do |t|
+        schedule.add_exception_time TimeUtil.deserialize_time(t)
+      end
+    end
+
+    def parse_time(time)
+      TimeUtil.deserialize_time(time)
+    end
+
+  end
+end

data/lib/ice_cube/parsers/ical_parser.rb

@@ -0,0 +1,91 @@
+module IceCube
+  class IcalParser
+    def self.schedule_from_ical(ical_string, options = {})
+      data = {}
+      ical_string.each_line do |line|
+        (property, value) = line.split(':')
+        (property, tzid) = property.split(';')
+        case property
+        when 'DTSTART'
+          data[:start_time] = Time.parse(value)
+        when 'DTEND'
+          data[:end_time] = Time.parse(value)
+        when 'EXDATE'
+          data[:extimes] ||= []
+          data[:extimes] += value.split(',').map{|v| Time.parse(v)}
+        when 'DURATION'
+          data[:duration] # FIXME
+        when 'RRULE'
+          data[:rrules] ||= []
+          data[:rrules] += [rule_from_ical(value)]
+        end
+      end
+      Schedule.from_hash data
+    end
+
+    def self.rule_from_ical(ical)
+      params = { validations: { } }
+
+      ical.split(';').each do |rule|
+        (name, value) = rule.split('=')
+        value.strip!
+        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] = Time.parse(value).utc
+        when 'WKST'
+          params[:wkst] = TimeUtil.ical_day_to_symbol(value)
+        when 'BYSECOND'
+          params[:validations][:second_of_minute] = value.split(',').collect(&:to_i)
+        when 'BYMINUTE'
+          params[:validations][:minute_of_hour] = value.split(',').collect(&:to_i)
+        when 'BYHOUR'
+          params[:validations][:hour_of_day] = value.split(',').collect(&: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.sym_to_wday(day))
+            else
+              days.push TimeUtil.sym_to_wday(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(&:to_i)
+        when 'BYMONTH'
+          params[:validations][:month_of_year] = value.split(',').collect(&:to_i)
+        when 'BYYEARDAY'
+          params[:validations][:day_of_year] = value.split(',').collect(&:to_i)
+        when 'BYSETPOS'
+        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 = 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
+  end
+end

data/lib/ice_cube/parsers/yaml_parser.rb

@@ -0,0 +1,19 @@
+require 'yaml'
+
+module IceCube
+  class YamlParser < HashParser
+
+    SERIALIZED_START = /start_(?:time|date): .+(?<tz>(?:-|\+)\d{2}:\d{2})$/
+
+    attr_reader :hash
+
+    def initialize(yaml)
+      @hash = YAML::load(yaml)
+      yaml.match SERIALIZED_START do |match|
+        start_time = hash[:start_time] || hash[:start_date]
+        TimeUtil.restore_deserialized_offset start_time, match[:tz]
+      end
+    end
+
+  end
+end

data/lib/ice_cube/rule.rb

@@ -0,0 +1,123 @@
+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
+
+    def to_ical
+      raise MethodNotImplemented, "Expected to be overrridden by subclasses"
+    end
+
+    # Convert from ical string and create a rule
+    def self.from_ical(ical)
+      IceCube::IcalParser.rule_from_ical(ical)
+    end
+
+    # Yaml implementation
+    def to_yaml(*args)
+      YAML::dump(to_hash, *args)
+    end
+
+    # From yaml
+    def self.from_yaml(yaml)
+      from_hash YAML::load(yaml)
+    end
+
+    def to_hash
+      raise MethodNotImplemented, "Expected to be overridden by subclasses"
+    end
+
+    # Convert from a hash and create a rule
+    def self.from_hash(original_hash)
+      hash = IceCube::FlexibleHash.new original_hash
+      return nil unless match = hash[:rule_type].match(/\:\:(.+?)Rule/)
+      rule = IceCube::Rule.send(match[1].downcase.to_sym, hash[:interval] || 1)
+      rule.interval(hash[:interval] || 1, TimeUtil.wday_to_sym(hash[:week_start] || 0)) if match[1] == "Weekly"
+      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).to_i == time.to_i
+    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

data/lib/ice_cube/rules/daily_rule.rb

@@ -0,0 +1,16 @@
+module IceCube
+
+  class DailyRule < ValidatedRule
+
+    include Validations::DailyInterval
+
+    def initialize(interval = 1, week_start = :sunday)
+      super
+      interval(interval)
+      schedule_lock(:hour, :min, :sec)
+      reset
+    end
+
+  end
+
+end

data/lib/ice_cube/rules/hourly_rule.rb

@@ -0,0 +1,16 @@
+module IceCube
+
+  class HourlyRule < ValidatedRule
+
+    include Validations::HourlyInterval
+
+    def initialize(interval = 1, week_start = :sunday)
+      super
+      interval(interval)
+      schedule_lock(:min, :sec)
+      reset
+    end
+
+  end
+
+end

data/lib/ice_cube/rules/minutely_rule.rb

@@ -0,0 +1,16 @@
+module IceCube
+
+  class MinutelyRule < ValidatedRule
+
+    include Validations::MinutelyInterval
+
+    def initialize(interval = 1, week_start = :sunday)
+      super
+      interval(interval)
+      schedule_lock(:sec)
+      reset
+    end
+
+  end
+
+end

data/lib/ice_cube/rules/monthly_rule.rb

@@ -0,0 +1,16 @@
+module IceCube
+
+  class MonthlyRule < ValidatedRule
+
+    include Validations::MonthlyInterval
+
+    def initialize(interval = 1, week_start = :sunday)
+      super
+      interval(interval)
+      schedule_lock(:day, :hour, :min, :sec)
+      reset
+    end
+
+  end
+
+end

data/lib/ice_cube/rules/secondly_rule.rb

@@ -0,0 +1,15 @@
+module IceCube
+
+  class SecondlyRule < ValidatedRule
+
+    include Validations::SecondlyInterval
+
+    def initialize(interval = 1, week_start = :sunday)
+      super
+      interval(interval)
+      reset
+    end
+
+  end
+
+end

data/lib/ice_cube/rules/weekly_rule.rb

@@ -0,0 +1,16 @@
+module IceCube
+
+  class WeeklyRule < ValidatedRule
+
+    include Validations::WeeklyInterval
+
+    def initialize(interval = 1, week_start = :sunday)
+      super
+      interval(interval, week_start)
+      schedule_lock(:wday, :hour, :min, :sec)
+      reset
+    end
+
+  end
+
+end

data/lib/ice_cube/rules/yearly_rule.rb

@@ -0,0 +1,16 @@
+module IceCube
+
+  class YearlyRule < ValidatedRule
+
+    include Validations::YearlyInterval
+
+    def initialize(interval = 1, week_start = :sunday)
+      super
+      interval(interval)
+      schedule_lock(:month, :day, :hour, :min, :sec)
+      reset
+    end
+
+  end
+
+end