time_frame 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3a7329ea6aa8db160440c921d298bb8037194707
-  data.tar.gz: 445018532eec6574f3c254f388b11162d34a23af
+  metadata.gz: 36e147ffd05688d225d98d98b03df2055f8705fa
+  data.tar.gz: 52ce6f9719d59c49101b5eae4c25efa6f6bb90af
 SHA512:
-  metadata.gz: eef4ffa1fbc1a5bf4154582445d7dea4fcae7e21f3b6c019651c4d8e4bb2562180017c629f50669c2d671c549b66ab05f4792f88285296158c5a909791636a00
-  data.tar.gz: 08d510eb2c5b59d6eec01334183d582b44c93d623c75dd3f98db55817d915f339d829fc9ced18fe667239038abe3da6440a62b2d8ccbf9985295245cc0293256
+  metadata.gz: 8324b87fa0ad4685d2d793922f2a45923f16bad5fd2582534ad0df5ad9fa4bb77669cb79521836506c79e17b9dad0fc74a1af8e822c5e28fcb30a13fbc07042a
+  data.tar.gz: 3ffca269f990f2ecfe62d2beed4ac25bf5592b749ff0e71fb4aef019ff24741f6b25f231edde6c89ffc55d70abcc903b69e1a229db0c44084012d56522f584a8

data/Guardfile

@@ -0,0 +1,24 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml|\.slim)$})          { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml|slim)$})     { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/lib/time_frame/empty.rb

@@ -15,8 +15,8 @@ class TimeFrame
       true
     end
 
-    def deviation_of(_)
-      fail TypeError, 'deviation_of is undefined for empty time frame'
+    def time_between(_)
+      fail TypeError, 'time_between is undefined for empty time frame'
     end
 
     def &(_other)

data/lib/time_frame/time_frame.rb

@@ -1,4 +1,8 @@
 # Encoding: utf-8
+
+# Temporary disable class length cop.
+# rubocop:disable Style/ClassLength
+
 # The time frame class provides an specialized and enhanced range for time
 # values.
 class TimeFrame
@@ -24,23 +28,42 @@ class TimeFrame
   end
 
   def cover?(element)
-    if element.respond_to?(:min) && element.respond_to?(:max)
+    if rangy?(element)
       element.empty? || min <= element.min && element.max <= max
     else
       min <= element && element <= max
     end
   end
 
-  def deviation_of(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)
+  def before?(item)
+    case
+    when rangy?(item)
+      fail_if_empty item
+      item.min > max
+    else
+      item > max
+    end
+  end
+
+  def after?(item)
+    case
+    when rangy?(item)
+      fail_if_empty item
+      item.max < min
+    else
+      item < min
+    end
+  end
+
+  def time_between(item)
+    case
+    when rangy?(item)
+      fail_if_empty item
+      [time_between(item.min), time_between(item.max)].min_by(&:abs)
+    when cover?(item)
       0
-    elsif item < min
-      item - min
     else
-      item - max
+      [(item - min).abs, (item - max).abs].min
     end
   end
 
@@ -124,7 +147,18 @@ class TimeFrame
 
   private
 
+  def fail_if_empty(item)
+    fail ArgumentError, 'time frame is empty' if item.respond_to?(:empty) &&
+        item.empty?
+  end
+
+  def rangy?(item)
+    item.respond_to?(:min) && item.respond_to?(:max)
+  end
+
   def check_bounds(max, min)
     fail ArgumentError, 'min is greater than max.' if min > max
   end
 end
+
+# rubocop:enable Style/ClassLength

data/lib/time_frame/version.rb

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

data/spec/time_frame_spec.rb

@@ -276,7 +276,7 @@ describe TimeFrame do
     end
   end
 
-  describe '#deviation_of' do
+  describe '#time_between' do
     let(:time_frame) do
       TimeFrame.new(min: Time.zone.local(2012), duration: 2.days)
     end
@@ -284,29 +284,29 @@ describe TimeFrame do
       describe 'when self covers time' do
         context 'and time equals min' do
           let(:time) { time_frame.min }
-          subject { time_frame.deviation_of(time) }
+          subject { time_frame.time_between(time) }
           it { should eq 0.minutes }
         end
         context 'and time equals max' do
           let(:time) { time_frame.max }
-          subject { time_frame.deviation_of(time) }
+          subject { time_frame.time_between(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) }
+          subject { time_frame.time_between(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) }
+          subject { time_frame.time_between(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) }
+          subject { time_frame.time_between(time) }
           it { should eq 42.hours + 42.minutes }
         end
       end
@@ -315,40 +315,40 @@ describe TimeFrame 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) }
+          subject { time_frame.time_between(other) }
           it { should eq 0.minutes }
         end
         context 'and time equals max' do
           let(:other) { time_frame }
-          subject { time_frame.deviation_of(other) }
+          subject { time_frame.time_between(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) }
+          subject { time_frame.time_between(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) }
+          subject { time_frame.time_between(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) }
+          subject { time_frame.time_between(other) }
           it { should eq 42.seconds }
         end
       end
       it 'fails when only argument is empty' do
-        expect(-> { time_frame.deviation_of(TimeFrame::EMPTY) })
+        expect(-> { time_frame.time_between(TimeFrame::EMPTY) })
           .to raise_error ArgumentError
       end
       it 'fails when only self is empty' do
-        expect(-> { TimeFrame::EMPTY.deviation_of(time_frame) })
+        expect(-> { TimeFrame::EMPTY.time_between(time_frame) })
           .to raise_error TypeError
       end
     end
@@ -1095,4 +1095,158 @@ describe TimeFrame do
       expect(TimeFrame::EMPTY.inspect).to eq 'EMPTY'
     end
   end
+
+  describe '#before?' do
+    context 'when dealing with Time instances' do
+      it 'returns false if time is before time frame' do
+        time = Time.new(2012, 2, 1)
+        time_frame = TimeFrame.new(min: time, duration: 3.hours)
+        some_time = time - 1.hour
+        expect(time_frame.before?(some_time)).to be false
+      end
+
+      it 'returns false if time is on time frame min value' do
+        time_frame = TimeFrame.new(min: time, duration: 3.hours)
+        expect(time_frame.before?(time)).to be false
+      end
+
+      it 'returns false if time is on time frame max value' do
+        time = Time.new(2012, 2, 1)
+        time_frame = TimeFrame.new(min: time - 1.hour, max: time)
+        expect(time_frame.before?(time)).to be false
+      end
+
+      it 'returns false if time is covered by time frame' do
+        time = Time.new(2012, 2, 1)
+        time_frame = TimeFrame.new(min: time, duration: 3.hours)
+        some_time = time + 2.hours
+        expect(time_frame.before?(some_time)).to be false
+      end
+
+      it 'returns true if time is behind time frame max value' do
+        time = Time.new(2012, 2, 1)
+        time_frame = TimeFrame.new(min: time, duration: 3.hours)
+        some_time = time + 10.hours
+        expect(time_frame.before?(some_time)).to be true
+      end
+    end
+
+    context 'when dealing with TimeFrame instances' do
+      it 'returns false if time frame in question is before time frame' do
+        time_frame = TimeFrame.new(min: Time.new(2012, 2, 1), duration: 2.hours)
+        other = TimeFrame.new(min: Time.new(2011), duration: 1.hour)
+        expect(time_frame.before?(other)).to be false
+      end
+
+      it 'returns false if time frame in question ends on min value' do
+        time_frame = TimeFrame.new(min: Time.new(2012, 2, 1), duration: 2.hours)
+        other = TimeFrame.new(min: Time.new(2011), max: time_frame.min)
+        expect(time_frame.before?(other)).to be false
+      end
+
+      it 'returns false if time frame in question is covered by frame' do
+        time_frame = TimeFrame.new(min: Time.new(2012, 2, 1), duration: 2.hours)
+        other = TimeFrame.new(
+          min: time_frame.min + 1.hour,
+          max: time_frame.min + 2.hours
+        )
+        expect(time_frame.before?(other)).to be false
+      end
+
+      it 'returns false if time frame in question starts at max' do
+        time_frame = TimeFrame.new(min: Time.new(2012, 2, 1), duration: 2.hours)
+        other = TimeFrame.new(
+          min: time_frame.max,
+          max: time_frame.max + 2.hours
+        )
+        expect(time_frame.before?(other)).to be false
+      end
+
+      it 'returns true if time frame in question lies after time frame' do
+        time_frame = TimeFrame.new(min: Time.new(2012, 2, 1), duration: 2.hours)
+        other = TimeFrame.new(
+          min: time_frame.max + 1.hour,
+          max: time_frame.max + 2.hours
+        )
+        expect(time_frame.before?(other)).to be true
+      end
+    end
+  end
+
+  describe '#after?' do
+    context 'when dealing with Time instances' do
+      it 'returns true if time is before time frame' do
+        time = Time.new(2012, 2, 1)
+        time_frame = TimeFrame.new(min: time, duration: 3.hours)
+        some_time = time - 1.hour
+        expect(time_frame.after?(some_time)).to be true
+      end
+
+      it 'returns false if time is on time frame min value' do
+        time_frame = TimeFrame.new(min: time, duration: 3.hours)
+        expect(time_frame.after?(time)).to be false
+      end
+
+      it 'returns false if time is on time frame max value' do
+        time = Time.new(2012, 2, 1)
+        time_frame = TimeFrame.new(min: time - 1.hour, max: time)
+        expect(time_frame.after?(time)).to be false
+      end
+
+      it 'returns false if time is covered by time frame' do
+        time = Time.new(2012, 2, 1)
+        time_frame = TimeFrame.new(min: time, duration: 3.hours)
+        some_time = time + 2.hours
+        expect(time_frame.after?(some_time)).to be false
+      end
+
+      it 'returns false if time is behind time frame max value' do
+        time = Time.new(2012, 2, 1)
+        time_frame = TimeFrame.new(min: time, duration: 3.hours)
+        some_time = time + 10.hours
+        expect(time_frame.after?(some_time)).to be false
+      end
+    end
+
+    context 'when dealing with TimeFrame instances' do
+      it 'returns false if time frame in question is after time frame' do
+        time_frame = TimeFrame.new(min: Time.new(2012, 2, 1), duration: 2.hours)
+        other = TimeFrame.new(min: Time.new(2014), duration: 1.hour)
+        expect(time_frame.after?(other)).to be false
+      end
+
+      it 'returns false if time frame in question ends on min value' do
+        time_frame = TimeFrame.new(min: Time.new(2012, 2, 1), duration: 2.hours)
+        other = TimeFrame.new(min: Time.new(2011), max: time_frame.min)
+        expect(time_frame.after?(other)).to be false
+      end
+
+      it 'returns false if time frame in question is covered by frame' do
+        time_frame = TimeFrame.new(min: Time.new(2012, 2, 1), duration: 2.hours)
+        other = TimeFrame.new(
+          min: time_frame.min + 1.hour,
+          max: time_frame.min + 2.hours
+        )
+        expect(time_frame.after?(other)).to be false
+      end
+
+      it 'returns false if time frame in question starts at max' do
+        time_frame = TimeFrame.new(min: Time.new(2012, 2, 1), duration: 2.hours)
+        other = TimeFrame.new(
+          min: time_frame.max,
+          max: time_frame.max + 2.hours
+        )
+        expect(time_frame.after?(other)).to be false
+      end
+
+      it 'returns true if time frame in question is before time frame' do
+        time_frame = TimeFrame.new(min: Time.new(2012, 2, 1), duration: 2.hours)
+        other = TimeFrame.new(
+          min: time_frame.min - 10.hours,
+          max: time_frame.min - 5.hours
+        )
+        expect(time_frame.after?(other)).to be true
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: time_frame
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Patrick Derichs
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-16 00:00:00.000000000 Z
+date: 2014-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -109,6 +109,7 @@ files:
 - ".rubocop.yml"
 - ".travis.yml"
 - Gemfile
+- Guardfile
 - README.md
 - Rakefile
 - lib/time_frame.rb