rrule 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38233f8772b83457ca170a1e6eaa20d8f8455c02
-  data.tar.gz: d0a65079756ddb7faf5f4615145ce7b99814c8b7
+  metadata.gz: 2f4e67330d4bebaf8408d3125386565754c269ef
+  data.tar.gz: e1bfbeadff4cd2cf622360d38357d954bd9f5984
 SHA512:
-  metadata.gz: 57f3d09db8034288534d465af4af7011e3fa39418d36372fa44e834464c970eaaa29dacd7f649a98a3c39909ad5112516ed873f3dfacd8966b27eb8270442979
-  data.tar.gz: a79d86f15deb399905eeebb6a9d5274839614bc772580361f5cf4f43ccb11e1d1584f19fb86ad6e58d16cbae3c5f43c89ef57adba6126626a4701d177e28f15d
+  metadata.gz: 55b57448971a919141f491bc141d017eb2bd98421ed0f7cf6bf79d51859fb5cf5e6647d1c28b9738e4465258108fa436be006466b25428823a49b6220808216f
+  data.tar.gz: 72792b23c6a0e483a37d16501d1a79a2efc2303e1e0113bf03dc83bcd6775933f0a946bbf7c3f52be211d17a5e87560977874f57b90223af567a2f2a302a8bc0

data/README.md

@@ -30,6 +30,14 @@ rrule.between(Time.new(2016, 6, 23), Time.new(2016, 6, 24))
 => [2016-06-23 16:45:32 -0700]
 ```
 
+You can limit the number of instances that are returned with the `limit` option:
+
+```ruby
+rrule = RRule::Rule.new('FREQ=DAILY;COUNT=3')
+rrule.all(limit: 2)
+=> [2016-06-23 16:45:32 -0700, 2016-06-24 16:45:32 -0700]
+```
+
 By default the DTSTART of the recurrence is the current time, but this can be overriden with the `dtstart` option:
 
 ```ruby

data/lib/rrule/rule.rb

@@ -1,44 +1,33 @@
 module RRule
   class Rule
-    attr_reader :rrule, :dtstart, :tz, :exdate
+    include Enumerable
+
+    attr_reader :dtstart, :tz, :exdate
 
     def initialize(rrule, dtstart: Time.now, tzid: 'UTC', exdate: [])
-      @rrule = rrule
-      # This removes all sub-second and floors it to the second level.
-      # Sub-second level calculations breaks a lot of assumptions in this
-      # library and rounding it may also cause unexpected inequalities.
-      @dtstart = Time.at(dtstart.to_i).in_time_zone(tzid)
+      @dtstart = floor_to_seconds(dtstart).in_time_zone(tzid)
       @tz = tzid
       @exdate = exdate
+      @options = parse_options(rrule)
     end
 
-    def all
-      reject_exdates(all_until(nil))
-    end
-
-    def between(start_date, end_date)
-      # This removes all sub-second and floors it to the second level.
-      # Sub-second level calculations breaks a lot of assumptions in this
-      # library and rounding it may also cause unexpected inequalities.
-      floored_start_date = Time.at(start_date.to_i)
-      floored_end_date = Time.at(end_date.to_i)
-      reject_exdates(all_until(floored_end_date).reject { |instance| instance < floored_start_date })
+    def all(limit: nil)
+      all_until(limit: limit)
     end
 
-    private
-
-    def reject_exdates(results)
-      results.reject { |date| exdate.include?(date) }
+    def between(start_date, end_date, limit: nil)
+      floored_start_date = floor_to_seconds(start_date)
+      floored_end_date = floor_to_seconds(end_date)
+      all_until(end_date: floored_end_date, limit: limit).reject { |instance| instance < floored_start_date }
     end
 
-    def all_until(end_date)
-      result = []
+    def each
+      return enum_for(:each) unless block_given?
 
       context = Context.new(options, dtstart, tz)
       context.rebuild(dtstart.year, dtstart.month)
 
       timeset = options[:timeset]
-      total = 0
       count = options[:count]
 
       filters = []
@@ -81,7 +70,7 @@ module RRule
       end
 
       loop do
-        return result if frequency.current_date.year > MAX_YEAR
+        return if frequency.current_date.year > MAX_YEAR
 
         possible_days_of_year = frequency.possible_days
 
@@ -90,42 +79,45 @@ module RRule
         end
 
         results_with_time = generator.combine_dates_and_times(possible_days_of_year, timeset)
-        results_with_time.sort.each do |this_result|
-          if end_date
-            if this_result > end_date
-              return result
-            end
-          end
-
-          if options[:until]
-            if this_result > options[:until]
-              return result
-            end
-            result.push(this_result)
-          elsif this_result >= dtstart
-            total += 1
-            if options[:count]
-              count -= 1
-              result.push(this_result)
-              return result if count == 0
-            else
-              result.push(this_result)
-            end
-          end
+        results_with_time.each do |this_result|
+          next if this_result < dtstart
+          return if options[:until] && this_result > options[:until]
+          return if count && (count -= 1) < 0
+          yield this_result unless exdate.include?(this_result)
         end
 
         frequency.advance
       end
     end
 
-    def options
-      @options ||= parse_options
+    def next
+      enumerator.next
     end
 
-    def parse_options
+    private
+
+    attr_reader :options
+
+    def floor_to_seconds(date)
+      return date
+      # This removes all sub-second and floors it to the second level.
+      # Sub-second level calculations breaks a lot of assumptions in this
+      # library and rounding it may also cause unexpected inequalities.
+      Time.at(date.to_i)
+    end
+
+    def enumerator
+      @enumerator ||= to_enum
+    end
+
+    def all_until(end_date: MAX_DATE, limit: nil)
+      limit ? take(limit) : take_while { |date| date <= end_date }
+    end
+
+    def parse_options(rule)
       options = { interval: 1, wkst: 1 }
 
-      params = @rrule.split(';')
+      params = rule.split(';')
       params.each do |param|
         option, value = param.split('=')
 
@@ -133,11 +125,19 @@ module RRule
         when 'FREQ'
           options[:freq] = value
         when 'COUNT'
-          options[:count] = value.to_i
+          i = begin
+            Integer(value)
+          rescue ArgumentError
+            raise InvalidRRule, "COUNT must be a non-negative integer"
+          end
+          raise InvalidRRule, "COUNT must be a non-negative integer" if i < 0
+          options[:count] = i
         when 'UNTIL'
           options[:until] = Time.parse(value)
         when 'INTERVAL'
-          options[:interval] = value.to_i
+          i = Integer(value) rescue 0
+          raise InvalidRRule, "INTERVAL must be a positive integer" unless i > 0
+          options[:interval] = i
         when 'BYDAY'
           options[:byweekday] = value.split(',').map { |day| Weekday.parse(day) }
         when 'BYSETPOS'

data/lib/rrule.rb

@@ -25,4 +25,7 @@ module RRule
   end
 
   MAX_YEAR = 9999
+  MAX_DATE = DateTime.new(MAX_YEAR)
+
+  class InvalidRRule < StandardError; end
 end

data/rrule.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'rrule'
-  s.version = '0.1.1'
+  s.version = '0.2.1'
   s.date = '2016-06-06'
   s.summary = 'RRule expansion'
   s.description = 'A gem for expanding dates according to the RRule specification'

data/spec/rule_spec.rb

@@ -1,6 +1,35 @@
 require 'spec_helper'
 
 describe RRule::Rule do
+  describe '#next' do
+    it 'can sequentially return values' do
+      rrule = 'FREQ=DAILY;COUNT=10'
+      dtstart = Time.parse('Tue Sep  2 06:00:00 PDT 1997')
+      timezone = 'America/New_York'
+
+      rrule = RRule::Rule.new(rrule, dtstart: dtstart, tzid: timezone)
+
+      expect(rrule.next).to eql Time.parse('Tue Sep  2 06:00:00 PDT 1997')
+      expect(rrule.next).to eql Time.parse('Wed Sep  3 06:00:00 PDT 1997')
+      expect(rrule.next).to eql Time.parse('Thu Sep  4 06:00:00 PDT 1997')
+    end
+  end
+
+  describe '#take' do
+    it 'can return the next N instances' do
+      rrule = 'FREQ=DAILY;COUNT=10'
+      dtstart = Time.parse('Tue Sep  2 06:00:00 PDT 1997')
+      timezone = 'America/New_York'
+
+      rrule = RRule::Rule.new(rrule, dtstart: dtstart, tzid: timezone)
+      expect(rrule.take(3)).to match_array([
+        Time.parse('Tue Sep  2 06:00:00 PDT 1997'),
+        Time.parse('Wed Sep  3 06:00:00 PDT 1997'),
+        Time.parse('Thu Sep  4 06:00:00 PDT 1997')
+      ])
+    end
+  end
+
   describe '#all' do
     it 'returns the correct result with an rrule of FREQ=DAILY;COUNT=10' do
       rrule = 'FREQ=DAILY;COUNT=10'
@@ -22,6 +51,21 @@ describe RRule::Rule do
       ])
     end
 
+    it 'returns the correct result with an rrule of FREQ=DAILY;COUNT=10 and a limit' do
+      rrule = 'FREQ=DAILY;COUNT=10'
+      dtstart = Time.parse('Tue Sep  2 06:00:00 PDT 1997')
+      timezone = 'America/New_York'
+
+      rrule = RRule::Rule.new(rrule, dtstart: dtstart, tzid: timezone)
+      expect(rrule.all(limit: 5)).to match_array([
+        Time.parse('Tue Sep  2 06:00:00 PDT 1997'),
+        Time.parse('Wed Sep  3 06:00:00 PDT 1997'),
+        Time.parse('Thu Sep  4 06:00:00 PDT 1997'),
+        Time.parse('Fri Sep  5 06:00:00 PDT 1997'),
+        Time.parse('Sat Sep  6 06:00:00 PDT 1997')
+      ])
+    end
+
     it 'returns the correct result with an rrule of FREQ=DAILY;UNTIL=19971224T000000Z' do
       rrule = 'FREQ=DAILY;UNTIL=19971224T000000Z'
       dtstart = Time.parse('Tue Sep  2 06:00:00 PDT 1997')
@@ -1668,8 +1712,8 @@ describe RRule::Rule do
         Time.parse('Mon Aug 29 19:00:00 PDT 2016')
       ])
     end
-
   end
+
   describe '#between' do
     it 'returns the correct result with an rrule of FREQ=DAILY;INTERVAL=2' do
       rrule = 'FREQ=DAILY;INTERVAL=2'
@@ -1707,6 +1751,21 @@ describe RRule::Rule do
       ])
     end
 
+    it 'returns the correct result with an rrule of FREQ=DAILY;INTERVAL=2 and a limit' do
+      rrule = 'FREQ=DAILY;INTERVAL=2'
+      dtstart = Time.parse('Tue Sep  2 06:00:00 PDT 1997')
+      timezone = 'America/New_York'
+
+      rrule = RRule::Rule.new(rrule, dtstart: dtstart, tzid: timezone)
+      expect(rrule.between(Time.parse('Tue Sep  2 06:00:00 PDT 1997'), Time.parse('Wed Oct 22 06:00:00 PDT 1997'), limit: 5)).to match_array([
+        Time.parse('Tue Sep  2 06:00:00 PDT 1997'),
+        Time.parse('Thu Sep  4 06:00:00 PDT 1997'),
+        Time.parse('Sat Sep  6 06:00:00 PDT 1997'),
+        Time.parse('Mon Sep  8 06:00:00 PDT 1997'),
+        Time.parse('Wed Sep 10 06:00:00 PDT 1997')
+      ])
+    end
+
     it 'returns the correct result with an rrule of FREQ=WEEKLY;INTERVAL=2;WKST=SU' do
       rrule = 'FREQ=WEEKLY;INTERVAL=2;WKST=SU'
       dtstart = Time.parse('Tue Sep  2 06:00:00 PDT 1997')
@@ -1958,10 +2017,13 @@ describe RRule::Rule do
       dtstart = Time.parse('Thu Jan 28 17:00:00 PST 2016').in_time_zone(timezone)
 
       rrule = RRule.parse(rrule, dtstart: dtstart, tzid: timezone)
-      expect(rrule.between(Time.parse('Tue May 24 14:34:59 PDT 2016'), Time.parse('Sun Jul 24 14:35:09 PDT 2016'))).to match_array([
-                                                                                                                               Time.parse('Thu Jun 16 17:00:00 PDT 2016'),
-                                                                                                                               Time.parse('Thu Jul 14 17:00:00 PDT 2016')
-                                                                                                                           ])
+      expect(rrule.between(
+        Time.parse('Tue May 24 14:34:59 PDT 2016'),
+        Time.parse('Sun Jul 24 14:35:09 PDT 2016')
+      )).to match_array([
+        Time.parse('Thu Jun 16 17:00:00 PDT 2016'),
+        Time.parse('Thu Jul 14 17:00:00 PDT 2016')
+      ])
     end
 
     it 'returns the correct result with a date start right on the year border' do
@@ -1985,4 +2047,31 @@ describe RRule::Rule do
       expect(rule.between(start_time, end_time)).to eql([expected_instance])
     end
   end
+
+  describe 'validation' do
+    it 'raises RRule::InvalidRRule if INTERVAL is not a positive integer' do
+      dtstart = Time.parse('Tue Sep  2 06:00:00 PDT 1997')
+      timezone = 'America/New_York'
+
+      expect { RRule::Rule.new('FREQ=DAILY;INTERVAL=0', dtstart: dtstart, tzid: timezone) }.to raise_error(RRule::InvalidRRule)
+      expect { RRule::Rule.new('FREQ=DAILY;INTERVAL=-1', dtstart: dtstart, tzid: timezone) }.to raise_error(RRule::InvalidRRule)
+      expect { RRule::Rule.new('FREQ=DAILY;INTERVAL=1.1', dtstart: dtstart, tzid: timezone) }.to raise_error(RRule::InvalidRRule)
+      expect { RRule::Rule.new('FREQ=DAILY;INTERVAL=BOOM', dtstart: dtstart, tzid: timezone) }.to raise_error(RRule::InvalidRRule)
+    end
+
+    it 'raises RRule::InvalidRRule if COUNT is not an integer' do
+      dtstart = Time.parse('Tue Sep  2 06:00:00 PDT 1997')
+      timezone = 'America/New_York'
+
+      expect { RRule::Rule.new('FREQ=DAILY;COUNT=BOOM', dtstart: dtstart, tzid: timezone) }.to raise_error(RRule::InvalidRRule)
+      expect { RRule::Rule.new('FREQ=DAILY;COUNT=1.5', dtstart: dtstart, tzid: timezone) }.to raise_error(RRule::InvalidRRule)
+    end
+
+    it 'raises RRule::InvalidRRule if COUNT is negative' do
+      dtstart = Time.parse('Tue Sep  2 06:00:00 PDT 1997')
+      timezone = 'America/New_York'
+
+      expect { RRule::Rule.new('FREQ=DAILY;COUNT=-1', dtstart: dtstart, tzid: timezone) }.to raise_error(RRule::InvalidRRule)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rrule
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Ryan Mitchell