cosmos 3.2.1 → 3.3.0

data/spec/core_ext/array_spec.rb

@@ -14,172 +14,172 @@ require 'cosmos/core_ext/array'
 describe Array do
 
   describe "inspect" do
-    it "should limit the number of items to 10" do
-      Array.new([1,2,3,4,5,6,7,8,9,10]).inspect.should eql "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
-      Array.new([1,2,3,4,5,6,7,8,9,10,11]).inspect.should match /#<Array:\d+>/
+    it "limits the number of items to 10" do
+      expect(Array.new([1,2,3,4,5,6,7,8,9,10]).inspect).to eql "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
+      expect(Array.new([1,2,3,4,5,6,7,8,9,10,11]).inspect).to match /#<Array:\d+>/
     end
   end
 
   describe "clone_to_f" do
-    it "should clone the array and convert all the values to floats" do
-      Array.new([1,2,3,4,5]).clone_to_f.should eql [1.0,2.0,3.0,4.0,5.0]
+    it "clones the array and convert all the values to floats" do
+      expect(Array.new([1,2,3,4,5]).clone_to_f).to eql [1.0,2.0,3.0,4.0,5.0]
     end
   end
 
   describe "nearest_index" do
-    it "should raise error if empty" do
+    it "raises error if empty" do
       expect { Array.new.nearest_index(nil) }.to raise_error
     end
 
     def find_sorted_value(array, sorted)
-      array.nearest_index(-1, sorted).should eql 0
+      expect(array.nearest_index(-1, sorted)).to eql 0
       (0..10).each do |val|
-        array.nearest_index(val,sorted).should eql val
+        expect(array.nearest_index(val,sorted)).to eql val
         # Ensure we always round up
         if val < 10
-          array.nearest_index(val+0.1,sorted).should eql val
-          array.nearest_index(val+0.5,sorted).should eql val + 1
-          array.nearest_index(val+0.9,sorted).should eql val + 1
+          expect(array.nearest_index(val+0.1,sorted)).to eql val
+          expect(array.nearest_index(val+0.5,sorted)).to eql val + 1
+          expect(array.nearest_index(val+0.9,sorted)).to eql val + 1
         end
       end
-      array.nearest_index(5.5,sorted).should eql 6
-      array.nearest_index(11, sorted).should eql 10
+      expect(array.nearest_index(5.5,sorted)).to eql 6
+      expect(array.nearest_index(11, sorted)).to eql 10
     end
 
     context "with sorted data" do
       context "with sorted = true" do
-        it "should find the nearest index" do
+        it "finds the nearest index" do
           array = Array.new([0,1,2,3,4,5,6,7,8,9,10])
           find_sorted_value(array, true)
         end
       end
 
       context "with sorted = false" do
-        it "should find the nearest index" do
+        it "finds the nearest index" do
           array = Array.new([0,1,2,3,4,5,6,7,8,9,10])
           find_sorted_value(array, false)
         end
 
-        it "should find the nearest index with duplicates" do
+        it "finds the nearest index with duplicates" do
           index1 = Array.new([0,1,1,1,1,2,2,3]).nearest_index(1,false)
           index2 = Array.new([0,1,1,1,1,2,2]).nearest_index(1,false)
-          index1.should eql index2
+          expect(index1).to eql index2
         end
       end
     end
 
     context "with unsorted data" do
-      it "should find the nearest index to a value" do
+      it "finds the nearest index to a value" do
         array = Array.new([10,1,9,2,8,3,7,4,6,5,0])
-        array.nearest_index(-1, false).should eql 10
-        array.nearest_index(11, false).should eql 0
+        expect(array.nearest_index(-1, false)).to eql 10
+        expect(array.nearest_index(11, false)).to eql 0
         # Ensure we round up
-        array.nearest_index(0.5, false).should eql 1
-        array.nearest_index(1.5, false).should eql 3
-        array.nearest_index(2.5, false).should eql 5
-        array.nearest_index(3.5, false).should eql 7
-        array.nearest_index(4.5, false).should eql 9
-        array.nearest_index(5.5, false).should eql 8
-        array.nearest_index(6.5, false).should eql 6
-        array.nearest_index(7.5, false).should eql 4
-        array.nearest_index(8.5, false).should eql 2
-        array.nearest_index(9.5, false).should eql 0
+        expect(array.nearest_index(0.5, false)).to eql 1
+        expect(array.nearest_index(1.5, false)).to eql 3
+        expect(array.nearest_index(2.5, false)).to eql 5
+        expect(array.nearest_index(3.5, false)).to eql 7
+        expect(array.nearest_index(4.5, false)).to eql 9
+        expect(array.nearest_index(5.5, false)).to eql 8
+        expect(array.nearest_index(6.5, false)).to eql 6
+        expect(array.nearest_index(7.5, false)).to eql 4
+        expect(array.nearest_index(8.5, false)).to eql 2
+        expect(array.nearest_index(9.5, false)).to eql 0
       end
     end
   end
 
   describe "index_lt_eq" do
-    it "should find the nearest index less than or equal to" do
-      Array.new([0,1,1,1,1,2,2,3]).index_lt_eq(1).should eql 1
-      Array.new([0,1,1,2,3]).index_lt_eq(1).should eql 1
-      Array.new([0,1,1,2,3]).index_lt_eq(0.5).should eql 0
+    it "finds the nearest index less than or equal to" do
+      expect(Array.new([0,1,1,1,1,2,2,3]).index_lt_eq(1)).to eql 1
+      expect(Array.new([0,1,1,2,3]).index_lt_eq(1)).to eql 1
+      expect(Array.new([0,1,1,2,3]).index_lt_eq(0.5)).to eql 0
     end
 
-    it "should return the first index if can't find one" do
-      Array.new([1,2,3,4]).index_lt_eq(0).should eql 0
+    it "returns the first index if can't find one" do
+      expect(Array.new([1,2,3,4]).index_lt_eq(0)).to eql 0
     end
   end
 
   describe "index_gt_eq" do
-    it "should find the nearest index greater than or equal to" do
-      Array.new([0,1,1,1,1,2,2,3]).index_gt_eq(1).should eql 4
-      Array.new([0,0.1,1,1,1,2,2]).index_gt_eq(1).should eql 4
-      Array.new([0,0.1,0.5,1,1]).index_gt_eq(0.7).should eql 3
+    it "finds the nearest index greater than or equal to" do
+      expect(Array.new([0,1,1,1,1,2,2,3]).index_gt_eq(1)).to eql 4
+      expect(Array.new([0,0.1,1,1,1,2,2]).index_gt_eq(1)).to eql 4
+      expect(Array.new([0,0.1,0.5,1,1]).index_gt_eq(0.7)).to eql 3
     end
 
-    it "should return the last index if can't find one" do
-      Array.new([1,2,3,4]).index_gt_eq(5).should eql 3
+    it "returns the last index if can't find one" do
+      expect(Array.new([1,2,3,4]).index_gt_eq(5)).to eql 3
     end
   end
 
   describe "range_containing" do
-    it "should complain if start < end" do
+    it "complains if start < end" do
       expect { Array.new().range_containing(2,1) }.to raise_error(RuntimeError, "end_value: 1 must be greater than start_value: 2")
     end
 
-    it "should find the range of values containing both" do
-      Array.new([0,1,1,2,2,3]).range_containing(1,2).should eql (1..4)
-      Array.new([0,1,1,2,2,3]).range_containing(1,1).should eql (1..2)
+    it "finds the range of values containing both" do
+      expect(Array.new([0,1,1,2,2,3]).range_containing(1,2)).to eql (1..4)
+      expect(Array.new([0,1,1,2,2,3]).range_containing(1,1)).to eql (1..2)
     end
   end
 
   describe "sum" do
-    it "should sum up the array elements" do
-      Array.new([0,1,2,3,4]).sum.should eql 10
+    it "sums up the array elements" do
+      expect(Array.new([0,1,2,3,4]).sum).to eql 10
       # The float causes the entire result to be a Float
-      Array.new([0,1,2,3,4.0]).sum.should eql 10.0
+      expect(Array.new([0,1,2,3,4.0]).sum).to eql 10.0
     end
   end
 
   describe "mean" do
-    it "should calculate the mean" do
-      Array.new([0,1,2,3,4]).mean.should eql 2.0
+    it "calculates the mean" do
+      expect(Array.new([0,1,2,3,4]).mean).to eql 2.0
     end
   end
 
   describe "squared" do
-    it "should square each element in the array" do
+    it "squares each element in the array" do
       array = Array.new([0,1,2,3,4])
-      array.squared.should eql [0,1,4,9,16]
+      expect(array.squared).to eql [0,1,4,9,16]
       # It should not affect the original
-      array.should eql [0,1,2,3,4]
+      expect(array).to eql [0,1,2,3,4]
     end
   end
 
   describe "max_with_index" do
-    it "should find the first maximum value and its index" do
-      Array.new([0,1,8,3,4]).max_with_index.should eql [8,2]
-      Array.new([-1,-8,-3,-4]).max_with_index.should eql [-1,0]
-      Array.new([0,1,2,2,0]).max_with_index.should eql [2,2]
+    it "finds the first maximum value and its index" do
+      expect(Array.new([0,1,8,3,4]).max_with_index).to eql [8,2]
+      expect(Array.new([-1,-8,-3,-4]).max_with_index).to eql [-1,0]
+      expect(Array.new([0,1,2,2,0]).max_with_index).to eql [2,2]
     end
   end
 
   describe "min_with_index" do
-    it "should find the first maximum value and its index" do
-      Array.new([8,9,2,5,6]).min_with_index.should eql [2,2]
-      Array.new([-1,-8,-3,-4]).min_with_index.should eql [-8,1]
-      Array.new([0,1,2,2,0]).min_with_index.should eql [0,0]
+    it "finds the first maximum value and its index" do
+      expect(Array.new([8,9,2,5,6]).min_with_index).to eql [2,2]
+      expect(Array.new([-1,-8,-3,-4]).min_with_index).to eql [-8,1]
+      expect(Array.new([0,1,2,2,0]).min_with_index).to eql [0,0]
     end
   end
 
   describe "histogram" do
-    it "should group elements" do
+    it "groups elements" do
       myData1 = [1, 7, 4, 3, 4, 2, 7, 0, 8, 3, 4]
       myData2 = [1, 2, 3]
       myData3 = [2, 4, 8]
-      myData1.histogram(9, true).length.should eql 9
-      myData1.histogram(1, true).length.should eql 1
-      myData1.histogram(9, true)[0][2].should eql 1
-      myData1.histogram(9, true)[4][2].should eql 3
-      myData1.histogram(3, true)[0][2].should eql 3
-      myData2.histogram(5, true).length.should eql 5
-      myData2.histogram(50, true).length.should eql 50
-      myData2.histogram(5, true)[4][2].should eql 0
-      myData2.histogram(5, true)[1][2].should eql 1
-      myData3.histogram(7, true).length.should eql 7
-      myData3.histogram(25, true).length.should eql 25
-      myData3.histogram(7, true)[2][2].should eql 1
-      myData3.histogram(25, true)[20][2].should eql 0
+      expect(myData1.histogram(9, true).length).to eql 9
+      expect(myData1.histogram(1, true).length).to eql 1
+      expect(myData1.histogram(9, true)[0][2]).to eql 1
+      expect(myData1.histogram(9, true)[4][2]).to eql 3
+      expect(myData1.histogram(3, true)[0][2]).to eql 3
+      expect(myData2.histogram(5, true).length).to eql 5
+      expect(myData2.histogram(50, true).length).to eql 50
+      expect(myData2.histogram(5, true)[4][2]).to eql 0
+      expect(myData2.histogram(5, true)[1][2]).to eql 1
+      expect(myData3.histogram(7, true).length).to eql 7
+      expect(myData3.histogram(25, true).length).to eql 25
+      expect(myData3.histogram(7, true)[2][2]).to eql 1
+      expect(myData3.histogram(25, true)[20][2]).to eql 0
     end
   end
 end

data/spec/core_ext/class_spec.rb

@@ -14,7 +14,7 @@ require 'cosmos/core_ext/class'
 describe Class do
 
   describe "instance_attr_reader" do
-    it "should add instance attribute readers for class variables" do
+    it "adds instance attribute readers for class variables" do
       class MyClass
         instance_attr_reader :test
         @@instance = nil
@@ -29,8 +29,8 @@ describe Class do
       end
 
       my = MyClass.new
-      MyClass.test.should eql "Test"
-      my.test.should eql "Test"
+      expect(MyClass.test).to eql "Test"
+      expect(my.test).to eql "Test"
     end
   end
 end

data/spec/core_ext/cosmos_io_spec.rb

@@ -18,60 +18,60 @@ end
 describe StringIO do
 
   describe "read_length_bytes" do
-    it "should return nil if length field is not 1, 2 or 4" do
+    it "returns nil if length field is not 1, 2 or 4" do
       io = StringIO.new
       io.write "\x01\x01\x01\x01\x01\x01\x01\x01"
       io.rewind
-      io.read_length_bytes(0).should be_nil
+      expect(io.read_length_bytes(0)).to be_nil
       io.rewind
-      io.read_length_bytes(3).should be_nil
+      expect(io.read_length_bytes(3)).to be_nil
       io.rewind
-      io.read_length_bytes(8).should be_nil
+      expect(io.read_length_bytes(8)).to be_nil
     end
 
-    it "should return nil if there aren't enough bytes to read the length field" do
+    it "returns nil if there aren't enough bytes to read the length field" do
       io = StringIO.new
       io.write ""
       io.rewind
-      io.read_length_bytes(1).should be_nil
+      expect(io.read_length_bytes(1)).to be_nil
 
       io = StringIO.new
       io.write "\x01"
       io.rewind
-      io.read_length_bytes(2).should be_nil
+      expect(io.read_length_bytes(2)).to be_nil
 
       io = StringIO.new
       io.write "\x01\x01"
       io.rewind
-      io.read_length_bytes(4).should be_nil
+      expect(io.read_length_bytes(4)).to be_nil
     end
 
-    it "should return nil if there aren't enough bytes to read the string" do
+    it "returns nil if there aren't enough bytes to read the string" do
       io = StringIO.new
       io.write "\x02\x01"
       io.rewind
-      io.read_length_bytes(1).should be_nil
+      expect(io.read_length_bytes(1)).to be_nil
     end
 
-    it "should read the bytes with length field size 1" do
+    it "reads the bytes with length field size 1" do
       io = StringIO.new
       io.write "\x02\x01\x02"
       io.rewind
-      io.read_length_bytes(1).should eql "\x01\x02"
+      expect(io.read_length_bytes(1)).to eql "\x01\x02"
     end
 
-    it "should read the bytes with length field size 2" do
+    it "reads the bytes with length field size 2" do
       io = StringIO.new
       io.write "\x00\x03\x01\x02\x03"
       io.rewind
-      io.read_length_bytes(2).should eql "\x01\x02\x03"
+      expect(io.read_length_bytes(2)).to eql "\x01\x02\x03"
     end
 
-    it "should read the bytes with length field size 4" do
+    it "reads the bytes with length field size 4" do
       io = StringIO.new
       io.write "\x00\x00\x00\x03\x01\x02\x03"
       io.rewind
-      io.read_length_bytes(4).should eql "\x01\x02\x03"
+      expect(io.read_length_bytes(4)).to eql "\x01\x02\x03"
     end
   end
 end

data/spec/core_ext/exception_spec.rb

@@ -14,47 +14,47 @@ require 'cosmos/core_ext/exception'
 describe Exception do
 
   describe "formatted" do
-    it "should format an Exception" do
+    it "formats an Exception" do
       begin
         raise "My message"
       rescue => err
-        err.formatted.should match /RuntimeError : My message/
-        err.formatted.should match /#{File.expand_path(__FILE__)}/
+        expect(err.formatted).to match /RuntimeError : My message/
+        expect(err.formatted).to match /#{File.expand_path(__FILE__)}/
       end
     end
 
-    it "should format an Exception without RuntimeError class" do
+    it "formats an Exception without RuntimeError class" do
       begin
         raise "My message"
       rescue => err
-        err.formatted(true).should_not match /RuntimeError/
-        err.formatted(true).should match /My message/
-        err.formatted(true).should match /#{File.expand_path(__FILE__)}/
+        expect(err.formatted(true)).not_to match /RuntimeError/
+        expect(err.formatted(true)).to match /My message/
+        expect(err.formatted(true)).to match /#{File.expand_path(__FILE__)}/
       end
 
       # If it's not a RuntimeError then we should still see the class
       begin
         raise ArgumentError.new("My message")
       rescue => err
-        err.formatted(true).should match /ArgumentError/
-        err.formatted(true).should match /My message/
-        err.formatted(true).should match /#{File.expand_path(__FILE__)}/
+        expect(err.formatted(true)).to match /ArgumentError/
+        expect(err.formatted(true)).to match /My message/
+        expect(err.formatted(true)).to match /#{File.expand_path(__FILE__)}/
       end
     end
 
-    it "should format an Exception without stack trace" do
+    it "formats an Exception without stack trace" do
       begin
         raise "My message"
       rescue => err
-        err.formatted(false, false).should match /RuntimeError : My message/
-        err.formatted(false, false).should_not match /#{File.expand_path(__FILE__)}/
+        expect(err.formatted(false, false)).to match /RuntimeError : My message/
+        expect(err.formatted(false, false)).not_to match /#{File.expand_path(__FILE__)}/
       end
 
       begin
         raise "My message"
       rescue => err
-        err.formatted(true, false).should match /My message/
-        err.formatted(true, false).should_not match /#{File.expand_path(__FILE__)}/
+        expect(err.formatted(true, false)).to match /My message/
+        expect(err.formatted(true, false)).not_to match /#{File.expand_path(__FILE__)}/
       end
     end
   end
@@ -65,8 +65,8 @@ describe Exception do
         line = __LINE__; raise "My message"
       rescue => err
         file, line = err.source
-        file.should eql __FILE__
-        line.should eql line
+        expect(file).to eql __FILE__
+        expect(line).to eql line
       end
     end
 
@@ -83,8 +83,8 @@ describe Exception do
           file_name = "C:#{__FILE__}"
         end
         file, line = err.source
-        file.should eql file_name
-        line.should eql line
+        expect(file).to eql file_name
+        expect(line).to eql line
       end
     end
   end

data/spec/core_ext/file_spec.rb

@@ -15,7 +15,7 @@ require 'tempfile'
 describe File do
 
   describe "is_ascii?" do
-    it "should return true if a file only contains printable ASCII characters" do
+    it "returns true if a file only contains printable ASCII characters" do
       tf = Tempfile.new('unittest')
       (32..126).each do |val|
         tf.puts(val.chr)
@@ -25,7 +25,7 @@ describe File do
       tf.unlink
     end
 
-    it "should return false if a file contains non-ASCII characters" do
+    it "returns false if a file contains non-ASCII characters" do
       tf = Tempfile.new('unittest')
       (0..255).each do |val|
         tf.puts(val.chr)
@@ -37,36 +37,36 @@ describe File do
   end
 
   describe "build_timestamped_filename" do
-    it "should format the time" do
+    it "formats the time" do
       time = Time.now
       timestamp = sprintf("%04u_%02u_%02u_%02u_%02u_%02u", time.year, time.month, time.mday, time.hour, time.min, time.sec)
-      File.build_timestamped_filename(nil,".txt",time).should match timestamp
+      expect(File.build_timestamped_filename(nil,".txt",time)).to match timestamp
     end
 
-    it "should allow empty tags" do
-      File.build_timestamped_filename([]).should match /\d\d\.txt/
+    it "allows empty tags" do
+      expect(File.build_timestamped_filename([])).to match /\d\d\.txt/
     end
 
-    it "should allow nil tags" do
-      File.build_timestamped_filename(nil).should match /\d\d\.txt/
+    it "allows nil tags" do
+      expect(File.build_timestamped_filename(nil)).to match /\d\d\.txt/
     end
 
-    it "should include the tags" do
-      File.build_timestamped_filename(['this','is','a','test']).should match 'this_is_a_test'
+    it "includes the tags" do
+      expect(File.build_timestamped_filename(['this','is','a','test'])).to match 'this_is_a_test'
     end
 
-    it "should change the extension" do
-      File.build_timestamped_filename(nil,".bin").should match ".bin"
+    it "changes the extension" do
+      expect(File.build_timestamped_filename(nil,".bin")).to match ".bin"
     end
   end
 
   describe "find_in_search_path" do
-    it "should return the path to the file" do
-      File.find_in_search_path("cosmos.rb").should match "/lib/cosmos.rb"
+    it "returns the path to the file" do
+      expect(File.find_in_search_path("cosmos.rb")).to match "/lib/cosmos.rb"
     end
 
-    it "should return nil if the file can't be found" do
-      File.find_in_search_path("blah_blah_blah.rb").should be_nil
+    it "returns nil if the file can't be found" do
+      expect(File.find_in_search_path("blah_blah_blah.rb")).to be_nil
     end
   end
 end