fat_core 0.0.1

data/spec/lib/kernel_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Kernel do
+  it "should know how to time a block of code" do
+    result = time_it "do something" do
+      (1..10_000_000).each { |k| k * k }
+      "hello"
+    end
+    expect(result).to eq('hello')
+  end
+end

data/spec/lib/numeric_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(File.absolute_path(__FILE__)) + '/../spec_helper.rb'
+
+describe Numeric do
+  it "should properly round up" do
+    236.5555.commas(2).should == '236.56'
+    -236.5555.commas(2).should == '-236.56'
+  end
+
+  it "should properly round down" do
+    236.5512.commas(2).should == '236.55'
+    -236.5512.commas(2).should == '-236.55'
+  end
+
+  it "should place commas properly" do
+    123456789.0123.commas(2).should == '123,456,789.01'
+    -123456789.0123.commas(2).should == '-123,456,789.01'
+  end
+
+  it "should place commas properly with no fraction" do
+    123456789.commas.should == '123,456,789'
+    -123456789.commas.should == '-123,456,789'
+  end
+
+  it "should not place commas in a number with exponent" do
+    123456.789e100.commas.should == '1.23456789e+105'
+  end
+
+  it "should be able to convert itself into an H:M:S string" do
+    expect(60.secs_to_hms).to eq('00:01:00')
+    expect(120.secs_to_hms).to eq('00:02:00')
+    expect(6584.secs_to_hms).to eq('01:49:44')
+    expect(6584.35.secs_to_hms).to eq('01:49:44.35')
+  end
+end

data/spec/lib/period_spec.rb

@@ -0,0 +1,294 @@
+require 'spec_helper'
+
+describe Period do
+  before :each do
+    # Pretend it is this date. Not at beg or end of year, quarter,
+    # month, or week.  It is a Wednesday
+    Date.stub(:today).and_return(Date.parse('2012-07-18'))
+    @test_today = Date.parse('2012-07-18')
+  end
+
+  describe "initialization" do
+
+    it "should be initializable with date strings" do
+      Period.new('2013-01-01', '2013-12-13').should be_instance_of Period
+    end
+
+    it "should be initializable with Dates" do
+      Period.new(Date.parse('2013-01-01'), Date.parse('2013-12-13')).
+        should be_instance_of Period
+    end
+
+    it "should raise a ArgumentError if last > first" do
+      expect {
+        Period.new('2013-01-01', '2012-12-31')
+      }.to raise_error ArgumentError
+    end
+
+    it "should raise a ArgumentError if initialized with invalid date string" do
+      expect {
+        Period.new('2013-01-01', '2013-12-32')
+      }.to raise_error ArgumentError
+      expect {
+        Period.new('2013-13-01', '2013-12-31')
+      }.to raise_error ArgumentError
+    end
+
+    it "should raise a ArgumentError if initialized otherwise" do
+      expect {
+        Period.new(2013-01-01, 2013-12-31)
+      }.to raise_error ArgumentError
+    end
+  end
+
+  describe "class methods" do
+
+    it "should know the days in a chunk sym" do
+      Period.chunk_sym_to_days(:year).should eq(365)
+      Period.chunk_sym_to_days(:quarter).should eq(90)
+      Period.chunk_sym_to_days(:bimonth).should eq(60)
+      Period.chunk_sym_to_days(:month).should eq(30)
+      Period.chunk_sym_to_days(:semimonth).should eq(15)
+      Period.chunk_sym_to_days(:biweek).should eq(14)
+      Period.chunk_sym_to_days(:week).should eq(7)
+      Period.chunk_sym_to_days(:day).should eq(1)
+      Period.chunk_sym_to_days(:irregular).should eq(30)
+      expect {
+        Period.chunk_sym_to_days(:eon)
+      }.to raise_error ArgumentError
+    end
+
+    it "should know the chunk sym for given days but only :year, :quarter, :month" do
+      (356..376).each { |d| Period.days_to_chunk_sym(d).should eq(:year) }
+      (86..96).each { |d| Period.days_to_chunk_sym(d).should eq(:quarter) }
+      (28..31).each { |d| Period.days_to_chunk_sym(d).should eq(:month) }
+      Period.days_to_chunk_sym(7).should eq(:week)
+      Period.days_to_chunk_sym(1).should eq(:day)
+    end
+
+    it "should know what to call a chunk based on its size" do
+      expect(Period.new('2011-01-01', '2011-12-31').chunk_name).to eq('Year')
+      expect(Period.new('2011-01-01', '2011-03-31').chunk_name).to eq('Quarter')
+      expect(Period.new('2011-01-01', '2011-01-31').chunk_name).to eq('Month')
+      expect(Period.new('2011-01-01', '2011-01-07').chunk_name).to eq('Week')
+      expect(Period.new('2011-01-01', '2011-01-01').chunk_name).to eq('Day')
+      expect(Period.new('2011-01-01', '2011-01-21').chunk_name).to eq('Period')
+      # Only size matters, not whether the period begins and ends on
+      # calendar unit boundaries.
+      expect(Period.new('2011-02-11', '2011-03-10').chunk_name).to eq('Month')
+    end
+  end
+
+  describe "instance methods" do
+
+    it "should be able to compare for equality" do
+      pp1 = Period.new('2013-01-01', '2013-12-31')
+      pp2 = Period.new('2013-01-01', '2013-12-31')
+      pp3 = Period.new('2013-01-01', '2013-12-30')
+      (pp1 == pp2).should be_true
+      (pp1 == pp3).should_not be_true
+    end
+
+    it "should be able to convert into a Range" do
+      pp = Period.new('2013-01-01', '2013-12-31')
+      rr = Period.new('2013-01-01', '2013-12-31').to_range
+      rr.should be_instance_of Range
+      rr.first.should eq(pp.first)
+      rr.first.should eq(pp.first)
+    end
+
+    it "should be able to tell if it contains a date" do
+      pp = Period.new('2013-01-01', '2013-12-31')
+      pp.contains?(Date.parse('2013-01-01')).should be_true
+      pp.contains?(Date.parse('2013-07-04')).should be_true
+      pp.contains?(Date.parse('2013-12-31')).should be_true
+      pp.contains?(Date.parse('2012-07-04')).should be_false
+    end
+
+    it "should be able to make a concise period string" do
+      Period.new('2013-01-01', '2013-12-31').to_s.
+        should eq('2013')
+      Period.new('2013-04-01', '2013-06-30').to_s.
+        should eq('2013-2Q')
+      Period.new('2013-03-01', '2013-03-31').to_s.
+        should eq('2013-03')
+      Period.new('2013-03-11', '2013-10-31').to_s.
+        should eq('2013-03-11 to 2013-10-31')
+    end
+
+    # Note in the following that first period must begin within self.
+    it "should be able to chunk into years" do
+      chunks = Period.new('2009-12-15', '2013-01-10').chunks(size: :year)
+      chunks.size.should eq(3)
+      chunks[0].first.iso.should eq('2010-01-01')
+      chunks[0].last.iso.should eq('2010-12-31')
+      chunks[1].first.iso.should eq('2011-01-01')
+      chunks[1].last.iso.should eq('2011-12-31')
+      chunks[2].first.iso.should eq('2012-01-01')
+      chunks[2].last.iso.should eq('2012-12-31')
+    end
+
+    it "should be able to chunk into quarters" do
+      chunks = Period.new('2009-12-15', '2013-01-10').chunks(size: :quarter)
+      chunks.size.should eq(12)
+      chunks[0].first.iso.should eq('2010-01-01')
+      chunks[0].last.iso.should eq('2010-03-31')
+      chunks[1].first.iso.should eq('2010-04-01')
+      chunks[1].last.iso.should eq('2010-06-30')
+      chunks[2].first.iso.should eq('2010-07-01')
+      chunks[2].last.iso.should eq('2010-09-30')
+      chunks.last.first.iso.should eq('2012-10-01')
+      chunks.last.last.iso.should eq('2012-12-31')
+    end
+
+    it "should be able to chunk into bimonths" do
+      chunks = Period.new('2009-12-15', '2013-01-10').chunks(size: :bimonth)
+      chunks.size.should eq(18)
+      chunks[0].first.iso.should eq('2010-01-01')
+      chunks[0].last.iso.should eq('2010-02-28')
+      chunks[1].first.iso.should eq('2010-03-01')
+      chunks[1].last.iso.should eq('2010-04-30')
+      chunks[2].first.iso.should eq('2010-05-01')
+      chunks[2].last.iso.should eq('2010-06-30')
+      chunks.last.first.iso.should eq('2012-11-01')
+      chunks.last.last.iso.should eq('2012-12-31')
+    end
+
+    it "should be able to chunk into months" do
+      chunks = Period.new('2009-12-15', '2013-01-10').chunks(size: :month)
+      chunks.size.should eq(36)
+      chunks[0].first.iso.should eq('2010-01-01')
+      chunks[0].last.iso.should eq('2010-01-31')
+      chunks[1].first.iso.should eq('2010-02-01')
+      chunks[1].last.iso.should eq('2010-02-28')
+      chunks[2].first.iso.should eq('2010-03-01')
+      chunks[2].last.iso.should eq('2010-03-31')
+      chunks.last.first.iso.should eq('2012-12-01')
+      chunks.last.last.iso.should eq('2012-12-31')
+    end
+
+    it "should be able to chunk into semimonths" do
+      chunks = Period.new('2009-12-25', '2013-01-10').chunks(size: :semimonth)
+      chunks.size.should eq(72)
+      chunks[0].first.iso.should eq('2010-01-01')
+      chunks[0].last.iso.should eq('2010-01-15')
+      chunks[1].first.iso.should eq('2010-01-16')
+      chunks[1].last.iso.should eq('2010-01-31')
+      chunks[2].first.iso.should eq('2010-02-01')
+      chunks[2].last.iso.should eq('2010-02-15')
+      chunks.last.first.iso.should eq('2012-12-16')
+      chunks.last.last.iso.should eq('2012-12-31')
+    end
+
+    it "should be able to chunk into biweeks" do
+      chunks = Period.new('2009-12-29', '2013-01-10').chunks(size: :biweek)
+      expect(chunks.size).to be >=(26*3)
+      chunks[0].first.iso.should eq('2010-01-04')
+      chunks[0].last.iso.should eq('2010-01-17')
+      chunks[1].first.iso.should eq('2010-01-18')
+      chunks[1].last.iso.should eq('2010-01-31')
+      chunks[2].first.iso.should eq('2010-02-01')
+      chunks[2].last.iso.should eq('2010-02-14')
+      chunks.last.first.iso.should eq('2012-12-17')
+      chunks.last.last.iso.should eq('2012-12-30')
+    end
+
+    it "should be able to chunk into weeks" do
+      chunks = Period.new('2010-01-01', '2012-12-31').chunks(size: :week)
+      expect(chunks.size).to be >=(52*3)
+      chunks[0].first.iso.should eq('2010-01-04')
+      chunks[0].last.iso.should eq('2010-01-10')
+      chunks[1].first.iso.should eq('2010-01-11')
+      chunks[1].last.iso.should eq('2010-01-17')
+      chunks[2].first.iso.should eq('2010-01-18')
+      chunks[2].last.iso.should eq('2010-01-24')
+      chunks.last.first.iso.should eq('2012-12-24')
+      chunks.last.last.iso.should eq('2012-12-30')
+    end
+
+    it "should be able to chunk into days" do
+      chunks = Period.new('2012-12-28', '2012-12-31').chunks(size: :day)
+      chunks.size.should eq(4)
+      chunks[0].first.iso.should eq('2012-12-28')
+      chunks[0].last.iso.should eq('2012-12-28')
+      chunks[1].first.iso.should eq('2012-12-29')
+      chunks[1].last.iso.should eq('2012-12-29')
+      chunks[2].first.iso.should eq('2012-12-30')
+      chunks[2].last.iso.should eq('2012-12-30')
+      chunks.last.first.iso.should eq('2012-12-31')
+      chunks.last.last.iso.should eq('2012-12-31')
+    end
+
+    it "should not include a partial final chunk by default" do
+      chunks = Period.new('2012-01-01', '2012-03-30').chunks(size: :month)
+      chunks.size.should eq(2)
+    end
+
+    it "should include a partial final chunk if partial_last" do
+      chunks = Period.new('2012-01-01', '2012-03-30').
+        chunks(size: :month, partial_last: true)
+      chunks.size.should eq(3)
+      chunks.last.first.should eq(Date.parse('2012-03-01'))
+      chunks.last.last.should eq(Date.parse('2012-03-30'))
+    end
+
+    it "should include a final chunk beyond end_date if round_up" do
+      chunks = Period.new('2012-01-01', '2012-03-30').
+        chunks(size: :month, round_up_last: true)
+      chunks.size.should eq(3)
+      chunks.last.first.should eq(Date.parse('2012-03-01'))
+      chunks.last.last.should eq(Date.parse('2012-03-31'))
+    end
+
+    it "should not include a partial initial chunk by default" do
+      chunks = Period.new('2012-01-13', '2012-03-31').chunks(size: :month)
+      chunks.size.should eq(2)
+      chunks[0].first.should eq(Date.parse('2012-02-01'))
+      chunks[0].last.should eq(Date.parse('2012-02-29'))
+    end
+
+    it "should include a partial initial chunk by if partial_first" do
+      chunks = Period.new('2012-01-13', '2012-03-31').
+        chunks(size: :month, partial_first: true)
+      chunks.size.should eq(3)
+      chunks[0].first.should eq(Date.parse('2012-01-13'))
+      chunks[0].last.should eq(Date.parse('2012-01-31'))
+    end
+
+    it "should include a final chunk beyond end_date if round_up" do
+      chunks = Period.new('2012-01-01', '2012-03-30').
+        chunks(size: :month, round_up_last: true)
+      chunks.size.should eq(3)
+      chunks.last.first.should eq(Date.parse('2012-03-01'))
+      chunks.last.last.should eq(Date.parse('2012-03-31'))
+    end
+
+    it "should be able to its chunk_sym" do
+      Period.new('2013-01-01', '2013-12-31').chunk_sym.should eq(:year)
+      Period.new('2012-01-01', '2013-12-31').chunk_sym.should_not eq(:year)
+
+      Period.new('2013-04-01', '2013-06-30').chunk_sym.should eq(:quarter)
+      Period.new('2013-04-01', '2013-09-30').chunk_sym.should_not eq(:quarter)
+
+      Period.new('2013-03-01', '2013-04-30').chunk_sym.should eq(:bimonth)
+      Period.new('2013-03-01', '2013-06-30').chunk_sym.should_not eq(:bimonth)
+
+      Period.new('2013-04-01', '2013-04-30').chunk_sym.should eq(:month)
+      Period.new('2013-04-01', '2013-05-30').chunk_sym.should_not eq(:month)
+
+      Period.new('2013-05-16', '2013-05-31').chunk_sym.should eq(:semimonth)
+      Period.new('2013-05-16', '2013-06-30').chunk_sym.should_not eq(:semimonth)
+
+      Period.new('2013-11-04', '2013-11-17').chunk_sym.should eq(:biweek)
+      Period.new('2013-11-04', '2013-11-24').chunk_sym.should_not eq(:biweek)
+
+      Period.new('2013-11-11', '2013-11-17').chunk_sym.should eq(:week)
+      Period.new('2013-11-11', '2013-11-24').chunk_sym.should_not eq(:week)
+
+      Period.new('2013-11-10', '2013-11-10').chunk_sym.should eq(:day)
+      Period.new('2013-11-10', '2013-11-11').chunk_sym.should_not eq(:day)
+
+      Period.new('2013-11-02', '2013-12-16').chunk_sym.should eq(:irregular)
+    end
+  end
+end

data/spec/lib/range_spec.rb

@@ -0,0 +1,246 @@
+require File.dirname(File.absolute_path(__FILE__)) + '/../spec_helper.rb'
+
+describe Range do
+  describe "set operations" do
+    it "should know if it is a subset of another range" do
+      expect((4..8)).to be_subset_of((2..9))
+      expect((4..8)).to be_subset_of((4..8))
+      expect((4..8)).not_to be_subset_of((2..7))
+      expect((4..8)).not_to be_subset_of((5..8))
+      expect((4..8)).not_to be_subset_of((11..20))
+    end
+
+    it "should know if it is a proper subset of another range" do
+      expect((4..8)).to be_proper_subset_of((2..9))
+      expect((4..8)).not_to be_proper_subset_of((4..8))
+      expect((4..8)).not_to be_proper_subset_of((2..7))
+      expect((4..8)).not_to be_proper_subset_of((5..8))
+      expect((4..8)).not_to be_proper_subset_of((11..20))
+    end
+
+    it "should know if it is a superset of another range" do
+      expect((4..8)).to be_superset_of((5..7))
+      expect((4..8)).to be_superset_of((6..8))
+      expect((4..8)).to be_superset_of((4..7))
+      expect((4..8)).to be_superset_of((4..8))
+      expect((4..8)).not_to be_superset_of((2..9))
+      expect((4..8)).not_to be_superset_of((2..8))
+      expect((4..8)).not_to be_superset_of((4..9))
+      expect((4..8)).not_to be_superset_of((8..20))
+      expect((4..8)).not_to be_superset_of((0..4))
+      expect((4..8)).not_to be_superset_of((0..3))
+      expect((4..8)).not_to be_superset_of((9..20))
+    end
+
+    it "should know if it is a superset of another range" do
+      expect((4..8)).to be_proper_superset_of((5..7))
+      expect((4..8)).not_to be_proper_superset_of((6..8))
+      expect((4..8)).not_to be_proper_superset_of((4..7))
+      expect((4..8)).not_to be_proper_superset_of((4..8))
+      expect((4..8)).not_to be_proper_superset_of((2..9))
+      expect((4..8)).not_to be_proper_superset_of((2..8))
+      expect((4..8)).not_to be_proper_superset_of((4..9))
+      expect((4..8)).not_to be_proper_superset_of((8..20))
+      expect((4..8)).not_to be_proper_superset_of((0..4))
+      expect((4..8)).not_to be_proper_superset_of((0..3))
+      expect((4..8)).not_to be_proper_superset_of((9..20))
+    end
+
+    it "should know its intersection with another range" do
+      ((0..10) & (5..20)).should eq((5..10))
+      ((0..10) & (5..20)).should eq((5..20) & (0..10))
+      ((0..10) & (10..20)).should eq((10..10))
+    end
+
+    it "intersection should return nil if there is no overlap" do
+      ((0..10) & (15..20)).should be_nil
+    end
+
+    it "should know its union with another range" do
+      ((0..10) + (5..20)).should eq((0..20))
+      ((0..10) + (5..20)).should eq((5..20) + (0..10))
+      ((0..10) + (10..20)).should eq((0..20))
+    end
+
+    it "union should return nil if there is no overlap" do
+      ((0..10) & (15..20)).should be_nil
+    end
+
+    it "should know the difference with another range" do
+      # Other is same as self
+      expect(((4..10) - (4..10)).size).to eq(0)
+      expect(((4..10) - (4..10))).to be_empty
+
+      # Other is proper subset of self
+      expect(((4..10) - (6..7)).first).to eq((4..5))
+      expect(((4..10) - (6..7)).last).to eq((8..10))
+      expect(((4..10) - (6..10)).first).to eq((4..5))
+      expect(((4..10) - (4..7)).last).to eq((8..10))
+
+      # Other overlaps on the left
+      expect(((4..10) - (0..6)).size).to eq(1)
+      expect(((4..10) - (0..6)).first).to eq((7..10))
+
+      expect(((4..10) - (4..6)).size).to eq(1)
+      expect(((4..10) - (4..6)).first).to eq((7..10))
+
+      # Other overlaps on the right
+      expect(((4..10) - (7..11)).size).to eq(1)
+      expect(((4..10) - (7..11)).first).to eq((4..6))
+
+      expect(((4..10) - (7..10)).size).to eq(1)
+      expect(((4..10) - (7..10)).last).to eq((4..6))
+
+      # Other does not overlap
+      expect((4..10) - (13..20)).to be_empty
+      expect((4..10) - (1..3)).to be_empty
+    end
+  end
+
+  describe "joining" do
+    it "should be able to join contiguous ranges" do
+      (0..3).join(4..8).should == (0..8)
+    end
+
+    it "should return nil on join of non-contiguous ranges" do
+      (0..3).join(5..8).should be_nil
+      (0...3).join(4..8).should be_nil
+    end
+
+    it "should work with Floats, allowing single-point overlap" do
+      (0.0..3.0).join(3.0..8.2).should == (0.0..8.2)
+    end
+  end
+
+  describe "spanning" do
+    it "should be able to determine whether it is spanned by a set of ranges" do
+      (0..10).should be_spanned_by([(0..3), (4..6), (7..10)])
+    end
+
+    it "should be determine that overlapping ranges do not span" do
+      (0..10).should_not be_spanned_by([(0..3), (3..6), (7..10)])
+    end
+
+    it "should allow spanning ranges to be any Enumerable" do
+      require 'set'
+      set = [(0..3), (4..6), (7..10)].to_set
+      (0..10).should be_spanned_by(set)
+      set = [(0...3), (4..6), (7..10)].to_set
+      (0..10).should_not be_spanned_by(set)
+    end
+
+    it "should allow the spanning set to be wider than itself" do
+      set = [(0..3), (4..6), (7..10)].to_set
+      (2..8).should be_spanned_by(set)
+      (5..6).should be_spanned_by(set)
+    end
+  end
+
+  describe "overlapping a single range" do
+    it "should know if another range overlaps it" do
+      (0..10).overlaps?(-3..5).should be_true
+      (0..10).overlaps?(3..5).should be_true
+      (0..10).overlaps?(8..15).should be_true
+      (0..10).overlaps?(0..10).should be_true
+      (0..10).overlaps?(11..12).should be_false
+      (0..10).overlaps?(-11..-1).should be_false
+    end
+
+    it "should be able to determine whether a set contains covered overlaps" do
+      (0..10).should have_overlaps_within([(0..3), (2..6), (7..10)])
+    end
+
+    it "should not care about overlaps outside range" do
+      (11..15).should_not have_overlaps_within([(0..3), (2..6), (7..10)])
+    end
+
+    it "should not count contiguous ranges as overlapping" do
+      (0..10).should_not have_overlaps_within([(0..3), (4..6), (7..10)])
+    end
+
+    it "should not count non-contiguous ranges as overlapping" do
+      (0..10).should_not have_overlaps_within([(0..3), (4..6), (8..10)])
+    end
+
+    it "should not count an empty set as overlapping" do
+      (0..10).should_not have_overlaps_within([])
+    end
+  end
+
+  describe "coverage gaps" do
+    it "should return an empty array if ranges completely cover" do
+      (0..10).gaps([(-1..3), (4..8), (9..11)]).should be_empty
+    end
+
+    it "should return array for itself if ranges are empty" do
+      (0..10).gaps([]).should eq([(0..10)])
+    end
+
+    it "should return an array of gaps" do
+      gaps = (0..10).gaps([(0..3), (5..6), (9..10)])
+      gaps[0].should eq((4..4))
+      gaps[1].should eq((7..8))
+    end
+
+    it "should allow ranges to extend before and after self" do
+      gaps = (0..10).gaps([(-3..3), (4..6), (7..13)])
+      gaps.should be_empty
+    end
+
+    it "should return an gaps at beginning and end" do
+      gaps = (0..10).gaps([(2..3), (4..6), (7..8)])
+      gaps[0].should eq((0..1))
+      gaps[1].should eq((9..10))
+    end
+
+    it "should work even if ranges are out of order" do
+      gaps = (0..10).gaps([(2..3), (7..8), (4..6)])
+      gaps[0].should eq((0..1))
+      gaps[1].should eq((9..10))
+    end
+
+    it "should work even if ranges overlap" do
+      gaps = (0..10).gaps([(-2..3), (2..8), (4..10)])
+      gaps.should be_empty
+    end
+  end
+
+  describe "coverage overlaps" do
+    it "should return an empty array if ranges are empty" do
+      (0..10).overlaps([]).should be_empty
+    end
+
+    it "should return an empty array if ranges is same as self" do
+      (0..10).overlaps([(0..10)]).should be_empty
+    end
+
+    it "should return an empty array if ranges is wider than self" do
+      (0..10).overlaps([(-5..15)]).should be_empty
+    end
+
+    it "should return an empty array if ranges is narrower than self" do
+      (0..10).overlaps([(5..8)]).should be_empty
+    end
+
+    it "should return an array of overlaps" do
+      overlaps = (0..10).overlaps([(0..3), (2..6), (4..10)])
+      overlaps.size.should eq(2)
+      overlaps[0].should eq((2..3))
+      overlaps[1].should eq((4..6))
+    end
+
+    it "should not return any overlaps before self" do
+      overlaps = (0..10).overlaps([(-5..-3), (-4..-1), (0..3), (2..6), (4..10)])
+      overlaps.size.should eq(2)
+      overlaps[0].should eq((2..3))
+      overlaps[1].should eq((4..6))
+    end
+
+    it "should not return any overlaps after self" do
+      overlaps = (0..10).overlaps([(0..3), (2..6), (4..15), (11..20)])
+      overlaps.size.should eq(2)
+      overlaps[0].should eq((2..3))
+      overlaps[1].should eq((4..6))
+    end
+  end
+end