fat_core 0.0.1 → 0.1.0

data/spec/lib/numeric_spec.rb

@@ -2,27 +2,27 @@ 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'
+    expect(236.5555.commas(2)).to eq '236.56'
+    expect(-236.5555.commas(2)).to eq '-236.56'
   end
 
   it "should properly round down" do
-    236.5512.commas(2).should == '236.55'
-    -236.5512.commas(2).should == '-236.55'
+    expect(236.5512.commas(2)).to eq '236.55'
+    expect(-236.5512.commas(2)).to eq '-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'
+    expect(123456789.0123.commas(2)).to eq '123,456,789.01'
+    expect(-123456789.0123.commas(2)).to eq '-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'
+    expect(123456789.commas).to eq '123,456,789'
+    expect(-123456789.commas).to eq '-123,456,789'
   end
 
   it "should not place commas in a number with exponent" do
-    123456.789e100.commas.should == '1.23456789e+105'
+    expect(123456.789e100.commas).to eq '1.23456789e+105'
   end
 
   it "should be able to convert itself into an H:M:S string" do

data/spec/lib/period_spec.rb

@@ -4,19 +4,19 @@ 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')
+    allow(Date).to receive_messages(:today => Date.parse('2012-07-18'))
+    allow(Date).to receive_messages(:current => 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
+      expect(Period.new('2013-01-01', '2013-12-13')).to 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
+      expect(Period.new(Date.parse('2013-01-01'), Date.parse('2013-12-13'))).
+        to be_instance_of Period
     end
 
     it "should raise a ArgumentError if last > first" do
@@ -43,27 +43,33 @@ describe Period do
 
   describe "class methods" do
 
+    it "should know how to parse a pair of date specs" do
+      expect(Period.parse_spec.first).to eq Date.current
+      expect(Period.parse_spec('2014-3Q').first).to eq Date.parse('2014-07-01')
+      expect(Period.parse_spec('2014-3Q').last).to eq Date.parse('2014-09-30')
+    end
+
     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(:year)).to eq(365)
+      expect(Period.chunk_sym_to_days(:quarter)).to eq(90)
+      expect(Period.chunk_sym_to_days(:bimonth)).to eq(60)
+      expect(Period.chunk_sym_to_days(:month)).to eq(30)
+      expect(Period.chunk_sym_to_days(:semimonth)).to eq(15)
+      expect(Period.chunk_sym_to_days(:biweek)).to eq(14)
+      expect(Period.chunk_sym_to_days(:week)).to eq(7)
+      expect(Period.chunk_sym_to_days(:day)).to eq(1)
+      expect(Period.chunk_sym_to_days(:irregular)).to 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)
+      (356..376).each { |d| expect(Period.days_to_chunk_sym(d)).to eq(:year) }
+      (86..96).each { |d| expect(Period.days_to_chunk_sym(d)).to eq(:quarter) }
+      (28..31).each { |d| expect(Period.days_to_chunk_sym(d)).to eq(:month) }
+      expect(Period.days_to_chunk_sym(7)).to eq(:week)
+      expect(Period.days_to_chunk_sym(1)).to eq(:day)
     end
 
     it "should know what to call a chunk based on its size" do
@@ -85,210 +91,206 @@ describe Period 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
+      expect((pp1 == pp2)).to be true
+      expect((pp1 == pp3)).to_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)
+      expect(rr).to be_instance_of Range
+      expect(rr.first).to eq(pp.first)
+      expect(rr.first).to 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
+      expect(pp.contains?(Date.parse('2013-01-01'))).to be true
+      expect(pp.contains?(Date.parse('2013-07-04'))).to be true
+      expect(pp.contains?(Date.parse('2013-12-31'))).to be true
+      expect(pp.contains?(Date.parse('2012-07-04'))).to 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')
+      expect(Period.new('2013-01-01', '2013-12-31').to_s).to eq('2013')
+      expect(Period.new('2013-04-01', '2013-06-30').to_s).to eq('2013-2Q')
+      expect(Period.new('2013-03-01', '2013-03-31').to_s).to eq('2013-03')
+      expect(Period.new('2013-03-11', '2013-10-31').to_s).to 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')
+      expect(chunks.size).to eq(3)
+      expect(chunks[0].first.iso).to eq('2010-01-01')
+      expect(chunks[0].last.iso).to eq('2010-12-31')
+      expect(chunks[1].first.iso).to eq('2011-01-01')
+      expect(chunks[1].last.iso).to eq('2011-12-31')
+      expect(chunks[2].first.iso).to eq('2012-01-01')
+      expect(chunks[2].last.iso).to 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')
+      expect(chunks.size).to eq(12)
+      expect(chunks[0].first.iso).to eq('2010-01-01')
+      expect(chunks[0].last.iso).to eq('2010-03-31')
+      expect(chunks[1].first.iso).to eq('2010-04-01')
+      expect(chunks[1].last.iso).to eq('2010-06-30')
+      expect(chunks[2].first.iso).to eq('2010-07-01')
+      expect(chunks[2].last.iso).to eq('2010-09-30')
+      expect(chunks.last.first.iso).to eq('2012-10-01')
+      expect(chunks.last.last.iso).to 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')
+      expect(chunks.size).to eq(18)
+      expect(chunks[0].first.iso).to eq('2010-01-01')
+      expect(chunks[0].last.iso).to eq('2010-02-28')
+      expect(chunks[1].first.iso).to eq('2010-03-01')
+      expect(chunks[1].last.iso).to eq('2010-04-30')
+      expect(chunks[2].first.iso).to eq('2010-05-01')
+      expect(chunks[2].last.iso).to eq('2010-06-30')
+      expect(chunks.last.first.iso).to eq('2012-11-01')
+      expect(chunks.last.last.iso).to 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')
+      expect(chunks.size).to eq(36)
+      expect(chunks[0].first.iso).to eq('2010-01-01')
+      expect(chunks[0].last.iso).to eq('2010-01-31')
+      expect(chunks[1].first.iso).to eq('2010-02-01')
+      expect(chunks[1].last.iso).to eq('2010-02-28')
+      expect(chunks[2].first.iso).to eq('2010-03-01')
+      expect(chunks[2].last.iso).to eq('2010-03-31')
+      expect(chunks.last.first.iso).to eq('2012-12-01')
+      expect(chunks.last.last.iso).to 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')
+      expect(chunks.size).to eq(72)
+      expect(chunks[0].first.iso).to eq('2010-01-01')
+      expect(chunks[0].last.iso).to eq('2010-01-15')
+      expect(chunks[1].first.iso).to eq('2010-01-16')
+      expect(chunks[1].last.iso).to eq('2010-01-31')
+      expect(chunks[2].first.iso).to eq('2010-02-01')
+      expect(chunks[2].last.iso).to eq('2010-02-15')
+      expect(chunks.last.first.iso).to eq('2012-12-16')
+      expect(chunks.last.last.iso).to 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')
+      expect(chunks[0].first.iso).to eq('2010-01-04')
+      expect(chunks[0].last.iso).to eq('2010-01-17')
+      expect(chunks[1].first.iso).to eq('2010-01-18')
+      expect(chunks[1].last.iso).to eq('2010-01-31')
+      expect(chunks[2].first.iso).to eq('2010-02-01')
+      expect(chunks[2].last.iso).to eq('2010-02-14')
+      expect(chunks.last.first.iso).to eq('2012-12-17')
+      expect(chunks.last.last.iso).to 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')
+      expect(chunks[0].first.iso).to eq('2010-01-04')
+      expect(chunks[0].last.iso).to eq('2010-01-10')
+      expect(chunks[1].first.iso).to eq('2010-01-11')
+      expect(chunks[1].last.iso).to eq('2010-01-17')
+      expect(chunks[2].first.iso).to eq('2010-01-18')
+      expect(chunks[2].last.iso).to eq('2010-01-24')
+      expect(chunks.last.first.iso).to eq('2012-12-24')
+      expect(chunks.last.last.iso).to 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')
+      expect(chunks.size).to eq(4)
+      expect(chunks[0].first.iso).to eq('2012-12-28')
+      expect(chunks[0].last.iso).to eq('2012-12-28')
+      expect(chunks[1].first.iso).to eq('2012-12-29')
+      expect(chunks[1].last.iso).to eq('2012-12-29')
+      expect(chunks[2].first.iso).to eq('2012-12-30')
+      expect(chunks[2].last.iso).to eq('2012-12-30')
+      expect(chunks.last.first.iso).to eq('2012-12-31')
+      expect(chunks.last.last.iso).to 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)
+      expect(chunks.size).to 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'))
+      expect(chunks.size).to eq(3)
+      expect(chunks.last.first).to eq(Date.parse('2012-03-01'))
+      expect(chunks.last.last).to 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'))
+      expect(chunks.size).to eq(3)
+      expect(chunks.last.first).to eq(Date.parse('2012-03-01'))
+      expect(chunks.last.last).to 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'))
+      expect(chunks.size).to eq(2)
+      expect(chunks[0].first).to eq(Date.parse('2012-02-01'))
+      expect(chunks[0].last).to 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'))
+      expect(chunks.size).to eq(3)
+      expect(chunks[0].first).to eq(Date.parse('2012-01-13'))
+      expect(chunks[0].last).to 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'))
+      expect(chunks.size).to eq(3)
+      expect(chunks.last.first).to eq(Date.parse('2012-03-01'))
+      expect(chunks.last.last).to 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)
+      expect(Period.new('2013-01-01', '2013-12-31').chunk_sym).to eq(:year)
+      expect(Period.new('2012-01-01', '2013-12-31').chunk_sym).to_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)
+      expect(Period.new('2013-04-01', '2013-06-30').chunk_sym).to eq(:quarter)
+      expect(Period.new('2013-04-01', '2013-09-30').chunk_sym).to_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)
+      expect(Period.new('2013-03-01', '2013-04-30').chunk_sym).to eq(:bimonth)
+      expect(Period.new('2013-03-01', '2013-06-30').chunk_sym).to_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)
+      expect(Period.new('2013-04-01', '2013-04-30').chunk_sym).to eq(:month)
+      expect(Period.new('2013-04-01', '2013-05-30').chunk_sym).to_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)
+      expect(Period.new('2013-05-16', '2013-05-31').chunk_sym).to eq(:semimonth)
+      expect(Period.new('2013-05-16', '2013-06-30').chunk_sym).to_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)
+      expect(Period.new('2013-11-04', '2013-11-17').chunk_sym).to eq(:biweek)
+      expect(Period.new('2013-11-04', '2013-11-24').chunk_sym).to_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)
+      expect(Period.new('2013-11-11', '2013-11-17').chunk_sym).to eq(:week)
+      expect(Period.new('2013-11-11', '2013-11-24').chunk_sym).to_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)
+      expect(Period.new('2013-11-10', '2013-11-10').chunk_sym).to eq(:day)
+      expect(Period.new('2013-11-10', '2013-11-11').chunk_sym).to_not eq(:day)
 
-      Period.new('2013-11-02', '2013-12-16').chunk_sym.should eq(:irregular)
+      expect(Period.new('2013-11-02', '2013-12-16').chunk_sym).to eq(:irregular)
     end
   end
 end

data/spec/lib/range_spec.rb

@@ -32,7 +32,7 @@ describe Range do
       expect((4..8)).not_to be_superset_of((9..20))
     end
 
-    it "should know if it is a superset of another range" do
+    it "should know if it is a proper 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))
@@ -47,23 +47,23 @@ describe Range do
     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))
+      expect(((0..10) & (5..20))).to eq((5..10))
+      expect(((0..10) & (5..20))).to eq((5..20) & (0..10))
+      expect(((0..10) & (10..20))).to eq((10..10))
     end
 
     it "intersection should return nil if there is no overlap" do
-      ((0..10) & (15..20)).should be_nil
+      expect(((0..10) & (15..20))).to 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))
+      expect(((0..10) + (5..20))).to eq((0..20))
+      expect(((0..10) + (5..20))).to eq((5..20) + (0..10))
+      expect(((0..10) + (10..20))).to eq((0..20))
     end
 
     it "union should return nil if there is no overlap" do
-      ((0..10) & (15..20)).should be_nil
+      expect(((0..10) & (15..20))).to be_nil
     end
 
     it "should know the difference with another range" do
@@ -99,148 +99,148 @@ describe Range do
 
   describe "joining" do
     it "should be able to join contiguous ranges" do
-      (0..3).join(4..8).should == (0..8)
+      expect((0..3).join(4..8)).to eq (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
+      expect((0..3).join(5..8)).to be_nil
+      expect((0...3).join(4..8)).to 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)
+      expect((0.0..3.0).join(3.0..8.2)).to eq (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)])
+      expect((0..10)).to 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)])
+      expect((0..10)).to_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)
+      expect((0..10)).to be_spanned_by(set)
       set = [(0...3), (4..6), (7..10)].to_set
-      (0..10).should_not be_spanned_by(set)
+      expect((0..10)).to_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)
+      expect((2..8)).to be_spanned_by(set)
+      expect((5..6)).to 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
+      expect((0..10).overlaps?(-3..5)).to be_truthy
+      expect((0..10).overlaps?(3..5)).to be_truthy
+      expect((0..10).overlaps?(8..15)).to be_truthy
+      expect((0..10).overlaps?(0..10)).to be_truthy
+      expect((0..10).overlaps?(11..12)).to be_falsy
+      expect((0..10).overlaps?(-11..-1)).to be_falsy
     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)])
+      expect((0..10)).to 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)])
+      expect((11..15)).to_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)])
+      expect((0..10)).to_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)])
+      expect((0..10)).to_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([])
+      expect((0..10)).to_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
+      expect((0..10).gaps([(-1..3), (4..8), (9..11)])).to be_empty
     end
 
     it "should return array for itself if ranges are empty" do
-      (0..10).gaps([]).should eq([(0..10)])
+      expect((0..10).gaps([])).to 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))
+      expect(gaps[0]).to eq((4..4))
+      expect(gaps[1]).to 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
+      expect(gaps).to 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))
+      expect(gaps[0]).to eq((0..1))
+      expect(gaps[1]).to 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))
+      expect(gaps[0]).to eq((0..1))
+      expect(gaps[1]).to 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
+      expect(gaps).to 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
+      expect((0..10).overlaps([])).to be_empty
     end
 
     it "should return an empty array if ranges is same as self" do
-      (0..10).overlaps([(0..10)]).should be_empty
+      expect((0..10).overlaps([(0..10)])).to be_empty
     end
 
     it "should return an empty array if ranges is wider than self" do
-      (0..10).overlaps([(-5..15)]).should be_empty
+      expect((0..10).overlaps([(-5..15)])).to be_empty
     end
 
     it "should return an empty array if ranges is narrower than self" do
-      (0..10).overlaps([(5..8)]).should be_empty
+      expect((0..10).overlaps([(5..8)])).to 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))
+      expect(overlaps.size).to eq(2)
+      expect(overlaps[0]).to eq((2..3))
+      expect(overlaps[1]).to 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))
+      expect(overlaps.size).to eq(2)
+      expect(overlaps[0]).to eq((2..3))
+      expect(overlaps[1]).to 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))
+      expect(overlaps.size).to eq(2)
+      expect(overlaps[0]).to eq((2..3))
+      expect(overlaps[1]).to eq((4..6))
     end
   end
 end