time_frame 0.0.6 → 0.1.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    Nzk5ZmI2MDEwY2E0MTkzOTU1NDE2MDYwNzE5ZDcwZjZhY2U2MTg3Mg==
-  data.tar.gz: !binary |-
-    ZjRkOTNjYmVmMjMxY2MwZjYyMTgwNmM1ODBmZDFkZTA0YmI2ZjE5OQ==
+SHA1:
+  metadata.gz: 3a7329ea6aa8db160440c921d298bb8037194707
+  data.tar.gz: 445018532eec6574f3c254f388b11162d34a23af
 SHA512:
-  metadata.gz: !binary |-
-    NzBmZjQ5MWYwNDRjYjNjOTZmOTYwMGU3OTYzNzBiNjZhOTMwOThlMDEyZDRh
-    NTQ4MTk3NTgyZmNkMmQyYzUyMmQxNWMxNDIwODdmNmI5MDc0NjIzZDE3Nzc5
-    OGFhYzA5OTZmZGU0OWU0YzBmZjM0M2U3NzMwMGZmNzRhOTJiYmM=
-  data.tar.gz: !binary |-
-    OGU5YTZhZDE3ZDc0NTY5MmI5OGUyYjU5OGEzNTY2NjljMDkwMTQ3OWQ3MTEw
-    YTgwMWNiZmU1YTFjNjYzZTczZmU5NTc0YTRjOTMxNjg0ODFjOTk0YzE2OTcw
-    N2Q0MDIzYjYyNWVmMzllYjcxZTEzZjBjY2U1YmQ3MzFhMTllOTE=
+  metadata.gz: eef4ffa1fbc1a5bf4154582445d7dea4fcae7e21f3b6c019651c4d8e4bb2562180017c629f50669c2d671c549b66ab05f4792f88285296158c5a909791636a00
+  data.tar.gz: 08d510eb2c5b59d6eec01334183d582b44c93d623c75dd3f98db55817d915f339d829fc9ced18fe667239038abe3da6440a62b2d8ccbf9985295245cc0293256

data/Rakefile

@@ -3,7 +3,7 @@ require 'rspec/core/rake_task'
 require 'rubocop/rake_task'
 require 'bundler/gem_tasks'
 
-Rubocop::RakeTask.new
+RuboCop::RakeTask.new
 
 RSpec::Core::RakeTask.new :spec
 

data/lib/time_frame.rb

@@ -1,7 +1,9 @@
 # Encoding: utf-8
 require 'active_support'
 require 'active_support/core_ext'
+require 'singleton'
 
+require 'time_frame/empty'
 require 'time_frame/time_frame_splitter'
 require 'time_frame/time_frame_covered'
 require 'time_frame/time_frame_overlaps'

data/lib/time_frame/empty.rb

@@ -0,0 +1,50 @@
+class TimeFrame
+  # Singleton class for the empty time frame object
+  class Empty < TimeFrame
+    include Singleton
+
+    def duration
+      0
+    end
+
+    def cover?(element)
+      element == EMPTY
+    end
+
+    def empty?
+      true
+    end
+
+    def deviation_of(_)
+      fail TypeError, 'deviation_of is undefined for empty time frame'
+    end
+
+    def &(_other)
+      self
+    end
+
+    def overlaps?(_)
+      false
+    end
+
+    def split_by_interval(_)
+      []
+    end
+
+    def shift_by(_)
+      fail TypeError, 'can\'t shift empty time frame'
+    end
+
+    def shift_to(_)
+      fail TypeError, 'can\'t shift empty time frame'
+    end
+
+    def without(*_)
+      []
+    end
+
+    def inspect
+      'EMPTY'
+    end
+  end
+end

data/lib/time_frame/time_frame.rb

@@ -4,6 +4,8 @@
 class TimeFrame
   attr_reader :min, :max
 
+  EMPTY = Empty.instance
+
   def initialize(args)
     min = args.fetch(:min)
     max = args.fetch(:max, nil) || min + args.fetch(:duration)
@@ -23,18 +25,19 @@ class TimeFrame
 
   def cover?(element)
     if element.respond_to?(:min) && element.respond_to?(:max)
-      return min <= element.min && element.max <= max
+      element.empty? || min <= element.min && element.max <= max
+    else
+      min <= element && element <= max
     end
-    min <= element && element <= max
   end
 
   def deviation_of(item)
-    case
-    when item.respond_to?(:min) && item.respond_to?(:max)
-      [deviation_of(item.min), deviation_of(item.max)].min_by { |a| a.abs }
-    when cover?(item)
+    if item.respond_to?(:min) && item.respond_to?(:max)
+      fail ArgumentError, 'time frame is empty' if item.empty?
+      [deviation_of(item.min), deviation_of(item.max)].min_by(&:abs)
+    elsif cover?(item)
       0
-    when item < min
+    elsif item < min
       item - min
     else
       item - max
@@ -42,7 +45,7 @@ class TimeFrame
   end
 
   def empty?
-    min == max
+    false
   end
 
   def self.union(time_frames, options = {})
@@ -51,20 +54,21 @@ class TimeFrame
 
   def self.intersection(time_frames)
     time_frames.reduce(time_frames.first) do |intersection, time_frame|
-      return unless intersection
       intersection & time_frame
     end
   end
 
   # Returns true if the interior intersect.
   def overlaps?(other)
+    return false if other.duration == 0
     other.max > min && other.min < max
   end
 
   def &(other)
+    return EMPTY if other.empty?
     new_min = [min, other.min].max
     new_max = [max, other.max].min
-    TimeFrame.new(min: new_min, max: new_max) if new_min <= new_max
+    new_min <= new_max ? TimeFrame.new(min: new_min, max: new_max) : EMPTY
   end
 
   def shift_by(duration)
@@ -107,9 +111,6 @@ class TimeFrame
 
   def without_frame(other)
     intersection = self & other
-    # this case is never used up to now (15.03.2013),
-    # since without selects the values correctly
-    return [self] unless intersection
 
     result = []
     if intersection.min > min

data/lib/time_frame/time_frame_covered.rb

@@ -3,11 +3,11 @@ class TimeFrame
   # Getting the covering time frame from a bunch of time_frame's.
   class CoveredFrame
     def initialize(time_frames)
-      @time_frames = time_frames
+      @time_frames = time_frames.reject(&:empty?)
     end
 
     def frame
-      return nil unless @time_frames.any?
+      return EMPTY unless @time_frames.any?
       min = @time_frames.min_by(&:min).min
       max = @time_frames.max_by(&:max).max
       TimeFrame.new(min: min, max: max)

data/lib/time_frame/time_frame_overlaps.rb

@@ -8,16 +8,16 @@ class TimeFrame
   # * requires each of the arrays to be sorted
   class Overlaps
     def initialize(array1, array2)
-      @array1 = array1.dup
-      @array2 = array2.dup
+      @array1 = array1.reject(&:empty?)
+      @array2 = array2.reject(&:empty?)
     end
 
     def each(&block)
       return [] if @array1.empty? || @array2.empty?
-      yield_current_items(&block) if current_items_overlapping?
-      while arrays_have_many_items?
+      yield_current_pair(&block) if current_pair_overlaps?
+      while each_array_has_many_items?
         shift
-        yield_current_items(&block) if current_items_overlapping?
+        yield_current_pair(&block) if current_pair_overlaps?
       end
     end
 
@@ -32,17 +32,16 @@ class TimeFrame
       end
     end
 
-    def arrays_have_many_items?
+    def each_array_has_many_items?
       @array1.many? || @array2.many?
     end
 
-    def yield_current_items
+    def yield_current_pair
       yield @array1.first, @array2.first
     end
 
-    def current_items_overlapping?
-      time_frame = @array1.first & @array2.first
-      time_frame && time_frame.duration > 0
+    def current_pair_overlaps?
+      @array1.first.overlaps? @array2.first
     end
   end
 end

data/lib/time_frame/time_frame_uniter.rb

@@ -4,7 +4,7 @@ class TimeFrame
   # the min Time value.
   class Uniter
     def initialize(time_frames, options = {})
-      @time_frames = time_frames
+      @time_frames = time_frames.reject(&:empty?)
       @sorted = options[:sorted]
     end
 

data/lib/time_frame/version.rb

@@ -1,5 +1,5 @@
 # Encoding: utf-8
 # gem version
 class TimeFrame
-  VERSION = '0.0.6'
+  VERSION = '0.1.0'
 end

data/spec/spec_helper.rb

@@ -1,11 +1,11 @@
 # Encoding: utf-8
-require 'time_frame'
-
 require 'simplecov'
 SimpleCov.start do
   add_filter '/spec/'
 end
 
+require 'time_frame'
+
 Time.zone ||= 'UTC'
 
 require 'rspec'

data/spec/time_frame_spec.rb

@@ -0,0 +1,1098 @@
+# Encoding: utf-8
+require 'spec_helper'
+
+describe TimeFrame do
+  let(:time) { Time.zone.local(2012) }
+  let(:duration) { 2.hours }
+
+  before do
+    # Avoid i18n deprecation warning
+    I18n.enforce_available_locales = true
+  end
+
+  describe '#min and #max' do
+    context 'when given two times' do
+      context 'and min is smaller than max' do
+        subject { TimeFrame.new(min: time, max: time + duration) }
+
+        describe '#min' do
+          subject { super().min }
+          it { should eq time }
+        end
+
+        describe '#max' do
+          subject { super().max }
+          it { should eq time + duration }
+        end
+      end
+      context 'and max is smaller than min' do
+        specify do
+          expect do
+            TimeFrame.new(min: time, max: time - 1.day)
+          end.to raise_error(ArgumentError)
+        end
+      end
+      context 'which are equal' do
+        subject { TimeFrame.new(min: time, max: time) }
+
+        describe '#min' do
+          subject { super().min }
+          it { should eq time }
+        end
+
+        describe '#max' do
+          subject { super().max }
+          it { should eq time }
+        end
+      end
+    end
+
+    context 'when time and duration is given' do
+      context ' and duration is positive' do
+        subject { TimeFrame.new(min: time, duration: 1.hour) }
+
+        describe '#min' do
+          subject { super().min }
+          it { should eq time }
+        end
+
+        describe '#max' do
+          subject { super().max }
+          it { should eq time + 1.hour }
+        end
+      end
+      context 'and duration is negative' do
+        let(:invalid_t_r) { TimeFrame.new(min: time, duration: - 1.hour) }
+        specify { expect { invalid_t_r }.to raise_error }
+      end
+      context 'and duration is 0' do
+        subject { TimeFrame.new(min: time, duration: 0.hour) }
+
+        describe '#min' do
+          subject { super().min }
+          it { should eq time }
+        end
+
+        describe '#max' do
+          subject { super().max }
+          it { should eq time }
+        end
+      end
+      context 'and time sframe covers a DST shift' do
+        let(:time) do
+          Time.use_zone('Europe/Berlin') { Time.zone.local(2013, 10, 27) }
+        end
+        subject { TimeFrame.new(min: time, duration: 1.day) }
+
+        describe '#min' do
+          subject { super().min }
+          it { should eq time }
+        end
+
+        describe '#max' do
+          subject { super().max }
+          it { should eq time + 25.hours }
+        end
+      end
+    end
+
+    specify '#min and #max are nil if time frame is empty' do
+      expect(TimeFrame::EMPTY.min).to be_nil
+      expect(TimeFrame::EMPTY.max).to be_nil
+    end
+  end
+
+  describe '#duration' do
+    context 'when borders are different' do
+      subject { TimeFrame.new(min: time, duration: 2.hours).duration }
+      it { should eq 2.hours }
+    end
+    context 'when borders are equal' do
+      subject { TimeFrame.new(min: time, max: time).duration }
+      it { should eq 0 }
+    end
+    context 'when time frame containts a DST shift' do
+      it 'should gain 1 hour on summer -> winter shifts' do
+        Time.use_zone('Europe/Berlin') do
+          time_frame = TimeFrame.new(min: Time.zone.local(2013, 10, 27),
+                                     max: Time.zone.local(2013, 10, 28))
+          expect(time_frame.duration).to eq 25.hours
+        end
+      end
+      it 'should lose 1 hour on winter -> summer shifts' do
+        Time.use_zone('Europe/Berlin') do
+          time_frame = TimeFrame.new(min: Time.zone.local(2013, 3, 31),
+                                     max: Time.zone.local(2013, 4, 1))
+          expect(time_frame.duration).to eq 23.hours
+        end
+      end
+    end
+    it 'returns 0 when time frame is empty' do
+      expect(TimeFrame::EMPTY.duration).to eq 0
+    end
+  end
+
+  describe '#==' do
+    let(:time_frame) { TimeFrame.new(min: time, duration: 2.hours) }
+    context 'when borders are equal' do
+      let(:other) { TimeFrame.new(min: time, duration: 2.hours) }
+      subject { time_frame == other }
+      it { should be true }
+    end
+    context 'when min value is different' do
+      let(:other) do
+        TimeFrame.new(min: time - 1.hour, max: time + 2.hours)
+      end
+      subject { time_frame == other }
+      it { should be false }
+    end
+    context 'when max value is different' do
+      let(:other) { TimeFrame.new(min: time, duration: 3.hours) }
+      subject { time_frame == other }
+      it { should be false }
+    end
+    it 'returns true when self and the argument are both empty' do
+      expect(TimeFrame::EMPTY).to eq TimeFrame::EMPTY
+    end
+    it 'returns false if argument is empty, but self is not' do
+      expect(
+        TimeFrame.new(min: time, duration: 3.hours)
+      ).not_to eq TimeFrame::EMPTY
+    end
+    it 'returns false if self is empty, but argument is not' do
+      expect(
+        TimeFrame::EMPTY
+      ).not_to eq TimeFrame.new(min: time, duration: 3.hours)
+    end
+  end
+
+  describe '#cover?' do
+    let(:time_frame) { TimeFrame.new(min: time, duration: 4.hours) }
+    context 'when argument is a Time instance' do
+      context 'and its covered' do
+        context 'and equal to min' do
+          subject { time_frame.cover?(time_frame.min) }
+          it { should be true }
+        end
+        context 'and equal to max' do
+          subject { time_frame.cover?(time_frame.max) }
+          it { should be true }
+        end
+        context 'and is an inner value' do
+          subject { time_frame.cover?(time_frame.min + 1.hour) }
+          it { should be true }
+        end
+      end
+      context 'and its not covered' do
+        context 'and smaller than min' do
+          subject { time_frame.cover?(time_frame.min - 1.hour) }
+          it { should be false }
+        end
+        context 'and greater than max' do
+          subject { time_frame.cover?(time_frame.max + 5.hours) }
+          it { should be false }
+        end
+      end
+    end
+    context 'when argument is a TimeFrame' do
+      context 'and its covered' do
+        context 'and they have the same min value' do
+          let(:other) { TimeFrame.new(min: time_frame.min, duration: 2.hours) }
+          subject { time_frame.cover?(other) }
+          it { should be true }
+        end
+        context 'and they have the same max value' do
+          let(:other) do
+            TimeFrame.new(min: time_frame.min + 1.hour, max: time_frame.max)
+          end
+          subject { time_frame.cover?(other) }
+          it { should be true }
+        end
+        context 'and it is within the interior of self' do
+          let(:other) do
+            TimeFrame.new(
+              min: time_frame.min + 1.hour, max: time_frame.max - 1.hour
+            )
+          end
+          subject { time_frame.cover?(other) }
+          it { should be true }
+        end
+        context 'and are equal' do
+          let(:other) { time_frame.clone }
+          subject { time_frame.cover?(other) }
+          it { should be true }
+        end
+      end
+      context 'and it is not covered' do
+        context 'and other is left of self' do
+          let(:other) { time_frame.shift_by(-5.hours) }
+          subject { time_frame.cover?(other) }
+          it { should be false }
+        end
+        context 'and other overlaps left hand side' do
+          let(:other) { time_frame.shift_by(-1.hour) }
+          subject { time_frame.cover?(other) }
+          it { should be false }
+        end
+        context 'and other overlaps left hand side at the border only' do
+          let(:other) { time_frame.shift_by(-time_frame.duration) }
+          subject { time_frame.cover?(other) }
+          it { should be false }
+        end
+        context 'and other is right of self' do
+          let(:other) { time_frame.shift_by(5.hours) }
+          subject { time_frame.cover?(other) }
+          it { should be false }
+        end
+        context 'and other overlaps right hand side' do
+          let(:other) { time_frame.shift_by(1.hours) }
+          subject { time_frame.cover?(other) }
+          it { should be false }
+        end
+        context 'and other overlaps right hand side at the border only' do
+          let(:other) { time_frame.shift_by(time_frame.duration) }
+          subject { time_frame.cover?(other) }
+          it { should be false }
+        end
+      end
+    end
+    it 'returns true when argument is empty' do
+      expect(
+        TimeFrame.new(min: time, duration: 3.hours)
+      ).to cover(TimeFrame::EMPTY)
+    end
+    it 'returns true when self and argument are both empty' do
+      expect(TimeFrame::EMPTY).to cover(TimeFrame::EMPTY)
+    end
+    it 'returns false when only self is empty' do
+      expect(
+        TimeFrame::EMPTY
+      ).not_to cover(TimeFrame.new(min: time, duration: 3.hours))
+    end
+    it 'returns true when only the argument is empty' do
+      expect(
+        TimeFrame.new(min: time, duration: 3.hours)
+      ).to cover(TimeFrame::EMPTY)
+    end
+  end
+
+  describe '#deviation_of' do
+    let(:time_frame) do
+      TimeFrame.new(min: Time.zone.local(2012), duration: 2.days)
+    end
+    context 'when providing a time object' do
+      describe 'when self covers time' do
+        context 'and time equals min' do
+          let(:time) { time_frame.min }
+          subject { time_frame.deviation_of(time) }
+          it { should eq 0.minutes }
+        end
+        context 'and time equals max' do
+          let(:time) { time_frame.max }
+          subject { time_frame.deviation_of(time) }
+          it { should eq 0.minutes }
+        end
+        context 'and time is an interior point of self' do
+          let(:time) { time_frame.min + (time_frame.duration / 2.0) }
+          subject { time_frame.deviation_of(time) }
+          it { should eq 0.minutes }
+        end
+      end
+      context 'when self do not cover time' do
+        context 'and time is smaller than the left bound' do
+          let(:time) { time_frame.min - 42.hours - 42.minutes }
+          subject { time_frame.deviation_of(time) }
+          it { should eq(-42.hours - 42.minutes) }
+        end
+        context 'and time is greater than the right bound' do
+          let(:time) { time_frame.max + 42.hours + 42.minutes }
+          subject { time_frame.deviation_of(time) }
+          it { should eq 42.hours + 42.minutes }
+        end
+      end
+    end
+    context 'when providing a time_frame' do
+      describe 'when self overlaps other' do
+        context 'and its partly' do
+          let(:other) { time_frame.shift_by(time_frame.duration / 2) }
+          subject { time_frame.deviation_of(other) }
+          it { should eq 0.minutes }
+        end
+        context 'and time equals max' do
+          let(:other) { time_frame }
+          subject { time_frame.deviation_of(other) }
+          it { should eq 0.minutes }
+        end
+        context 'and other lies in the interior of self' do
+          let(:other) do
+            TimeFrame.new(min: time_frame.min + 1.hour, duration: 1.hour)
+          end
+          subject { time_frame.deviation_of(other) }
+          it { should eq 0.minutes }
+        end
+      end
+      context 'when self do not cover time' do
+        context 'and time is smaller than the left bound' do
+          let(:other) { time_frame.shift_by(-2.days - 42.seconds) }
+          subject { time_frame.deviation_of(other) }
+          it { should eq(-42.seconds) }
+        end
+        context 'and time is greater than the right bound' do
+          let(:other) { time_frame.shift_by(2.days + 42.seconds) }
+          subject { time_frame.deviation_of(other) }
+          it { should eq 42.seconds }
+        end
+      end
+      it 'fails when only argument is empty' do
+        expect(-> { time_frame.deviation_of(TimeFrame::EMPTY) })
+          .to raise_error ArgumentError
+      end
+      it 'fails when only self is empty' do
+        expect(-> { TimeFrame::EMPTY.deviation_of(time_frame) })
+          .to raise_error TypeError
+      end
+    end
+  end
+
+  describe '#empty?' do
+    it 'returns false when self is not contains at least one point' do
+      expect(TimeFrame.new(min: time, max: time)).not_to be_empty
+    end
+
+    it 'returns true when self is empty' do
+      expect(TimeFrame::EMPTY).to be_empty
+    end
+  end
+
+  describe '.union' do
+
+    context 'when given an empty array' do
+      subject { TimeFrame.union([]) }
+      it { should eq [] }
+    end
+
+    context 'when given a single time frame' do
+      let(:time_frame) { TimeFrame.new(min: time, duration: 1.hour) }
+      subject { TimeFrame.union([time_frame]) }
+      it { should eq [time_frame] }
+    end
+
+    context 'when getting single element it returns a dup' do
+      let(:time_frames) { [TimeFrame.new(min: time, duration: 1.hour)] }
+      subject { TimeFrame.union(time_frames) }
+      it { should_not equal time_frames }
+    end
+
+    context 'when given time frames' do
+      context 'in order' do
+        context 'and no sorted flag is provided' do
+          context 'that are overlapping' do
+            let(:time_frame1) { TimeFrame.new(min: time, duration: 2.hours) }
+            let(:time_frame2) { time_frame1.shift_by(1.hour) }
+            let(:expected) do
+              [TimeFrame.new(min: time_frame1.min, max: time_frame2.max)]
+            end
+            subject { TimeFrame.union([time_frame1, time_frame2]) }
+            it { should eq expected }
+          end
+          context 'that are disjoint' do
+            let(:time_frame1) { TimeFrame.new(min: time, duration: 2.hours) }
+            let(:time_frame2) { time_frame1.shift_by(3.hours) }
+            subject { TimeFrame.union([time_frame1, time_frame2]) }
+            it { should eq [time_frame1, time_frame2] }
+          end
+          context 'that intersect at their boundaries' do
+            let(:time_frame1) { TimeFrame.new(min: time, duration: + 2.hour) }
+            let(:time_frame2) { time_frame1.shift_by(time_frame1.duration) }
+            let(:expected) do
+              [TimeFrame.new(min: time_frame1.min, max: time_frame2.max)]
+            end
+            subject { TimeFrame.union([time_frame1, time_frame2]) }
+            it { should eq expected }
+          end
+        end
+        context 'and the sorted flag is provided' do
+          context 'that are overlapping' do
+            let(:time_frame1) { TimeFrame.new(min: time, duration: 2.hours) }
+            let(:time_frame2) { time_frame1.shift_by(1.hour) }
+            let(:expected) do
+              [TimeFrame.new(min: time_frame1.min, max: time_frame2.max)]
+            end
+            subject do
+              TimeFrame.union([time_frame1, time_frame2], sorted: true)
+            end
+            it { should eq expected }
+          end
+          context 'that are disjoint' do
+            let(:time_frame1) { TimeFrame.new(min: time, duration: 2.hours) }
+            let(:time_frame2) { time_frame1.shift_by(3.hours) }
+            subject do
+              TimeFrame.union([time_frame1, time_frame2], sorted: true)
+            end
+            it { should eq [time_frame1, time_frame2] }
+          end
+          context 'that intersect at their boundaries' do
+            let(:time_frame1) { TimeFrame.new(min: time, duration: + 2.hour) }
+            let(:time_frame2) { time_frame1.shift_by(time_frame1.duration) }
+            let(:expected) do
+              [TimeFrame.new(min: time_frame1.min, max: time_frame2.max)]
+            end
+            subject do
+              TimeFrame.union([time_frame1, time_frame2], sorted: true)
+            end
+            it { should eq expected }
+          end
+        end
+      end
+      context 'not in order' do
+        context 'that are overlapping' do
+          let(:time_frame1) { TimeFrame.new(min: time, duration: 2.hours) }
+          let(:time_frame2) { time_frame1.shift_by(1.hour) }
+          subject { TimeFrame.union([time_frame2, time_frame1]) }
+          it do
+            should eq [
+              TimeFrame.new(min: time_frame1.min, max: time_frame2.max)
+            ]
+          end
+        end
+        context 'that are disjoint' do
+          let(:time_frame1) { TimeFrame.new(min: time, duration: 2.hours) }
+          let(:time_frame2) { time_frame1.shift_by(3.hours) }
+          subject { TimeFrame.union([time_frame2, time_frame1]) }
+          it { should eq [time_frame1, time_frame2] }
+        end
+        context 'that intersect at their boundaries' do
+          let(:time_frame1) { TimeFrame.new(min: time, duration: + 2.hour) }
+          let(:time_frame2) { time_frame1.shift_by(time_frame1.duration) }
+          subject { TimeFrame.union([time_frame2, time_frame1]) }
+          it do
+            should eq [
+              TimeFrame.new(min: time_frame1.min, max: time_frame2.max)
+            ]
+          end
+        end
+      end
+    end
+
+    it 'ignores any empty time frames' do
+      expect(TimeFrame.union([TimeFrame::EMPTY, TimeFrame::EMPTY])).to eq []
+    end
+  end
+
+  describe '.intersection' do
+    it 'returns the intersection of all time frames' do
+      time_frame1 = TimeFrame.new(min: Time.zone.local(2012), duration: 3.days)
+      time_frame2 = time_frame1.shift_by(-1.day)
+      time_frame3 = time_frame1.shift_by(-2.days)
+      expect(TimeFrame.intersection([time_frame1, time_frame2, time_frame3]))
+        .to eq TimeFrame.new(min: Time.zone.local(2012), duration: 1.day)
+    end
+    it 'is empty if the intersection is empty' do
+      time_frame1 = TimeFrame.new(min: Time.zone.local(2012), duration: 1.days)
+      time_frame2 = time_frame1.shift_by(-2.day)
+      time_frame3 = time_frame1.shift_by(-4.days)
+      expect(
+        TimeFrame.intersection([time_frame1, time_frame2, time_frame3])
+      ).to be_empty
+    end
+  end
+
+  describe '#overlaps?' do
+    let(:time_frame) { TimeFrame.new(min: time, duration: 3.hours) }
+    context 'when self is equal to other' do
+      let(:other) { time_frame.clone }
+      subject { time_frame.overlaps?(other) }
+      it { should be true }
+    end
+    context 'when self covers other' do
+      let(:other) do
+        TimeFrame.new(
+          min: time_frame.min + 1.hour, max: time_frame.max - 1.hour
+        )
+      end
+      subject { time_frame.overlaps?(other) }
+      it { should be true }
+    end
+    context 'when other covers self' do
+      let(:other) do
+        TimeFrame.new(
+          min: time_frame.min - 1.hour, max: time_frame.max + 1.hour
+        )
+      end
+      subject { time_frame.overlaps?(other) }
+      it { should be true }
+    end
+    context 'when self begins earlier than other' do
+      context 'and they are disjoint' do
+        let(:other) { time_frame.shift_by(-time_frame.duration - 1.hour) }
+        subject { time_frame.overlaps?(other) }
+        it { should be false }
+      end
+      context 'and they are overlapping' do
+        let(:other) { time_frame.shift_by(-1.hours) }
+        subject { time_frame.overlaps?(other) }
+        it { should be true }
+      end
+      context 'and they intersect at their boundaries' do
+        let(:other) { time_frame.shift_by(-time_frame.duration) }
+        subject { time_frame.overlaps?(other) }
+        it { should be false }
+      end
+    end
+    context 'when other begins earlier than self' do
+      context 'and they are disjoint' do
+        let(:other) { time_frame.shift_by(time_frame.duration + 1.hour) }
+        subject { time_frame.overlaps?(other) }
+        it { should be false }
+      end
+      context 'and they are overlapping' do
+        let(:other) { time_frame.shift_by(1.hours) }
+        subject { time_frame.overlaps?(other) }
+        it { should be true }
+      end
+      context 'and they intersect at their boundaries' do
+        let(:other) { time_frame.shift_by(time_frame.duration) }
+        subject { time_frame.overlaps?(other) }
+        it { should be false }
+      end
+    end
+    it 'returns false when self contains only one point' do
+      singleton_time_frame = TimeFrame.new(min: time, max: time)
+      time_frame = TimeFrame.new(min: time, duration: 1.hour)
+      expect(singleton_time_frame.overlaps?(time_frame)).to be false
+      expect(singleton_time_frame.overlaps?(singleton_time_frame)).to be false
+      expect(singleton_time_frame.overlaps?(TimeFrame::EMPTY)).to be false
+    end
+    it 'returns false when self is empty' do
+      singleton_time_frame = TimeFrame.new(min: time, max: time)
+      time_frame = TimeFrame.new(min: time, duration: 1.hour)
+      expect(TimeFrame::EMPTY.overlaps?(time_frame)).to be false
+      expect(TimeFrame::EMPTY.overlaps?(singleton_time_frame)).to be false
+      expect(TimeFrame::EMPTY.overlaps?(TimeFrame::EMPTY)).to be false
+    end
+    it 'returns false when other contains only one point' do
+      singleton_time_frame = TimeFrame.new(min: time, max: time)
+      time_frame = TimeFrame.new(min: time, duration: 1.hour)
+      expect(time_frame.overlaps?(singleton_time_frame)).to be false
+      expect(singleton_time_frame.overlaps?(singleton_time_frame)).to be false
+      expect(TimeFrame::EMPTY.overlaps?(singleton_time_frame)).to be false
+    end
+    it 'returns false when other is empty' do
+      singleton_time_frame = TimeFrame.new(min: time, max: time)
+      time_frame = TimeFrame.new(min: time, duration: 1.hour)
+      expect(time_frame.overlaps?(TimeFrame::EMPTY)).to be false
+      expect(singleton_time_frame.overlaps?(TimeFrame::EMPTY)).to be false
+      expect(TimeFrame::EMPTY.overlaps?(TimeFrame::EMPTY)).to be false
+    end
+  end
+
+  describe '#&' do
+    let(:time_frame) { TimeFrame.new(min: time, duration: 3.hours) }
+    context 'when self is equal to other' do
+      let(:other) { time_frame.clone }
+      subject { time_frame & other }
+      it { should eq time_frame }
+    end
+    context 'when self covers other' do
+      let(:other) do
+        TimeFrame.new(
+          min: time_frame.min + 1.hour, max: time_frame.max - 1.hour
+        )
+      end
+      subject { time_frame & other }
+      it { should eq other }
+    end
+    context 'when other covers self' do
+      let(:other) do
+        TimeFrame.new(
+          min: time_frame.min - 1.hour, max: time_frame.max + 1.hour
+        )
+      end
+      subject { time_frame & other }
+      it { should eq time_frame }
+    end
+    context 'when self begins earlier than other' do
+      context 'and they are disjoint' do
+        let(:other) { time_frame.shift_by(time_frame.duration + 1.hour) }
+        subject { time_frame & other }
+        it { should be_empty }
+      end
+      context 'and they are overlapping' do
+        let(:other) { time_frame.shift_by(1.hour) }
+        subject { time_frame & other }
+        it { should eq TimeFrame.new(min: other.min, max: time_frame.max) }
+      end
+      context 'and they intersect at their boundaries' do
+        let(:other) { time_frame.shift_by(time_frame.duration) }
+        subject { time_frame & other }
+        it { should eq TimeFrame.new(min: time_frame.max, max: time_frame.max) }
+      end
+    end
+    context 'when other begins earlier than self' do
+      context 'and they are disjoint' do
+        let(:other) { time_frame.shift_by(-time_frame.duration - 1.hour) }
+        subject { time_frame & other }
+        it { should be_empty }
+      end
+      context 'and they are overlapping' do
+        let(:other) { time_frame.shift_by(-1.hour) }
+        subject { time_frame & other }
+        it { should eq TimeFrame.new(min: time_frame.min, max: other.max) }
+      end
+      context 'and they intersect at their boundaries' do
+        let(:other) { time_frame.shift_by(-time_frame.duration) }
+        subject { time_frame & other }
+        it { should eq TimeFrame.new(min: time_frame.min, max: time_frame.min) }
+      end
+    end
+    it 'is empty time frame when self it empty' do
+      expect(TimeFrame::EMPTY & time_frame).to eq TimeFrame::EMPTY
+      expect(TimeFrame::EMPTY & TimeFrame::EMPTY).to eq TimeFrame::EMPTY
+    end
+    it 'is empty time frame when self it not empty and the argument is empty' do
+      expect(time_frame & TimeFrame::EMPTY).to eq TimeFrame::EMPTY
+    end
+  end
+
+  describe '#split_by_interval' do
+    context 'when time frame duration is divisible by interval' do
+      let(:time) { Time.new(2012, 1, 1) }
+      let(:interval) { 1.day }
+      let(:time_frame) do
+        TimeFrame.new(min: time, duration: 7.days)
+      end
+      subject do
+        time_frame.split_by_interval(interval)
+      end
+
+      describe '#size' do
+        subject { super().size }
+        it { should eq 7 }
+      end
+      (0..6).each do |day|
+        it "should have the right borders on day #{day}" do
+          expected = TimeFrame.new(min: time, duration: interval)
+          expect(subject[day]).to eq expected.shift_by(day.days)
+        end
+      end
+    end
+
+    context 'when time frame duration is not divisible by interval' do
+      let(:time) { Time.new(2012, 1, 1) }
+      let(:interval) { 1.day }
+      let(:time_frame) do
+        TimeFrame.new(min: time, duration: 7.days + 12.hours)
+      end
+      subject do
+        time_frame.split_by_interval(interval)
+      end
+
+      describe '#size' do
+        subject { super().size }
+        it { should eq 8 }
+      end
+      (0..6).each do |day|
+        it "should have the right borders on day #{day}" do
+          expected = TimeFrame.new(min: time, duration: interval)
+          expect(subject[day]).to eq expected.shift_by(day.days)
+        end
+      end
+      it 'should have a smaller time_frame at the end' do
+        expected = TimeFrame.new(min: time + 7.days, duration: 12.hours)
+        expect(subject[7]).to eq expected
+      end
+    end
+
+    it 'returns an empty array when self is empty' do
+      expect(TimeFrame::EMPTY.split_by_interval(1.day)).to eq []
+    end
+  end
+
+  describe '#shift_by' do
+    let(:min) { time }
+    let(:max) { time + 2.days }
+    let(:time_frame) { TimeFrame.new(min: min, max: max) }
+    context 'when shifting into the future' do
+      subject { time_frame.shift_by(1.day) }
+
+      describe '#min' do
+        subject { super().min }
+        it { should eq min + 1.day }
+      end
+
+      describe '#max' do
+        subject { super().max }
+        it { should eq max + 1.day }
+      end
+      it { should_not equal time_frame }
+    end
+    context 'when shifting into the past' do
+      subject { time_frame.shift_by(-1.day) }
+
+      describe '#min' do
+        subject { super().min }
+        it { should eq min - 1.day }
+      end
+
+      describe '#max' do
+        subject { super().max }
+        it { should eq max - 1.day }
+      end
+      it { should_not equal time_frame }
+    end
+    context 'when shifting by 0' do
+      subject { time_frame.shift_by(0) }
+
+      describe '#min' do
+        subject { super().min }
+        it { should eq min }
+      end
+
+      describe '#max' do
+        subject { super().max }
+        it { should eq max }
+      end
+      it { should_not equal time_frame }
+    end
+    context 'when shifting back and forth' do
+      subject { time_frame.shift_by(-1.day).shift_by(1.day) }
+
+      describe '#min' do
+        subject { super().min }
+        it { should eq min }
+      end
+
+      describe '#max' do
+        subject { super().max }
+        it { should eq max }
+      end
+      it { should_not equal time_frame }
+    end
+    it 'raises a TypeError when time frame is empty' do
+      expect { TimeFrame::EMPTY.shift_by(1.day) }.to raise_error TypeError
+    end
+  end
+
+  describe '#shift_to' do
+
+    let(:duration) { 1.day }
+    let(:min)      { Time.zone.local(2012, 1, 2) }
+    let(:max)      { min + duration }
+    let(:time_frame)    { TimeFrame.new(min: min, max: max) }
+
+    context 'when shifting to a future time' do
+      let(:destination) { min + duration }
+      subject   { time_frame.shift_to(destination) }
+      it { should_not equal time_frame }
+
+      describe '#min' do
+        subject { super().min }
+        it { should eq destination }
+      end
+
+      describe '#max' do
+        subject { super().max }
+        it { should eq destination + duration }
+      end
+    end
+
+    context 'when shifting to a past time' do
+      let(:destination) { min - duration }
+      subject   { time_frame.shift_to(destination) }
+      it { should_not equal time_frame }
+
+      describe '#min' do
+        subject { super().min }
+        it { should eq destination }
+      end
+
+      describe '#max' do
+        subject { super().max }
+        it { should eq destination + duration }
+      end
+    end
+
+    context 'when shifting to same time' do
+      let(:destination) { min }
+      subject   { time_frame.shift_to(destination) }
+      it { should_not equal time_frame }
+
+      describe '#min' do
+        subject { super().min }
+        it { should eq destination }
+      end
+
+      describe '#max' do
+        subject { super().max }
+        it { should eq destination + duration }
+      end
+    end
+
+    it 'raises a TypeError when time frame is empty' do
+      expect do
+        TimeFrame::EMPTY.shift_to(Time.zone.local(2012, 1, 2))
+      end.to raise_error TypeError
+    end
+  end
+
+  describe '#without' do
+    let(:time_frame) { TimeFrame.new(min: time, duration: 10.hours) }
+    context 'when the arguments do not intersect' do
+      context 'and do not touch the boundaries' do
+        let(:arg) do
+          shift = time_frame.duration + 1.hour
+          [
+            TimeFrame.new(min: time - 2.hours, duration: 1.hour),
+            TimeFrame.new(min: time + shift, duration: 1.hour)
+          ]
+        end
+        subject { time_frame.without(*arg) }
+        it { should eq [time_frame] }
+      end
+      context 'and they touch boundaries' do
+        let(:arg) do
+          [
+            TimeFrame.new(min: time - 1.hour, duration: 1.hour),
+            TimeFrame.new(min: time + time_frame.duration, duration: 1.hour)
+          ]
+        end
+        subject { time_frame.without(*arg) }
+        it { should eq [time_frame] }
+      end
+    end
+    context 'when the arguments intersect' do
+      context 'and the argument time_frames overlaps themself' do
+        let(:arg) do
+          [
+            TimeFrame.new(min: time + 1.hour, duration: 2.hours),
+            TimeFrame.new(min: time + 2.hours, duration: 2.hours)
+          ]
+        end
+        let(:expected) do
+          [
+            TimeFrame.new(min: time_frame.min, duration: 1.hour),
+            TimeFrame.new(min: time + 4.hours, max: time_frame.max)
+          ]
+        end
+        subject { time_frame.without(*arg) }
+        it { should eq expected }
+      end
+      context 'and they cover self' do
+        let(:arg) do
+          duration = 0.5 * time_frame.duration
+          [
+            TimeFrame.new(min: time, duration: duration),
+            TimeFrame.new(min: time + duration, duration: duration)
+          ]
+        end
+        subject { time_frame.without(*arg) }
+        it { should eq [] }
+      end
+      context 'and they overlap at the boundaries' do
+        let(:arg) do
+          shift = time_frame.duration - 1.hour
+          [
+            TimeFrame.new(min: time - 1.hour, duration: 2.hour),
+            TimeFrame.new(min: time + shift, duration: 2.hour)
+          ]
+        end
+        let(:expected) do
+          [
+            TimeFrame.new(min: time_frame.min + 1.hour,
+                          max: time_frame.max - 1.hour)
+          ]
+        end
+        subject { time_frame.without(*arg) }
+        it { should eq expected }
+      end
+      context 'and we have three time_frames in args overlaped by self' do
+        context 'which are sorted' do
+          let(:arg) do
+            [
+              TimeFrame.new(min: time + 1.hour, duration: 2.hour),
+              TimeFrame.new(min: time + 4.hours, duration: 2.hour),
+              TimeFrame.new(min: time + 7.hours, duration: 2.hour)
+            ]
+          end
+          let(:expected) do
+            [
+              TimeFrame.new(min: time, max: time + 1.hour),
+              TimeFrame.new(min: time + 3.hours, max: time + 4.hour),
+              TimeFrame.new(min: time + 6.hours, max: time + 7.hours),
+              TimeFrame.new(min: time + 9.hours, max: time + 10.hours)
+            ]
+          end
+          subject { time_frame.without(*arg) }
+          it { should eq expected }
+        end
+        context 'and they are unsorted' do
+          let(:arg) do
+            [
+              TimeFrame.new(min: time + 4.hours, duration: 2.hour),
+              TimeFrame.new(min: time + 1.hour, duration: 2.hour),
+              TimeFrame.new(min: time + 7.hours, duration: 2.hour)
+            ]
+          end
+          let(:expected) do
+            [
+              TimeFrame.new(min: time, max: time + 1.hour),
+              TimeFrame.new(min: time + 3.hours, max: time + 4.hour),
+              TimeFrame.new(min: time + 6.hours, max: time + 7.hours),
+              TimeFrame.new(min: time + 9.hours, max: time + 10.hours)
+            ]
+          end
+          subject { time_frame.without(*arg) }
+          it { should eq expected }
+        end
+      end
+    end
+
+    it 'returns self (as a singleton array) if there are no arguments' do
+      expect(time_frame.without).to eq [time_frame]
+    end
+
+    it 'returns an empty array if self is empty' do
+      expect(TimeFrame::EMPTY.without(time_frame)).to eq []
+    end
+
+    it 'ignores empty time ranges within the arguments' do
+      expect(time_frame.without(TimeFrame::EMPTY)).to eq [time_frame]
+    end
+  end
+
+  describe '.covering_time_frame_for' do
+
+    context 'for a single time frame' do
+      let(:time_frame) { TimeFrame.new(min: time, duration: 1.hour) }
+      subject { TimeFrame.covering_time_frame_for([time_frame]) }
+      it { should eq time_frame }
+    end
+
+    context 'for multiple time frames' do
+      let(:time_frame1) { TimeFrame.new(min: time, duration: 2.hours) }
+      let(:time_frame2) { time_frame1.shift_by(-1.hour) }
+      let(:time_frame3) { time_frame1.shift_by(3.hours) }
+      subject do
+        TimeFrame.covering_time_frame_for(
+          [time_frame1, time_frame2, time_frame3]
+        )
+      end
+
+      describe '#min' do
+        subject { super().min }
+        it { should eq time_frame2.min }
+      end
+
+      describe '#max' do
+        subject { super().max }
+        it { should eq time_frame3.max }
+      end
+    end
+
+    it 'returns the empty time frame if the array is empty' do
+      expect(TimeFrame.covering_time_frame_for([])).to eq TimeFrame::EMPTY
+    end
+
+    it 'ignores empty time frames' do
+      time_frame = TimeFrame.new(min: time, duration: 2.hours)
+      expect(
+        TimeFrame.covering_time_frame_for([time_frame, TimeFrame::EMPTY])
+      ).to eq time_frame
+    end
+  end
+
+  describe '.each_overlap' do
+
+    # Visualization of example input:
+    #
+    # array1:       |---|-------|   |-------|-----------|
+    # array2:               |-----------|   |---|   |---|   |---|
+    #
+    #               0   1   2   3   4   5   6   7   8   9  10  11
+
+    let(:array1) do
+      [
+        TimeFrame.new(min: time, max: time + 1.hour),
+        TimeFrame.new(min: time + 1.hour, max: time + 3.hours),
+        TimeFrame.new(min: time + 4.hours, max: time + 6.hours),
+        TimeFrame.new(min: time + 6.hours, max: time + 9.hours)
+      ]
+    end
+
+    let(:array2) do
+      [
+        TimeFrame.new(min: time + 2.hours, max: time + 5.hour),
+        TimeFrame.new(min: time + 6.hour, max: time + 7.hours),
+        TimeFrame.new(min: time + 8.hours, max: time + 9.hours),
+        TimeFrame.new(min: time + 10.hours, max: time + 11.hours),
+        TimeFrame::EMPTY
+      ]
+    end
+
+    it 'yields the block for each overlap' do
+      overlaps = []
+      TimeFrame.each_overlap(array1, array2) { |a, b| overlaps << [a, b] }
+      expect(overlaps).to eq [
+        [array1[1], array2[0]],
+        [array1[2], array2[0]],
+        [array1[3], array2[1]],
+        [array1[3], array2[2]]
+      ]
+    end
+
+    it 'still works when switching arguments' do
+      overlaps = []
+      TimeFrame.each_overlap(array2, array1) { |a, b| overlaps << [a, b] }
+      expect(overlaps).to eq [
+        [array2[0], array1[1]],
+        [array2[0], array1[2]],
+        [array2[1], array1[3]],
+        [array2[2], array1[3]]
+      ]
+    end
+
+    it 'works if first array is empty' do
+      overlaps = []
+      TimeFrame.each_overlap([], array2) { |a, b| overlaps << [a, b] }
+      expect(overlaps).to be_empty
+    end
+
+    it 'works if second array is empty' do
+      overlaps = []
+      TimeFrame.each_overlap(array1, []) { |a, b| overlaps << [a, b] }
+      expect(overlaps).to be_empty
+    end
+  end
+
+  describe '#inspect' do
+    it 'works for a TimeFrame with same min and max' do
+      time = Time.now
+      expected = "#{time}..#{time}"
+      tr = TimeFrame.new(min: time, max: time)
+      actual = tr.inspect
+      expect(actual).to eq expected
+    end
+
+    it 'works for a TimeFrame created with min and max' do
+      min = Time.now
+      max = min + 10.minutes
+      expected = "#{min}..#{max}"
+      tr = TimeFrame.new(min: min, max: max)
+      actual = tr.inspect
+      expect(actual).to eq expected
+    end
+
+    it 'works for a TimeFrame created with min and duration' do
+      min = Time.now
+      max = min + 10.minutes
+      expected = "#{min}..#{max}"
+      tr = TimeFrame.new(min: min, duration: 10.minutes)
+      actual = tr.inspect
+      expect(actual).to eq expected
+    end
+
+    it 'is overridden for empty time frames' do
+      expect(TimeFrame::EMPTY.inspect).to eq 'EMPTY'
+    end
+  end
+end