Issues/50 from ical

.gitignore

@@ -6,3 +6,5 @@ coverage
 coverage.data
 *.gem
 .bundle
+*.idea
+/nbproject

.travis.yml

@@ -5,7 +5,7 @@ notifications:
 branches:
   only:
     - master
-    - v0.7
+    - issues/50-from_ical
 rvm:
   - 1.9.3
   - 2.0.0

README.md

@@ -90,7 +90,7 @@ schedule.add_recurrence_rule Rule.daily
 schedule.occurring_at?(now + 1800) # true
 schedule.occurring_between?(t1, t2)
 
-# using end_time also sets the duration 
+# using end_time also sets the duration
 schedule = Schedule.new(start = Time.now, :end_time => start + 3600)
 schedule.add_recurrence_rule Rule.daily
 schedule.occurring_at?(start + 3599) # true

ice_cube.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.rubyforge_project = "ice-cube"
 
   s.add_development_dependency('rake')
-  s.add_development_dependency('rspec', '~> 2.12.0')
-  s.add_development_dependency('activesupport', '>= 3.0.0')
-  s.add_development_dependency('tzinfo')
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('activesupport', '~> 4.0.0')
+  s.add_development_dependency('tzinfo', '~> 0.3')
 end

lib/ice_cube.rb

@@ -18,9 +18,11 @@ module IceCube
 
   autoload :HashParser, 'ice_cube/parsers/hash_parser'
   autoload :YamlParser, 'ice_cube/parsers/yaml_parser'
+  autoload :IcalParser, 'ice_cube/parsers/ical_parser'
 
   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'

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

lib/ice_cube/parsers/hash_parser.rb

@@ -53,15 +53,19 @@ def apply_end_time(schedule, data)
     def apply_rrules(schedule, data)
       return unless data[:rrules]
       data[:rrules].each do |h|
-        schedule.rrule(IceCube::Rule.from_hash(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 deprecated. (This will be going away)"
       data[:exrules].each do |h|
-        schedule.exrule(IceCube::Rule.from_hash(h))
+        rrule = h.is_a?(IceCube::Rule) ? h : IceCube::Rule.from_hash(h)
+
+        schedule.exrule(rrule)
       end
     end
 

lib/ice_cube/parsers/ical_parser.rb

@@ -0,0 +1,88 @@
+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] = [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] = 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.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{ |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 = 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

lib/ice_cube/schedule.rb

@@ -431,6 +431,8 @@ def next_time(time, closing_time)
             [min_time, new_time].compact.min
           rescue StopIteration
             min_time
+          rescue CountExceeded, UntilExceeded, ZeroInterval
+            next
           end
         end
         break nil unless min_time

lib/ice_cube/time_util.rb

@@ -10,6 +10,11 @@ module TimeUtil
       :thursday => 4, :friday => 5, :saturday => 6
     }
 
+    ICAL_DAYS = {
+      'SU' => :sunday, 'MO' => :monday, 'TU' => :tuesday, 'WE' => :wednesday,
+      'TH' => :thursday, 'FR' => :friday, 'SA' => :saturday
+    }
+
     MONTHS = {
       :january => 1, :february => 2, :march => 3, :april => 4, :may => 5,
       :june => 6, :july => 7, :august => 8, :september => 9, :october => 10,
@@ -142,12 +147,25 @@ def self.wday_to_sym(wday)
       end
     end
 
+    # Convert a symbol to an ical day (SU, MO)
+    def self.week_start(sym)
+      raise "No such day: #{sym}" unless DAYS.keys.include?(sym)
+      day = sym.to_s.upcase[0..1]
+      day
+    end
+
     # Convert weekday from base sunday to the schedule's week start.
     def self.normalize_wday(wday, week_start)
       (wday - sym_to_wday(week_start)) % 7
     end
     deprecated_alias :normalize_weekday, :normalize_wday
 
+    def self.ical_day_to_symbol(str)
+      day = ICAL_DAYS[str]
+      raise "No such day: #{str}" if day.nil?
+      day
+    end
+
     # Return the count of the number of times wday appears in the month,
     # and which of those time falls on
     def self.which_occurrence_in_month(time, wday)

lib/ice_cube/validations/daily_interval.rb

@@ -26,14 +26,6 @@ def dst_adjust?
         true
       end
 
-      def validate(step_time, schedule)
-        t0, t1 = schedule.start_time, step_time
-        days = Date.new(t1.year, t1.month, t1.day) -
-               Date.new(t0.year, t0.month, t0.day)
-        offset = (days % interval).nonzero?
-        interval - offset if offset
-      end
-
       def build_s(builder)
         builder.base = interval == 1 ? 'Daily' : "Every #{interval} days"
       end
@@ -47,6 +39,16 @@ def build_ical(builder)
         builder['INTERVAL'] << interval unless interval == 1
       end
 
+      def validate(time, schedule)
+        raise ZeroInterval if interval == 0
+        time_date = Date.new(time.year, time.month, time.day)
+        start_date = Date.new(schedule.start_time.year, schedule.start_time.month, schedule.start_time.day)
+        days = time_date - start_date
+        unless days % interval === 0
+          interval - (days % interval)
+        end
+      end
+
     end
 
   end

lib/ice_cube/validations/hourly_interval.rb

@@ -25,15 +25,6 @@ def dst_adjust?
         false
       end
 
-      def validate(step_time, schedule)
-        t0, t1 = schedule.start_time.to_i, step_time.to_i
-        sec = (t1 - t1 % ONE_HOUR) -
-              (t0 - t0 % ONE_HOUR)
-        hours = sec / ONE_HOUR
-        offset = (hours % interval).nonzero?
-        interval - offset if offset
-      end
-
       def build_s(builder)
         builder.base = interval == 1 ? 'Hourly' : "Every #{interval} hours"
       end
@@ -47,6 +38,17 @@ def build_ical(builder)
         builder['INTERVAL'] << interval unless interval == 1
       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

lib/ice_cube/validations/minutely_interval.rb

@@ -25,15 +25,6 @@ def dst_adjust?
         false
       end
 
-      def validate(step_time, schedule)
-        t0, t1 = schedule.start_time.to_i, step_time.to_i
-        sec = (t1 - t1 % ONE_MINUTE) -
-              (t0 - t0 % ONE_MINUTE)
-        minutes = sec / ONE_MINUTE
-        offset = (minutes % interval).nonzero?
-        interval - offset if offset
-      end
-
       def build_s(builder)
         builder.base = interval == 1 ? 'Minutely' : "Every #{interval} minutes"
       end
@@ -47,6 +38,17 @@ def build_ical(builder)
         builder['INTERVAL'] << interval unless interval == 1
       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

lib/ice_cube/validations/monthly_interval.rb

@@ -25,14 +25,6 @@ def dst_adjust?
         true
       end
 
-      def validate(step_time, schedule)
-        t0, t1 = schedule.start_time, step_time
-        months = (t1.month - t0.month) +
-                 (t1.year - t0.year) * 12
-        offset = (months % interval).nonzero?
-        interval - offset if offset
-      end
-
       def build_s(builder)
         builder.base = interval == 1 ? 'Monthly' : "Every #{interval} months"
       end
@@ -46,6 +38,15 @@ def build_ical(builder)
         builder['INTERVAL'] << interval unless interval == 1
       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

lib/ice_cube/validations/secondly_interval.rb

@@ -25,12 +25,6 @@ def dst_adjust?
         false
       end
 
-      def validate(step_time, schedule)
-        seconds = step_time.to_i - schedule.start_time.to_i
-        offset = (seconds % interval).nonzero?
-        interval - offset if offset
-      end
-
       def build_s(builder)
         builder.base = interval == 1 ? 'Secondly' : "Every #{interval} seconds"
       end
@@ -44,6 +38,14 @@ def build_ical(builder)
         builder['INTERVAL'] << interval unless interval == 1
       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