End of duration shouldn't hit start of check

The spans checks were incorrectly returning a hit when the end of the duration for an event ended on the same time as the start time checks. Allows occurring_between? method to now be simplifed to use the spanned check.

Author: jopotts

lib/ice_cube/schedule.rb

@@ -226,9 +226,7 @@ def occurs_between?(begin_time, closing_time, spans = false)
     # occurrences at the end of the range since none of their duration
     # intersects the range.
     def occurring_between?(opening_time, closing_time)
-      opening_time = opening_time - duration
-      closing_time = closing_time - 1 if duration > 0
-      occurs_between?(opening_time, closing_time)
+      occurs_between?(opening_time, closing_time, true)
     end
 
     # Return a boolean indicating if an occurrence falls on a certain date
@@ -409,13 +407,14 @@ def enumerate_occurrences(opening_time, closing_time = nil, spans = false, &bloc
       closing_time = TimeUtil.match_zone(closing_time, start_time)
       opening_time += start_time.subsec - opening_time.subsec rescue 0
       opening_time = start_time if opening_time < start_time
+      spans = false if duration == 0
       Enumerator.new do |yielder|
         reset
         t1 = full_required? ? start_time : realign((spans ? opening_time - duration : opening_time))
         loop do
           break unless (t0 = next_time(t1, closing_time))
           break if closing_time && t0 > closing_time
-          if (spans ? t0.end_time : t0) >= opening_time
+          if (spans ? (t0.end_time > opening_time) : (t0 >= opening_time))
             yielder << (block_given? ? block.call(t0) : t0)
           end
           break unless (t1 = next_time(t0 + 1, closing_time))
@@ -424,7 +423,7 @@ def enumerate_occurrences(opening_time, closing_time = nil, spans = false, &bloc
             wind_back_dst
             next (t1 += 1)
           end
-          if (spans ? t1.end_time : t1) >= opening_time
+          if (spans ? (t1.end_time > opening_time) : (t1 >= opening_time))
             yielder << (block_given? ? block.call(t1) : t1)
           end
           next (t1 += 1)

spec/examples/schedule_spec.rb

@@ -500,10 +500,10 @@
       occs.should == [t0]
     end
 
-    it 'should include long occurrences starting before and ending after' do
+    it 'should not find occurrence with duration ending on start time' do
       t0 = Time.utc(2015, 10, 1, 12, 00)
       schedule = IceCube::Schedule.new(t0, :duration => IceCube::ONE_HOUR)
-      schedule.occurs_between?(t0 + IceCube::ONE_HOUR, t0 + 2 * IceCube::ONE_HOUR, true).should be_true
+      schedule.occurs_between?(t0 + IceCube::ONE_HOUR, t0 + 2 * IceCube::ONE_HOUR, true).should be_false
     end
 
     it 'should quickly fetch a future time from a recurring schedule' do
@@ -518,6 +518,14 @@
       timing.should < 0.1
       occ.should == [t1]
     end
+    
+    it 'should not include occurrence ending on start time' do
+      t0 = Time.utc(2015, 10, 1, 10, 00)
+      schedule = IceCube::Schedule.new(t0, :duration => IceCube::ONE_HOUR / 2)
+      schedule.add_recurrence_rule IceCube::Rule.minutely(30).count(6)
+      third_occ = schedule.next_occurrence(t0 + IceCube::ONE_HOUR, true)
+      third_occ.should == t0 + IceCube::ONE_HOUR
+    end
 
   end
 
@@ -527,8 +535,8 @@
       t0 = Time.utc(2013, 5, 18, 12, 34)
       schedule = IceCube::Schedule.new(t0)
       schedule.add_recurrence_rule IceCube::Rule.daily
-      previous = schedule.previous_occurrence(t0 + 2 * ONE_DAY)
-      previous.should == t0 + ONE_DAY
+      previous = schedule.previous_occurrence(t0 + 2 * IceCube::ONE_DAY)
+      previous.should == t0 + IceCube::ONE_DAY
     end
 
     it 'returns nil given the start time' do
@@ -555,16 +563,16 @@
       t0 = Time.utc(2013, 5, 18, 12, 34)
       schedule = IceCube::Schedule.new(t0)
       schedule.add_recurrence_rule IceCube::Rule.daily
-      previous = schedule.previous_occurrences(2, t0 + 3 * ONE_DAY)
-      previous.should == [t0 + ONE_DAY, t0 + 2 * ONE_DAY]
+      previous = schedule.previous_occurrences(2, t0 + 3 * IceCube::ONE_DAY)
+      previous.should == [t0 + IceCube::ONE_DAY, t0 + 2 * IceCube::ONE_DAY]
     end
 
     it 'limits the returned occurrences to a given count' do
       t0 = Time.utc(2013, 5, 18, 12, 34)
       schedule = IceCube::Schedule.new(t0)
       schedule.add_recurrence_rule IceCube::Rule.daily
-      previous = schedule.previous_occurrences(999, t0 + 2 * ONE_DAY)
-      previous.should == [t0, t0 + ONE_DAY]
+      previous = schedule.previous_occurrences(999, t0 + 2 * IceCube::ONE_DAY)
+      previous.should == [t0, t0 + IceCube::ONE_DAY]
     end
 
     it 'returns empty array given the start time' do
@@ -601,7 +609,7 @@
       t1 = Time.utc(2013, 5, 31, 12, 34)
       schedule = IceCube::Schedule.new(t0)
       schedule.add_recurrence_rule IceCube::Rule.daily.until(t1 + 1)
-      schedule.last(2).should == [t1 - ONE_DAY, t1]
+      schedule.last(2).should == [t1 - IceCube::ONE_DAY, t1]
     end
 
     it 'raises an error for a non-terminating schedule' do