overlaps 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47f94fb75dd165cd51d32e6e369a80523ae94772
-  data.tar.gz: c7ad701a70c19715d40e81ca981b63014da3eeec
+  metadata.gz: 46b462c3111be6a7030d964585b9524a1a3a66d3
+  data.tar.gz: d83b354897aa8693341b732b4daca726413818d6
 SHA512:
-  metadata.gz: efce43bad7f10d55ac8c6b76a1e43a31efbd99be2b9fb199320aa57a925520ddbf967ce0ab2e0bf780871ef86968aa9dc2f63677a4fd1aaff91cfb059c2858bd
-  data.tar.gz: 93d01683a5c86dc4470836eb4a17c10512d8008df6b9d79be6ae5c5504cd9ec9e88a30397cf1892ddf167fcde5a2273b00a70fd7a11516a6dd97085777605637
+  metadata.gz: 86954a9d270c1075497cc8eb7adbb2d9e5ccc87e64960705d8ec4e515486cf9189b23534638e0881f1abd5ddcbed7be9c2139959a7f6cbf7d5c4cae53c5b0fe5
+  data.tar.gz: 415f604c26049c1140f59a31c39db17a87324c7757a55364be5a9b1723bd836af518612d0103d5593f24b37a2d5c9b1bcf16d73bf1cadd08c741ea5eb6592c84

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.DS_Store

data/.rspec

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

data/README.md

@@ -1,10 +1,10 @@
 # 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 Overlaps module provides methods to either find or count overlaps in an array of:
+  1. Range objects
+  2. Range-like objects that have start and end point-type attributes/values 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.
+The main purpose of Overlaps -- given a set of range/range-like objects -- is to find all possible overlaps and have information about which ranges belong to/share in a given overlap.
 
 ## Installation
 
@@ -22,68 +22,63 @@ Or install it yourself as:
 
 ## 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).
+Require the Overlaps module and call either #find or #count.  You can feed them two main types of input:
+
+Array of Range objects where all range start/end points are of the same class:
 
-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)
+    Overlaps.find(array_of_ranges)
+    Overlaps.count(array_of_ranges)
+
+Array of Range-like objects where each object is of the same class and the start and end point attribute/accessors are passed as values in an options hash to the :start and :end keys:
 
-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):
+    PseudoRange = Struct.new(:start_point, :end_point)
 
-    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')
+    array_of_objects = [ PseudoRange.new(1,10), PseudoRange.new(1,5), PseudoRange.new(3,6) ]
+    Overlaps.find(array_of_objects, start: :start_point, end: :end_point)
+    Overlaps.count(array_of_objects, start: :start_point, end: :end_point)
 
-Overlaps::ClassMethods::count_overlaps returns a Fixnum count:
+Overlaps.count 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):
+    Overlaps.count(array_of_ranges) => 5
+
+Overlaps.find 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.
+
+Also, you may pass a specific attribute to use as the id (assign the id attr/accessor to the :id key in the options hash).  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:
+Say we had a list of Zombie objects 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)
+ If we wanted to find the overlapping periods where each of them were alive and not yet a zombie, we could call Overlaps.find like so:
+
+    Overlaps.find(zombies, start: :date_of_birth, end: :date_turned_zombie, id: :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
+
+    Overlaps.count(zombies, start: :date_of_birth, end: :date_turned_zombie) => 3
 
 ## Contributing
 

data/lib/overlaps.rb

@@ -1,5 +1,7 @@
 require_relative 'overlaps/version'
-require_relative 'overlaps/input_parser'
+require_relative 'overlaps/range_collection'
+require_relative 'overlaps/overlap_factory'
+require_relative 'overlaps/pseudo_range'
 require_relative 'overlaps/start_point'
 require_relative 'overlaps/end_point'
 require_relative 'overlaps/overlap'
@@ -8,60 +10,13 @@ require 'date'
 require 'time'
 
 module Overlaps
-  extend Overlaps::InputParser
-  
-  def self.included(base)
-    base.extend(ClassMethods)
+
+  def self.find(ranges, accessors = {})
+    range_collection = Overlaps::RangeCollection.new(ranges, accessors)
+    Overlaps::OverlapFactory.new(range_collection.points).overlaps
   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
+  def self.count(ranges, accessors = {})
+    find(ranges, accessors).size
   end
 end

data/lib/overlaps/overlap.rb

@@ -1,13 +1,13 @@
 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

data/lib/overlaps/overlap_factory.rb

@@ -0,0 +1,64 @@
+module Overlaps
+  class OverlapFactory
+
+    def initialize(points)
+      @count = -1
+      @points = Array(points)
+      @overlaps = []
+    end
+
+    def overlaps
+      build_overlaps_with_points
+      @overlaps
+    end
+
+    private
+
+    def build_overlaps_with_points
+      @points.each { |point| process(point) }
+    end
+
+    def start_points
+      @start_points ||= []
+    end
+
+    def process(point)
+      if point.start?
+        store_start_point(point)
+      elsif point.end?
+        store_end_point(point)
+      end
+    end
+
+    def store_start_point(point)
+      start_points << point
+      @count += 1
+    end
+
+    def store_end_point(point)
+      build_overlap(point)
+      close_out_range(point)
+      @count -= 1
+    end
+
+    def start_ids
+      start_points.map(&:id)
+    end
+
+    def build_overlap(end_point)
+      stack_of_start_points = start_points.dup
+      ids = start_ids
+
+      @count.times do
+        start_point = stack_of_start_points.pop
+        @overlaps << Overlaps::Overlap.new(start_point.value, end_point.value, ids.dup)
+        break if start_point.id == end_point.id
+        ids.pop
+      end
+    end
+
+    def close_out_range(end_point)
+      start_points.delete_if {|start| start.id == end_point.id}
+    end
+  end
+end

data/lib/overlaps/point.rb

@@ -1,18 +1,24 @@
 module Overlaps
   class Point
+    include Comparable
+
     attr_accessor :value, :id
-    
+
     def initialize(value, id)
       @value = value
       @id = id
     end
-    
+
     def start?
       false
     end
-    
+
     def end?
       false
     end
+
+    def <=>(other_point)
+      value <=> other_point.value
+    end
   end
 end

data/lib/overlaps/pseudo_range.rb

@@ -0,0 +1,57 @@
+module Overlaps
+  class PseudoRange
+    attr_accessor :start_point, :end_point, :id
+
+    def initialize(range, accessors = {})
+      verify_input(range, accessors)
+      ensure_points_are_same_class
+      build
+    end
+
+    def points
+      [@start_point, @end_point]
+    end
+
+    def range
+      (@start_point.value..@end_point.value)
+    end
+
+    def type
+      @start_point.value.class
+    end
+
+    private
+
+    def verify_input(range, accessors)
+      if range.is_a?(Range)
+        @start_point = range.first
+        @end_point = range.last
+        @id = accessors.fetch(:index) { raise ArgumentError, 'Must provide the :index key/value option when given a Range object.' }
+      else
+        @start_point = range.send accessors.fetch(:start) { raise ArgumentError, 'Must provide the :start key/value option when given a non-Range object.' }
+        @end_point = range.send accessors.fetch(:end) { raise ArgumentError, 'Must provide the :end key/value option when given a non-Range object.' }
+        @id = determine_id(range, accessors)
+      end
+    end
+
+    def determine_id(range, accessors)
+      method = accessors[:id]
+      if method && range.respond_to?(method)
+        range.send(method)
+      elsif range.respond_to?(:id)
+        range.send(:id)
+      else
+        accessors.fetch(:index)
+      end
+    end
+
+    def ensure_points_are_same_class
+      raise TypeError, 'The start and end points for a PseudoRange must be of the same class.' unless start_point.class == end_point.class
+    end
+
+    def build
+      @start_point = StartPoint.new(@start_point, @id)
+      @end_point = EndPoint.new(@end_point, @id)
+    end
+  end
+end

data/lib/overlaps/range_collection.rb

@@ -0,0 +1,30 @@
+module Overlaps
+  class RangeCollection
+
+    def initialize(range_input, accessors)
+      build(range_input, accessors)
+      ensure_single_class_among_points
+    end
+
+    def ranges
+      @ranges ||= []
+    end
+
+    def points
+      ranges.map(&:points).flatten.sort
+    end
+
+    private
+
+    def build(range_input, accessors)
+      range_input.each_with_index do |range, index|
+        accessors[:index] = index
+        ranges << PseudoRange.new(range, accessors)
+      end
+    end
+
+    def ensure_single_class_among_points
+      raise TypeError, 'All ranges must have a single shared class of start/end point.' unless ranges.map(&:type).uniq.size == 1
+    end
+  end
+end

data/lib/overlaps/version.rb

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

data/overlaps.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   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.description   = %q{Overlaps aids in finding shared overlaps between a set of Range or Range-like objects.}
+  spec.summary       = %q{Overlaps lets you #find or #count overlaps in a given set of Range or Range-like objects.}
   spec.homepage      = "https://github.com/h0tl33t/overlaps"
   spec.license       = "MIT"
 
@@ -20,4 +20,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
 end

data/spec/overlaps/end_point_spec.rb

@@ -1,16 +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
+require 'spec_helper'
+
+module Overlaps
+  describe EndPoint do
+    subject { described_class.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/overlap_factory_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module Overlaps
+  describe OverlapFactory do
+
+    describe "#overlaps" do
+      let(:point1) { double 'point', start?: true, end?: false, id: 0, value: 1 }
+      let(:point2) { double 'point', start?: true, end?: false, id: 1, value: 2 }
+      let(:point3) { double 'point', start?: true, end?: false, id: 2, value: 3 }
+      let(:point4) { double 'point', start?: false, end?: true, id: 2, value: 6 }
+      let(:point5) { double 'point', start?: false, end?: true, id: 1, value: 8 }
+      let(:point6) { double 'point', start?: false, end?: true, id: 0, value: 9}
+      let(:points) { [point1, point2, point3, point4, point5, point6] }
+      let(:overlap1) { double 'overlap1' }
+      let(:overlap2) { double 'overlap2' }
+      subject { described_class.new(points) }
+
+      before do
+        Overlap.stub(:new).with(3, 6, [0,1,2,]).and_return(overlap1)
+        Overlap.stub(:new).with(2, 8, [0,1]).and_return(overlap2)
+      end
+
+      it "returns the correct set of overlaps" do
+        subject.overlaps.should == [overlap1, overlap2]
+      end
+    end
+  end
+end

data/spec/overlaps/overlap_spec.rb

@@ -1,19 +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
+require 'spec_helper'
+
+module Overlaps
+  describe Overlap do
+    subject { described_class.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

@@ -2,15 +2,40 @@ 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}
+    subject { described_class.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 }
+
+    describe "#<=>" do
+      context "when passed a point with a lesser value" do
+        let(:point) { described_class.new(5,1) }
+        it "returns 1" do
+          (subject <=> point).should == 1
+        end
+      end
+
+      context "when passed a point with equal value" do
+        let(:point) { described_class.new(10,1) }
+
+        it "returns 0" do
+          (subject <=> point).should == 0
+        end
+      end
+
+      context "when passed a point of greater value" do
+        let(:point) { described_class.new(20, 1) }
+
+        it "returns -1" do
+          (subject <=> point).should == -1
+        end
+      end
+    end
   end
 end

data/spec/overlaps/pseudo_range_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+module Overlaps
+  describe PseudoRange do
+
+    let(:range) { 1..100 }
+    let(:accessors) { {index: 5} }
+    subject { described_class.new(range, accessors) }
+
+    context "when initialized with a Range object" do
+      context "without an index in the accompanying hash" do
+        it "raises an error" do
+          expect { described_class.new(range) }.to raise_error(ArgumentError)
+        end
+      end
+
+      context "with an index in the accompanying hash" do
+        subject { described_class.new(range, accessors) }
+
+        it "creates a start_point of class Overlaps::StartPoint" do
+          subject.start_point.class == Overlaps::StartPoint
+        end
+
+        it "creates a start point with the index as the id" do
+          subject.start_point.id == 5
+        end
+
+        it "creates an end_point of class Overlaps::EndPoint" do
+          subject.end_point.class == Overlaps::EndPoint
+        end
+
+        it "creates an end point with the index as the id" do
+          subject.end_point.id == 5
+        end
+      end
+    end
+
+    context "when initialized with a non-Range object" do
+      let(:range) { double 'range', start_point: 1, end_point: 100, id: 5 }
+
+      context "without a start accessor in the accompanying hash" do
+        let(:accessors) { {end: :end_point, id: :id} }
+
+        it "raises an error" do
+          expect { described_class.new(range, accessors) }.to raise_error(ArgumentError)
+        end
+      end
+
+      context "without an end accessor in the accompanying hash" do
+        let(:accessors) { {start: :start_point, id: :id} }
+
+        it "raises an error" do
+          expect { described_class.new(range, accessors) }.to raise_error(ArgumentError)
+        end
+      end
+
+      context "where the start and end points are of a different class" do
+        let(:range) { double 'range', start_point: 1, end_point: 'z', id: 5 }
+        let(:accessors) { {start: :start_point, end: :end_point, id: :id} }
+
+        it "raises an error" do
+          expect { described_class.new(range, accessors) }.to raise_error(TypeError)
+        end
+      end
+
+      context "with valid input" do
+        let(:accessors) { {start: :start_point, end: :end_point, id: :id} }
+        subject { described_class.new(range, accessors) }
+
+        context "creates a start point" do
+          it "of class Overlaps::StartPoint" do
+            subject.start_point.class.should == Overlaps::StartPoint
+          end
+
+          it "with the start value of the original range as determined by the start accessor" do
+            subject.start_point.value.should == 1
+          end
+
+          it "with the id from the original object as determined by the id accessor" do
+            subject.start_point.id.should == 5
+          end
+        end
+
+        context "creates an end point" do
+          it "of class Overlaps::EndPoint" do
+            subject.end_point.class.should == Overlaps::EndPoint
+          end
+
+          it "with the start value of the original range as determined by the start accessor" do
+            subject.end_point.value.should == 100
+          end
+
+          it "with the id from the original object as determined by the id accessor" do
+            subject.end_point.id.should == 5
+          end
+        end
+      end
+    end
+
+    describe "#points" do
+      it "returns an array containing the start and end point" do
+        subject.points.should == [subject.start_point, subject.end_point]
+      end
+    end
+
+    describe "#range" do
+      it "returns a Range using the start and end point values" do
+        subject.range.should == (1..100)
+      end
+    end
+
+    describe "#type" do
+      it "returns the class of the start and end point values" do
+        subject.type.should == Fixnum
+      end
+    end
+  end
+end

data/spec/overlaps/range_collection_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module Overlaps
+  describe RangeCollection do
+
+    let(:ranges) { [1..100, 25..75, 50..90] }
+    let(:accessors) { Hash.new }
+    let(:pseudo_range) { double('pseudo_range', points: [1,5], type: :cool) }
+    subject { described_class.new(ranges, accessors) }
+
+    context "when initialized" do
+      it "converts each of the passed ranges to PseudoRange objects before storing" do
+        PseudoRange.stub(new: pseudo_range)
+        PseudoRange.should_receive(:new).exactly(ranges.size).times
+        described_class.new(ranges, accessors)
+      end
+    end
+
+    describe "#ranges" do
+      it "returns an array of PseudoRange objects" do
+        subject.ranges.map(&:class).uniq.should == [PseudoRange]
+      end
+    end
+
+    describe "#points" do
+      it "returns a sorted list of points" do
+        PseudoRange.stub(new: pseudo_range)
+        pseudo_range.should_receive(:points).exactly(ranges.size).times
+        subject.points.should == [1,1,1,5,5,5]
+      end
+    end
+  end
+end

data/spec/overlaps/start_point_spec.rb

@@ -2,15 +2,15 @@ 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}
+    subject { described_class.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

@@ -1,67 +1,44 @@
-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
+require 'spec_helper'
+
+describe Overlaps do
+  it 'has a version' do
+    expect(Overlaps::VERSION).to_not be_nil
+  end
+
+  describe "#find" do
+    let(:ranges) { [1..10, 3..6] }
+    let(:options) { Hash.new }
+    let(:overlaps) { 'overlaps' }
+    let(:overlap_factory) { double 'overlap_factory', overlaps: overlaps}
+    let(:range_collection) { double 'range_collection', points: 'PONITZ!' }
+    let(:overlaps) { double 'overlaps' }
+
+    it "it creates a RangeCollection with provided input" do
+      Overlaps::OverlapFactory.stub(:new => overlap_factory )
+      Overlaps::OverlapFactory.stub(:overlaps)
+      Overlaps::RangeCollection.should_receive(:new).with(ranges, options).and_return(range_collection)
+      subject.find(ranges, options)
+    end
+
+    it "it makes an OverlapsFactory with that RangeCollection" do
+      Overlaps::RangeCollection.stub(:new).with(ranges, options).and_return(range_collection)
+      Overlaps::OverlapFactory.should_receive(:new).with(range_collection.points).and_return(overlap_factory)
+      subject.find(ranges, options)
+    end
+
+    it "it calls overlaps on the created OverlapFactory" do
+      Overlaps::RangeCollection.stub(:new).with(ranges, options).and_return(range_collection)
+      Overlaps::OverlapFactory.stub(:new).with(range_collection.points).and_return(overlap_factory)
+      overlap_factory.should_receive(:overlaps).and_return(overlaps)
+      subject.find(ranges, options)
+    end
+  end
+
+  describe "#count" do
+    let(:ranges) { [1..100, 25..75] }
+
+    it "returns the number of overlaps found" do
+      subject.count(ranges).should == 1
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,29 +1,20 @@
-# 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
+# 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: overlaps
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Ryan Stenberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-22 00:00:00.000000000 Z
+date: 2013-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,8 +38,22 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Overlaps enables a class to either count or find overlaps between a set
-  of ranges.
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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 aids in finding shared overlaps between a set of Range or Range-like
+  objects.
 email:
 - h0tl33t@gmail.com
 executables: []
@@ -54,16 +68,20 @@ files:
 - Rakefile
 - lib/overlaps.rb
 - lib/overlaps/end_point.rb
-- lib/overlaps/input_parser.rb
 - lib/overlaps/overlap.rb
+- lib/overlaps/overlap_factory.rb
 - lib/overlaps/point.rb
+- lib/overlaps/pseudo_range.rb
+- lib/overlaps/range_collection.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_factory_spec.rb
 - spec/overlaps/overlap_spec.rb
 - spec/overlaps/point_spec.rb
+- spec/overlaps/pseudo_range_spec.rb
+- spec/overlaps/range_collection_spec.rb
 - spec/overlaps/start_point_spec.rb
 - spec/overlaps_spec.rb
 - spec/spec_helper.rb
@@ -87,17 +105,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.6
+rubygems_version: 2.0.3
 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.'
+summary: 'Overlaps lets you #find or #count overlaps in a given set of Range or Range-like
+  objects.'
 test_files:
 - spec/overlaps/end_point_spec.rb
-- spec/overlaps/input_parser_spec.rb
+- spec/overlaps/overlap_factory_spec.rb
 - spec/overlaps/overlap_spec.rb
 - spec/overlaps/point_spec.rb
+- spec/overlaps/pseudo_range_spec.rb
+- spec/overlaps/range_collection_spec.rb
 - spec/overlaps/start_point_spec.rb
 - spec/overlaps_spec.rb
 - spec/spec_helper.rb

data/lib/overlaps/input_parser.rb

@@ -1,46 +0,0 @@
-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/spec/overlaps/input_parser_spec.rb

@@ -1,168 +0,0 @@
-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