slotter 0.0.2 → 0.0.3

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/features/step_definitions/time_slot_collection_definitions.rb

@@ -0,0 +1,24 @@
+Given /^I have a time slot collection "([^\"]*)"$/ do |name|
+  @time_slot_collections ||= {}
+  @time_slot_collections[name] = TimeSlotCollection.new
+end
+
+Given /^time slot "([^\"]*)" belongs to collection "([^\"]*)"$/ do |slot, collection|
+  @time_slot_collections[collection] << @time_slots[slot]
+end
+
+When /^I merge time slot collections "([^\"]*)" and "([^\"]*)"$/ do |a, b|
+  @result = @time_slot_collections[a].merge(@time_slot_collections[b])
+end
+
+When /^I compress time slot collection "([^\"]*)"$/ do |name|
+  @result = @time_slot_collections[name].compress
+end
+
+Then /^I should have a new collection of ([0-9]+) time slots$/ do |length|
+  @result.time_slots.length.should == length.to_i
+end
+
+Then /^show the result$/ do
+  puts "The result is: \n#{@result}"
+end

data/features/step_definitions/time_slot_definitions.rb

@@ -16,8 +16,8 @@ When /^I split time slot "([^\"]*)" into ([0-9]+) second slots$/ do |name, durat
 end
 
 Then /^I should have a time slot between "([^\"]*)" and "([^\"]*)"$/ do |start, finish|
-  @result.start.should == Chronic.parse(start)
-  @result.finish.should == Chronic.parse(finish)
+  @result.start.should == Chronic.parse("today " + start)
+  @result.finish.should == Chronic.parse("today " + finish)
 end
 
 Then /^I should have an array of ([0-9]+) time slots$/ do |size|
@@ -45,4 +45,12 @@ end
 
 Then /^the array should be empty$/ do
   @result.should be_empty
-end
+end
+
+Then /^"([^\"]*)" and "([^\"]*)" should be disjoint$/ do |a, b|
+  @time_slots[a].disjoint?(@time_slots[b]).should == true
+end
+
+Then /^I should not be able to add "([^\"]*)" to "([^\"]*)"$/ do |a, b|
+  (@time_slots[a] + @time_slots[b]).should == nil
+end

data/features/time_slot_addition.feature

@@ -8,96 +8,82 @@ Feature: Time slot addition
     Given I have a time slot "A" between "10:00" and "11:00"
     And I have a time slot "B" between "10:00" and "11:00"
     When I add time slot "B" to time slot "A"
-    Then I should have an array of 1 time slots
-    Then one should be between "10:00" and "11:00"
+    Then I should have a time slot between "10:00" and "11:00"
   
   # Case 2
   Scenario: Add A.start == B.start
     Given I have a time slot "A" between "10:00" and "11:00"
     And I have a time slot "B" between "10:00" and "12:00"
     When I add time slot "B" to time slot "A"
-    Then I should have an array of 1 time slots
-    Then one should be between "10:00" and "12:00"
+    Then I should have a time slot between "10:00" and "12:00"
   
   # Case 3
   Scenario: Add A.start > B.start and A.finish < B.finish
     Given I have a time slot "A" between "11:00" and "12:00"
     And I have a time slot "B" between "10:00" and "13:00"
     When I add time slot "B" to time slot "A"
-    Then I should have an array of 1 time slots
-    Then one should be between "10:00" and "13:00"
+    Then I should have a time slot between "10:00" and "13:00"
   
   # Case 4
   Scenario: Add A.finish == B.start
     Given I have a time slot "A" between "10:00" and "11:00"
     And I have a time slot "B" between "11:00" and "12:00"
     When I add time slot "B" to time slot "A"
-    Then I should have an array of 1 time slots
-    Then one should be between "10:00" and "12:00"
+    Then I should have a time slot between "10:00" and "12:00"
   
   # Case 5
   Scenario: Add A.start == B.finish
     Given I have a time slot "A" between "11:00" and "12:00"
     And I have a time slot "B" between "10:00" and "11:00"
     When I add time slot "B" to time slot "A"
-    Then I should have an array of 1 time slots
-    Then one should be between "10:00" and "12:00"
+    Then I should have a time slot between "10:00" and "12:00"
   
   # Case 6
   Scenario: Add non-intersecting A.finish < B.start
     Given I have a time slot "A" between "10:00" and "11:00"
     And I have a time slot "B" between "12:00" and "13:00"
-    When I add time slot "B" to time slot "A"
-    Then I should have an array of 1 time slots
-    And one should be between "10:00" and "11:00"
-    And one should be between "12:00" and "13:00"
+    Then "A" and "B" should be disjoint
+    And I should not be able to add "B" to "A"
   
   # Case 7
   Scenario: Add non-intersecting A.start > B.finish
     Given I have a time slot "A" between "12:00" and "13:00"
     And I have a time slot "B" between "10:00" and "11:00"
-    When I add time slot "B" to time slot "A"
-    Then I should have an array of 2 time slots
-    And one should be between "10:00" and "11:00"
-    And one should be between "12:00" and "13:00"
-  
+    Then "A" and "B" should be disjoint
+    And I should not be able to add "B" to "A"
+
   # Case 8
   Scenario: Add A.start == B.start and A.finish > B.finish
     Given I have a time slot "A" between "10:00" and "12:00"
     And I have a time slot "B" between "10:00" and "11:00"
     When I add time slot "B" to time slot "A"
-    Then I should have an array of 1 time slots
-    And one should be between "10:00" and "12:00"
+    Then I should have a time slot between "10:00" and "12:00"
   
   # Case 9
   Scenario: Add A.start < B.start and A.finish == B.finish
     Given I have a time slot "A" between "10:00" and "12:00"
     And I have a time slot "B" between "11:00" and "12:00"
     When I add time slot "B" to time slot "A"
-    Then I should have an array of 1 time slots
-    And one should be between "10:00" and "12:00"
+    Then I should have a time slot between "10:00" and "12:00"
   
   # Case 10
   Scenario: Add A.start < B.start and A.finish > B.finish
     Given I have a time slot "A" between "10:00" and "13:00"
     And I have a time slot "B" between "11:00" and "12:00"
     When I add time slot "B" to time slot "A"
-    Then I should have an array of 1 time slots
-    And one should be between "10:00" and "13:00"
+    Then I should have a time slot between "10:00" and "13:00"
   
   # Case 11
   Scenario: Add a half intersecting time slot (A.finish < B.finish)
     Given I have a time slot "A" between "10:00" and "12:00"
     And I have a time slot "B" between "11:00" and "13:00"
     When I add time slot "B" to time slot "A"
-    Then I should have an array of 1 time slots
-    And one should be between "10:00" and "13:00"
+    Then I should have a time slot between "10:00" and "13:00"
   
   # Case 12
   Scenario: Add a half intersecting time slot (A.start > B.start)
     Given I have a time slot "A" between "11:00" and "13:00"
     And I have a time slot "B" between "10:00" and "12:00"
     When I add time slot "B" to time slot "A"
-    Then I should have an array of 1 time slots
-    And one should be between "10:00" and "13:00"
+    Then I should have a time slot between "10:00" and "13:00"
   

data/features/time_slot_collection_compress.feature

@@ -0,0 +1,19 @@
+Feature: Time slot collection compress
+  In order to compress collections of time slots
+  As a developer
+  I want to be able to compress a time slot collection through code
+
+  Scenario: compress time slot collection
+    Given I have a time slot collection "X"
+    And I have a time slot "A" between "09:00" and "10:00"
+    And I have a time slot "B" between "09:00" and "14:00"
+    And I have a time slot "C" between "15:00" and "16:00"
+    And I have a time slot "D" between "10:00" and "11:00"
+    And time slot "A" belongs to collection "X"
+    And time slot "B" belongs to collection "X"
+    And time slot "C" belongs to collection "X"
+    And time slot "B" belongs to collection "X"
+    When I compress time slot collection "X"
+    Then I should have a new collection of 2 time slots
+    And one should be between "09:00" and "14:00"
+    And one should be between "15:00" and "16:00"

data/features/time_slot_collection_merge.feature

@@ -0,0 +1,22 @@
+Feature: Time slot collection merge
+  In order to merge sets of time slots
+  As a developer
+  I want to be able to merge sets of time slots through code
+  
+  Scenario: merge a set of time slots with another
+    Given I have a time slot collection "X"
+    And I have a time slot collection "Y"
+    And I have a time slot "A" between "09:00" and "10:00"
+    And I have a time slot "B" between "09:00" and "11:00"
+    And I have a time slot "C" between "13:00" and "13:30"
+    And I have a time slot "D" between "13:30" and "17:00"
+    And time slot "A" belongs to collection "X"
+    And time slot "B" belongs to collection "Y"
+    And time slot "C" belongs to collection "Y"
+    And time slot "D" belongs to collection "X"
+    When I merge time slot collections "X" and "Y"
+    Then I should have a new collection of 2 time slots
+    And one should be between "09:00" and "11:00"
+    And one should be between "13:00" and "17:00"
+    
+  

data/lib/slotter.rb

@@ -1,2 +1,3 @@
 $:.unshift File.dirname(__FILE__)
-require 'slotter/time_slot'
+require 'slotter/time_slot'
+require 'slotter/time_slot_collection'

data/lib/slotter/time_slot.rb

@@ -13,9 +13,48 @@ class TimeSlot
     (self.finish - self.start)
   end
   
+  # Returns true if this TimeSlot intersects with <i>other_slot</i> otherwise 
+  # false.
+  def intersects_with?(other_slot)
+    !disjoint?(other_slot)
+  end
+  
+  # Returns true if this TimeSlot does not intersect with <i>other_slot</i> 
+  # otherwise false.
+  def disjoint?(other_slot)
+    (self.start > other_slot.finish) or 
+    (self.finish < other_slot.start)
+  end
+  
+  # Returns true if this TimeSlot contains the <i>other_slot</i> otherwise
+  # false.
+  def contains?(other_slot)
+    (self.contains_start_of?(other_slot) and 
+    self.contains_finish_of?(other_slot))
+  end
+  
+  # Returns true if this TimeSlot is within the <i>other_slot</i> otherwise 
+  # false.
+  def within?(other_slot)
+    other_slot.contains?(self)
+  end
+  
+  # Returns true if this TimeSlot contains the start of <i>other_slot</i> 
+  # otherwise false.
+  def contains_start_of?(other_slot)
+    (self.start < other_slot.start and self.finish > other_slot.start)
+  end
+  
+  # Returns true if this TimeSlot contains the finish of <i>other_slot</i>
+  # otherwise false.
+  def contains_finish_of?(other_slot)
+    (self.start < other_slot.finish and self.finish > other_slot.finish)
+  end
+  
   # Subtraction---Returns a set of new TimeSlot(s) that are the result of 
   # removing the other_slot from this slot.
   def -(other_slot)
+    return self unless other_slot
     # Case 1, Case 2 or Case 3
     if (self.start == other_slot.start and self.finish == other_slot.finish) or
        (self.start == other_slot.start and self.finish < other_slot.finish) or
@@ -50,43 +89,45 @@ class TimeSlot
   end
   
   # Concatenation---Returns a set of new TimeSlot(s) that are the result of
-  # concatenating the other_slot to this slot.
+  # concatenating the other_slot to this slot. Returns nil if the slots are 
+  # disjoint.
   def +(other_slot)
+    return self unless other_slot
     # Case 1
     if self.start == other_slot.start and self.finish == other_slot.finish
-      return [self.clone]
+      return self.clone
     end
     # Case 2 or Case 3
     if (self.start == other_slot.start and self.finish < other_slot.finish) or
        (self.start > other_slot.start and self.finish < other_slot.finish)
-      return [other_slot.clone]
+      return other_slot.clone
     end
     # Case 4
     if self.finish == other_slot.start
-      return [TimeSlot.new(self.start, other_slot.finish)]
+      return TimeSlot.new(self.start, other_slot.finish)
     end
     # Case 5
     if self.start == other_slot.finish
-      return [TimeSlot.new(other_slot.start, self.finish)]
+      return TimeSlot.new(other_slot.start, self.finish)
     end
-    # Case 6 or Case 7
+    # Case 6 or Case 7 (Disjoint)
     if (self.finish < other_slot.start) or
        (self.start > other_slot.finish)
-      return [self.clone, other_slot.clone].sort!
+       return nil
     end
     # Case 8, Case 9 or Case 10
     if (self.start == other_slot.start and self.finish > other_slot.finish) or
        (self.start < other_slot.start and self.finish == other_slot.finish) or
        (self.start < other_slot.start and self.finish > other_slot.finish)
-      return [self.clone]
+      return self.clone
     end
     # Case 11
     if self.start < other_slot.start and self.finish < other_slot.finish and self.finish > other_slot.start
-      return [TimeSlot.new(self.start, other_slot.finish)]
+      return TimeSlot.new(self.start, other_slot.finish)
     end
     # Case 12
     if self.start > other_slot.start and self.finish > other_slot.finish and self.start < other_slot.finish
-      return [TimeSlot.new(other_slot.start, self.finish)]
+      return TimeSlot.new(other_slot.start, self.finish)
     end
   end
   

data/lib/slotter/time_slot_collection.rb

@@ -0,0 +1,74 @@
+# A TimeSlotCollection object holds a collection of TimeSlot objects
+class TimeSlotCollection
+  attr_reader :time_slots
+  
+  # Returns a new collection of time slots where the default is empty.
+  def initialize(time_slots = [])
+    @time_slots = Array.new(time_slots)
+  end
+  
+  # Append---Pushes <i>slot</i> to the end of the internal collection of
+  # <i>time_slots</i> if <i>slot</i> is not already a part of it. This 
+  # expression returns <i>self</i>, so several appends may be chained together.
+  def <<(slot)
+    @time_slots << slot unless @time_slots.include?(slot)
+    return self
+  end
+  
+  # Returns a new collection that contains all slots from <i>self</i> and
+  # <i>other_collection</i>.
+  def union(other_collection)
+    result = self.clone
+    for slot in other_collection.time_slots
+      result << slot
+    end
+    return result
+  end
+  
+  # Returns a copy of <i>self</i> where all intersecting slots have been
+  # joined.
+  #
+  # x = [09:00 to 13:00, 12:00 to 14:00]
+  #
+  # x.compress #=> [09:00 to 14:00]
+  #
+  def compress
+    result = TimeSlotCollection.new
+    for slot_a in @time_slots
+      current_slot = slot_a
+      for slot_b in @time_slots
+        current_slot += slot_b unless current_slot.disjoint?(slot_b)
+      end
+      result << current_slot
+    end
+    return result
+  end
+  
+  # Joins all intersecting slots in time_slots. Returns nil if no changes
+  # where made.
+  def compress!
+    result = self.compress.time_slots
+    (result == @time_slots)? nil : self
+  end
+  
+  # Creates a new collection that contains the compressed union of 
+  # <i>self</i>.time_slots and <i>other_collection</i>.time_slots.
+  def merge(other_collection)
+    self.union(other_collection).compress
+  end
+  
+  # Calls <i>block</i> once for each element in <i>self</i>.time_slots, passing
+  # that element as a parameter.
+  def each(&block)
+    for slot in time_slots
+      yield(slot)
+    end
+  end
+  
+  alias :+ :merge
+  
+  # Returns <i>self</i>.time_slots.to_s
+  def to_s
+    "#{@time_slots}"
+  end
+end

data/slotter.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{slotter}
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Bjarki Gudlaugsson"]
-  s.date = %q{2009-11-01}
+  s.date = %q{2009-11-03}
   s.description = %q{the gem allows you to perform operations like addition, subtraction and splitting on time slots}
   s.email = %q{bjarkigud@gmail.com}
   s.extra_rdoc_files = [
@@ -25,14 +25,18 @@ Gem::Specification.new do |s|
      "VERSION",
      "features/case_subtraction.txt",
      "features/cases_addition.txt",
+     "features/step_definitions/time_slot_collection_definitions.rb",
      "features/step_definitions/time_slot_definitions.rb",
      "features/support/env.rb",
      "features/time_slot_addition.feature",
+     "features/time_slot_collection_compress.feature",
+     "features/time_slot_collection_merge.feature",
      "features/time_slot_intersection.feature",
      "features/time_slot_split.feature",
      "features/time_slot_subtraction.feature",
      "lib/slotter.rb",
      "lib/slotter/time_slot.rb",
+     "lib/slotter/time_slot_collection.rb",
      "slotter.gemspec",
      "spec/spec.opts",
      "spec/spec_helper.rb",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: slotter
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Bjarki Gudlaugsson
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-01 00:00:00 +00:00
+date: 2009-11-03 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -60,14 +60,18 @@ files:
 - VERSION
 - features/case_subtraction.txt
 - features/cases_addition.txt
+- features/step_definitions/time_slot_collection_definitions.rb
 - features/step_definitions/time_slot_definitions.rb
 - features/support/env.rb
 - features/time_slot_addition.feature
+- features/time_slot_collection_compress.feature
+- features/time_slot_collection_merge.feature
 - features/time_slot_intersection.feature
 - features/time_slot_split.feature
 - features/time_slot_subtraction.feature
 - lib/slotter.rb
 - lib/slotter/time_slot.rb
+- lib/slotter/time_slot_collection.rb
 - slotter.gemspec
 - spec/spec.opts
 - spec/spec_helper.rb