overlaps 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 47f94fb75dd165cd51d32e6e369a80523ae94772
+  data.tar.gz: c7ad701a70c19715d40e81ca981b63014da3eeec
+SHA512:
+  metadata.gz: efce43bad7f10d55ac8c6b76a1e43a31efbd99be2b9fb199320aa57a925520ddbf967ce0ab2e0bf780871ef86968aa9dc2f63677a4fd1aaff91cfb059c2858bd
+  data.tar.gz: 93d01683a5c86dc4470836eb4a17c10512d8008df6b9d79be6ae5c5504cd9ec9e88a30397cf1892ddf167fcde5a2273b00a70fd7a11516a6dd97085777605637

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in overlaps.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ryan Stenberg
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+# Overlaps
+
+The Overlaps module enables a class to either count or find overlaps in an array of:
+1. Range objects
+2. Objects that have start and end point-type attributes that form a valid range.
+
+The main purpose of Overlaps -- given a set of ranges -- is to find all possible overlaps and have information about which ranges belong to/share in a given overlap.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'overlaps'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install overlaps
+
+## Usage
+
+Include the Overlaps module in the class you want to manage overlaps in your application (class Klass; include Overlaps; end).  The class now has access to the count_overlaps and find_overlaps methods (from Overlaps::ClassMethods).
+
+Both methods expect an array of Range objects where the start and end points for each range in the array must all be of the same class.
+    
+    array_of_ranges = [1..100, 25..55, 30..110, 10..27]
+    Klass.count_overlaps(array_of_ranges)
+    Klass.find_overlaps(array_of_ranges)
+
+You may also feed them an array of objects with a hash containing the start point attribute and end point attribute (as symbol or string):
+
+    class ObjWithRange
+      attr_accessor :s, :e
+      def initialize(attrs = {})
+        @s, @e = attrs[:s], attrs[:e]
+      end
+    end
+    
+    array_of_objects = [ObjWithRange.new(s: 1, e: 10), ObjWithRange.new(s: 1, e: 5), ObjWithRange.new(s: 3, e: 6)]
+    Klass.count_overlaps(array_of_objects, start_attr: :s, end_attr: :e)
+    Klass.find_overlaps(array_of_objects, start_attr: 's', end_attr: 'e')
+
+Overlaps::ClassMethods::count_overlaps returns a Fixnum count:
+
+    Klass.count_overlaps(array_of_ranges) => 5
+    
+Overlaps::ClassMethods::find_overlaps returns an array of Overlap objects, where each overlap captures the following (with example output):
+
+  Start Point Value
+  
+    overlap.start_point => 1
+    
+  End Point Value
+  
+    overlap.end_point => 5
+    
+  Range
+  
+    overlap.range => 1..5
+    
+  IDs of Each Range that Shares the Overlap
+  
+    overlap.ids => [0,1]
+    
+Also, you may pass a specific attribute to use as the id.  When an array of Ranges is given, the id is set to the index of range as it appears in the original input array.  When an array of non-Ranges is given, it looks for an :id attribute by default.  If an :id attribute is not found, it falls back to the index of the object as it appears in the original input array.  The following section provides an example of setting the id to a specific object attribute.
+
+## Example Use Case
+Say we had a list of Zombie objects (zombies, where the Zombie class has included Overlaps) with :name, :date_of_birth, and :date_turned_zombie attributes that looked something like this:
+
+    zombies => [#<Zombie:0x2c78220 @name="Bob", @date_of_birth=#<Date: 1920-01-21 ((2422345j,0s,0n),+0s,2299161j)>, @date_turned_zombie=#<Date: 1950-06-20 ((2433453j,0s,0n),+0s,2299161j)>>,
+    #<Zombie:0x2c70e88 @name="Karen", @date_of_birth=#<Date: 1927-03-10 ((2424950j,0s,0n),+0s,2299161j)>, @date_turned_zombie=#<Date: 1950-07-04 ((2433467j,0s,0n),+0s,2299161j)>>,
+    #<Zombie:0x2c69a60 @name="Frank", @date_of_birth=#<Date: 1938-10-15 ((2429187j,0s,0n),+0s,2299161j)>, @date_turned_zombie=#<Date: 1950-11-27 ((2433613j,0s,0n),+0s,2299161j)>>]
+
+ If we wanted to find the overlapping periods where each of them were alive and not yet a zombie, we could call find_overlaps like so:
+ 
+    Zombie.find_overlaps(zombies, start_attr: :date_of_birth, end_attr: :date_turned_zombie, id_attr: :name)
+    => [#<Overlaps::Overlap:0x2f47d10 @start_point=#<Date: 1938-10-15 ((2429187j,0s,0n),+0s,2299161j)>, @end_point=#<Date: 1950-06-20((2433453j,0s,0n),+0s,2299161j)>, @ids=["Bob", "Karen", "Frank"]>,
+    #<Overlaps::Overlap:0x2f47ce0 @start_point=#<Date: 1927-03-10 ((2424950j,0s,0n),+0s,2299161j)>, @end_point=#<Date: 1950-06-20 ((2433453j,0s,0n),+0s,2299161j)>, @ids=["Bob", "Karen"]>,
+    #<Overlaps::Overlap:0x2f47c68 @start_point=#<Date: 1938-10-15 ((2429187j,0s,0n),+0s,2299161j)>, @end_point=#<Date: 1950-07-04 ((2433467j,0s,0n),+0s,2299161j)>, @ids=["Karen", "Frank"]>]
+
+  If we simply wanted to count the number of overlapping periods, we could call count_overlaps like so:
+  
+    Klass.count_overlaps(zombies, start_attr: :date_of_birth, end_attr: :date_turned_zombie) => 3
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/overlaps/end_point.rb

@@ -0,0 +1,9 @@
+require_relative 'point'
+
+module Overlaps
+  class EndPoint < Point
+    def end?
+      true
+    end
+  end
+end

data/lib/overlaps/input_parser.rb

@@ -0,0 +1,46 @@
+module Overlaps
+  module InputParser
+    class MissingParameter < StandardError; end
+    
+    def valid_input?(objects, start_attr = nil, end_attr = nil)
+      raise TypeError, "Expecting an Array object, got a #{objects.class} instead." unless objects.class == Array #Ensure Overlaps is receiving an Array object.
+      classes_in_range = []
+      objects.each do |object|
+        if object.class == Range
+          classes_in_range << object.first.class #Add class of start element to classes_in_range tracker
+          classes_in_range << object.last.class #Add class of end element to classes_in_range tracker
+        else
+          raise MissingParameter unless start_attr && end_attr #The names of the start_attr and end_attr must be passed with an array of ActiveRecord objects
+          classes_in_range << object.send(start_attr.to_sym).class #Add class of start element to classes_in_range tracker
+          classes_in_range << object.send(end_attr.to_sym).class #Add class of end element to classes_in_range tracker
+        end
+        raise TypeError, 'All ranges must share the same class-type for start and end points.' if classes_in_range.uniq.size > 1 #Ensure all range start/ends are of the same class.
+      end
+      true #If we get through each array element, verifying it is both a range and that its start/end points share a class with all the other ranges, return true.
+    end
+    
+    def grab_id(obj, id = nil)
+      id ||= :id
+      obj.respond_to?(id) ? obj.send(id) : nil
+    end
+    
+    def convert_range_to_points(range, id)
+      return StartPoint.new(range.first, id), EndPoint.new(range.last, id)
+    end
+    
+    def parse_input(objects, accessors = {})
+      valid_input?(objects, accessors[:start_attr], accessors[:end_attr])
+      output = []
+      objects.each_with_index do |object, index|
+        id = grab_id(object, accessors[:id_attr]) || index
+        if object.class == Range
+          output << convert_range_to_points(object, id)
+        else
+          range = object.send(accessors[:start_attr])..object.send(accessors[:end_attr])
+          output << convert_range_to_points(range, id)
+        end
+      end
+      output.flatten!.sort_by {|point| point.value}
+    end
+  end
+end

data/lib/overlaps/overlap.rb

@@ -0,0 +1,15 @@
+module Overlaps
+  class Overlap
+    attr_accessor :start_point, :end_point, :ids
+    
+    def initialize(start_point, end_point, ids)
+      @start_point = start_point
+      @end_point = end_point
+      @ids = ids
+    end
+    
+    def range
+      (start_point..end_point)
+    end
+  end
+end

data/lib/overlaps/point.rb

@@ -0,0 +1,18 @@
+module Overlaps
+  class Point
+    attr_accessor :value, :id
+    
+    def initialize(value, id)
+      @value = value
+      @id = id
+    end
+    
+    def start?
+      false
+    end
+    
+    def end?
+      false
+    end
+  end
+end

data/lib/overlaps/start_point.rb

@@ -0,0 +1,9 @@
+require_relative 'point'
+
+module Overlaps
+  class StartPoint < Point
+    def start?
+      true
+    end
+  end
+end

data/lib/overlaps/version.rb

@@ -0,0 +1,3 @@
+module Overlaps
+  VERSION = "0.0.1"
+end

data/lib/overlaps.rb

@@ -0,0 +1,67 @@
+require_relative 'overlaps/version'
+require_relative 'overlaps/input_parser'
+require_relative 'overlaps/start_point'
+require_relative 'overlaps/end_point'
+require_relative 'overlaps/overlap'
+
+require 'date'
+require 'time'
+
+module Overlaps
+  extend Overlaps::InputParser
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    #include Overlaps::InputParser
+    def count_overlaps(input_array)
+      points = Overlaps::parse_input(input_array) if Overlaps::valid_input?(input_array) #Validate array of ranges, then parse into a sorted array of StartPoint and EndPoint objects.
+      overlap_counter = -1 #Starts at negative 1, knowing that the first start element would start the counter at 0.
+      overlap_tally = points.inject(0) do |tally, point|
+        if point.class == StartPoint
+          overlap_counter += 1 #If we run into a start_point, increment the overlap_counter.
+        elsif point.class == EndPoint #If we run into an end point..
+          tally += overlap_counter #Add the current overlap_counter number of overlaps to the overall tally, noting the number of overlaps that are shared with the end point encountered.
+          overlap_counter -= 1 #Decrement the overlap counter, noting that one of the ranges was closed out.
+        end
+        tally
+      end
+    end
+    
+    def find_overlaps(input_array, accessors = {})
+      points = Overlaps::parse_input(input_array, accessors)
+      
+      overlaps = []
+      overlap_counter = -1 #Starts at negative 1, knowing that the first start element would start the counter at 0.
+
+      points.inject([]) do |start_stack, point|
+        if point.class == StartPoint
+          overlap_counter += 1 #If we run into a start_point, increment the overlap_counter.
+          start_stack.push(point)
+        elsif point.class == EndPoint
+          overlaps_to_make = overlap_counter #If we run into an end_point, capture the current overlap counter pre-decrement so we know how many overlaps to construct.
+          overlap_counter -= 1 #If we run into an end_point, decrement the overlap_counter.
+          overlaps << build_overlaps(start_stack.dup, point, overlaps_to_make) #Returns array of overlaps (as hashes) in format {overlap: (start..end), indices: [all start indices]}
+          start_stack.delete_if {|start_point| start_point.id == point.id} #Delete the start element from the start_stack if it was the starting point for the end_point found.
+        end
+        start_stack #Pass the current start_stack back into the inject to keep a running list of starts.
+      end
+      overlaps.flatten! #To end up with a single array of overlap hashes in format {overlap: (start..end), indeces: [all indices of original ranges that cover the given overlap]}
+    end
+    
+    private
+      def build_overlaps(start_stack, end_point, overlaps_to_make)
+        #Take a stack of start points, an end point, and a number of overlaps to make.
+        overlaps = []
+        start_ids = start_stack.map {|start_point| start_point.id} #Map ids for all start points in the stack.
+        overlaps_to_make.times do #Based on the overlap_counter value, we want to build that many overlaps starting with the closest start point to the given end point.
+          #Create overlap with the top of the start stack and given end point, attributing all start ids as sharing the overlap, then pop the start point off of the stack.
+          overlaps << Overlaps::Overlap.new(start_stack.pop.value, end_point.value, start_ids.dup)
+          start_ids.pop #Remove the id from the discarded start point from the list of start point ids.
+        end
+        overlaps
+      end
+  end
+end

data/overlaps.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'overlaps/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "overlaps"
+  spec.version       = Overlaps::VERSION
+  spec.authors       = ["Ryan Stenberg"]
+  spec.email         = ["h0tl33t@gmail.com"]
+  spec.description   = %q{Overlaps enables a class to either count or find overlaps between a set of ranges.}
+  spec.summary       = %q{Overlaps, when included in a class, enables that class to #count_overlaps or #find_overlaps when given an array of Range objects or objects that have start and end point-type attributes.}
+  spec.homepage      = "https://github.com/h0tl33t/overlaps"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/spec/overlaps/end_point_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Overlaps
+  describe EndPoint do
+    subject {EndPoint.new(10, 1)}
+    
+    it {should respond_to(:value)}
+    it {should respond_to(:id)}
+    
+    its(:value) {should == 10}
+    its(:id) {should == 1}
+    
+    it {should_not be_start}
+    it {should be_end}
+  end
+end

data/spec/overlaps/input_parser_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+module Overlaps
+  describe InputParser do
+    subject(:klass) {Class.new {extend InputParser}}
+    let(:valid_range_input) {[(1..10), (1..5), (3..7)]}
+    
+    let(:valid_obj_input) {[ObjectWithRange.new(1, 10, 1), ObjectWithRange.new(1, 5, 2), ObjectWithRange.new(3, 6, 3)] }
+    
+    context '#valid_input?' do
+      context 'raises an error when given' do
+        it 'a non-array object' do
+          expect {klass.valid_input?(Hash.new)}.to raise_error(TypeError)
+        end
+        
+        context 'an array' do
+          context 'of non-Range objects' do
+            it 'without providing the accessor methods for the start and end points' do
+              expect {klass.valid_input?(valid_obj_input)}.to raise_error(InputParser::MissingParameter)
+            end
+            
+            it 'where the class of the start and end points of each object are not all the same' do
+              invalid_obj_input = valid_obj_input << ObjectWithRange.new(4, 'a', 'z')
+              expect {klass.valid_input?(invalid_obj_input, :start_point, :end_point)}.to raise_error(TypeError)
+            end
+          end
+          
+          context 'of Range objects' do
+            it 'where the start and end points of each range are not all the same class' do
+              expect {klass.valid_input?([(1..5), ('a'..'b')])}.to raise_error(TypeError)
+            end
+          end
+        end
+      end
+      
+      context 'returns true when given' do
+        it 'an array of ranges where all start/end points are the same class' do
+          expect(klass.valid_input?(valid_range_input)).to be_true
+        end
+        
+        it 'an array of objects with start and end points that form a valid range and are all of the same class' do
+          expect(klass.valid_input?(valid_obj_input, :start_point, :end_point)).to be_true
+        end
+      end
+    end
+    
+    context '#grab_id' do
+      it 'returns the value of an id attribute if one exists' do
+        obj = ObjectWithRange.new(1, 10, 1)
+        expect(klass.grab_id(obj)).to eq(1)
+      end
+      it 'returns nil if no id attribute is found' do
+        expect(klass.grab_id(Object.new)).to be_nil
+      end
+    end
+    
+    context '#convert_range_to_points' do
+      let(:start_point) {klass.convert_range_to_points(1..10, 1).first}
+      let(:end_point) {klass.convert_range_to_points(1..10, 1).last}
+      
+      context 'returns a start point' do
+        it 'of class StartPoint' do
+          expect(start_point).to be_an_instance_of(StartPoint)
+        end
+        
+        it 'with a value equal to the first value in the range' do
+          expect(start_point.value).to eq(1)
+        end
+        
+        it 'with an id' do
+          expect(start_point.id).to eq(1)
+        end
+      end
+      
+      context 'returns an end point' do
+        it 'of class EndPoint' do
+          expect(end_point).to be_an_instance_of(EndPoint)
+        end
+        
+        it 'with a value equal to the last value in the range' do
+          expect(end_point.value).to eq(10)
+        end
+        
+        it 'with an id' do
+          expect(end_point.id).to eq(1)
+        end
+      end
+    end
+    
+    context '#parse_input' do
+      context 'returns a collection of start and end points when given valid input' do        
+        context 'consisting of non-Range objects' do
+          let(:output) { klass.parse_input(valid_obj_input, {start_attr: :start_point, end_attr: :end_point})}
+          
+          it 'where the collection is an Array' do
+            expect(output).to be_an_instance_of(Array)
+          end
+          
+          it 'where the start points are StartPoint objects' do
+            expect(output.first).to be_an_instance_of(StartPoint)
+          end
+            
+          it 'where the end points are EndPoint objects' do
+            expect(output.last).to be_an_instance_of(EndPoint)
+          end
+
+          it 'where the collection is sorted by the value attribute of each point' do
+            expect(output).to eq(output.sort_by {|point| point.value})
+          end
+          
+          context 'having an id attribute' do
+            it 'where the id of each start point point matches that of its originating object' do
+              expect(output.first.id).to eq(1)
+            end
+            it 'where the id of each end point point matches that of its originating object' do
+              expect(output.last.id).to eq(1)
+            end
+          end
+          
+          context 'not having an id attribute' do
+            let(:valid_obj_input) {[ObjectWithRange.new(1, 10), ObjectWithRange.new(1, 5), ObjectWithRange.new(3, 6)]}
+            it 'where the id of each start point matches the index of its originating object as found in the input array' do
+              expect(output.first.id).to eq(0)
+            end
+            
+            it 'where the id of each end point matches the index of its originating object as found in the input array' do
+              expect(output.last.id).to eq(0)
+            end
+          end
+        end
+        
+        context 'consisting of Range objects' do
+          let(:output) { klass.parse_input(valid_range_input)}
+          
+          it 'where the collection is an Array' do
+            expect(output).to be_an_instance_of(Array)
+          end
+          
+          it 'where the start points are StartPoint objects' do
+            expect(output.first).to be_an_instance_of(StartPoint)
+          end
+            
+          it 'where the end points are EndPoint objects' do
+            expect(output.last).to be_an_instance_of(EndPoint)
+          end
+
+          it 'where the collection is sorted by the value attribute of each point' do
+            expect(output).to eq(output.sort_by {|point| point.value})
+          end
+          
+          it 'where the id of the start points match the index of its originating range as found in the input array' do
+            expect(output.first.id).to eq(0)
+          end
+          
+          it 'where the id of the end points match the index of its originating range as found in the input array' do
+            expect(output.last.id).to eq(0)
+          end
+        end
+      end
+    
+      context 'when given invalid input' do
+        it 'raises an error' do
+          expect {klass.parse_input(['a', 1..5])}.to raise_error #Not sure if I need to specify an error type or if I can leave a general catch-all type 'raise_error' call.
+        end
+      end
+    end
+  end
+end

data/spec/overlaps/overlap_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Overlaps
+  describe Overlap do
+    subject(:overlap) {Overlap.new(5,10,[1,2])}
+    
+    it {should respond_to(:start_point)}
+    it {should respond_to(:end_point)}
+    it {should respond_to(:ids)}
+    
+    its(:start_point) {should == 5}
+    its(:end_point) {should == 10}
+    
+    its(:ids) {should be_an_instance_of(Array)}
+    its(:ids) {should == [1,2]}
+    
+    its(:range) {should == (5..10)}
+  end
+end

data/spec/overlaps/point_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Overlaps
+  describe Point do
+    subject {Point.new(10, 1)}
+    
+    it {should respond_to(:value)}
+    it {should respond_to(:id)}
+    
+    its(:value) {should == 10}
+    its(:id) {should == 1}
+    
+    it {should_not be_start}
+    it {should_not be_end}
+  end
+end

data/spec/overlaps/start_point_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Overlaps
+  describe StartPoint do
+    subject {StartPoint.new(10, 1)}
+    
+    it {should respond_to(:value)}
+    it {should respond_to(:id)}
+    
+    its(:value) {should == 10}
+    its(:id) {should == 1}
+    
+    it {should be_start}
+    it {should_not be_end}
+  end
+end

data/spec/overlaps_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Overlaps do
+  it 'has a version' do
+    expect(Overlaps::VERSION).to_not be_nil
+  end
+  
+  it {should respond_to(:valid_input? )}
+  it {should respond_to(:grab_id)}
+  it {should respond_to(:convert_range_to_points)}
+  it {should respond_to(:parse_input)}
+  
+  context 'included in a class' do
+    subject(:klass) {Class.new {include Overlaps}}
+    
+    let(:date_ranges) {[Date.parse('2013-01-01')..Date.parse('2013-06-30'), Date.parse('2013-02-14')..Date.parse('2013-04-01'), Date.parse('2013-03-01')..Date.parse('2013-12-25'), Date.parse('2013-01-21')..Date.parse('2013-11-04')]}
+    let(:time_ranges) {[Time.parse('8:00AM')..Time.parse('8:00PM'), Time.parse('11:00AM')..Time.parse('5:30PM'), Time.parse('1:00AM')..Time.parse('12:45PM'), Time.parse('12:00PM')..Time.parse('11:00PM')]}
+    let(:float_ranges) {[(1.1..5.9), (3.3..7.1), (0.5..15.9), (6.6..16.6), (5.5..10.2)]}
+    let(:fixnum_ranges) {[(1..100), (25..55), (30..110), (150..175), (10..27)]}
+
+    it {should respond_to(:count_overlaps)}
+    it {should respond_to(:find_overlaps)}
+    
+    context '#count_overlaps' do
+      let(:output) {klass.count_overlaps(fixnum_ranges)}
+      it 'returns a numeric count' do
+        expect(output).to be_an_instance_of(Fixnum)
+      end
+      
+      context 'when given an array of ranges with 5 overlaps' do
+        it 'returns 5' do
+          expect(output).to eq(5)
+        end
+      end
+    end
+    
+    context '#find_overlaps' do
+      context 'given an array of objects having start and end point attributes' do
+        context 'having 3 overlaps' do
+          let(:objects_with_range) {[ObjectWithRange.new(1, 10, 1), ObjectWithRange.new(1, 5, 2), ObjectWithRange.new(3, 6, 3)]}
+          let(:output) {klass.find_overlaps(objects_with_range, {start_attr: :start_point, end_attr: :end_point})}
+          
+          it 'returns output in an array' do
+            expect(output).to be_an_instance_of(Array)
+          end
+          
+          it 'returns a set of Overlap objects' do
+            expect(output.first).to be_an_instance_of(Overlaps::Overlap)
+          end
+          
+          it 'returns 3 overlaps' do
+            expect(output.size).to eq(3)
+          end
+          
+          it 'returns the correct set of overlaps' do
+            expect(output[0].range).to eq(3..5)
+            expect(output[0].ids).to match_array([1,2,3])
+            expect(output[1].range).to eq(1..5)
+            expect(output[1].ids).to match_array([1,2])
+            expect(output[2].range).to eq(3..6)
+            expect(output[2].ids).to match_array([1,3])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'overlaps'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  #config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+class ObjectWithRange
+  attr_accessor :id, :start_point, :end_point
+  def initialize(s, e, i = nil)
+    self.id = i
+    self.start_point = s
+    self.end_point = e
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: overlaps
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ryan Stenberg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Overlaps enables a class to either count or find overlaps between a set
+  of ranges.
+email:
+- h0tl33t@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/overlaps.rb
+- lib/overlaps/end_point.rb
+- lib/overlaps/input_parser.rb
+- lib/overlaps/overlap.rb
+- lib/overlaps/point.rb
+- lib/overlaps/start_point.rb
+- lib/overlaps/version.rb
+- overlaps.gemspec
+- spec/overlaps/end_point_spec.rb
+- spec/overlaps/input_parser_spec.rb
+- spec/overlaps/overlap_spec.rb
+- spec/overlaps/point_spec.rb
+- spec/overlaps/start_point_spec.rb
+- spec/overlaps_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/h0tl33t/overlaps
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: 'Overlaps, when included in a class, enables that class to #count_overlaps
+  or #find_overlaps when given an array of Range objects or objects that have start
+  and end point-type attributes.'
+test_files:
+- spec/overlaps/end_point_spec.rb
+- spec/overlaps/input_parser_spec.rb
+- spec/overlaps/overlap_spec.rb
+- spec/overlaps/point_spec.rb
+- spec/overlaps/start_point_spec.rb
+- spec/overlaps_spec.rb
+- spec/spec_helper.rb