cosmos 3.2.1 → 3.3.0

data/spec/utilities/crc_spec.rb

@@ -17,27 +17,27 @@ module Cosmos
 
   describe Crc16 do
     describe "calc" do
-      it "should calculate a 16 bit CRC" do
+      it "calculates a 16 bit CRC" do
         @crc = Crc16.new()
-        @crc.calc('123456789').should eql 0x29B1
+        expect(@crc.calc('123456789')).to eql 0x29B1
       end
     end
   end
 
   describe Crc32 do
     describe "calc" do
-      it "should calculate a 32 bit CRC" do
+      it "calculates a 32 bit CRC" do
         @crc = Crc32.new()
-        @crc.calc('123456789').should eql 0xCBF43926
+        expect(@crc.calc('123456789')).to eql 0xCBF43926
       end
     end
   end
 
   describe Crc64 do
     describe "calc" do
-      it "should calculate a 64 bit CRC" do
+      it "calculates a 64 bit CRC" do
         @crc = Crc64.new()
-        @crc.calc('123456789').should eql 0x995dc9bbdf1939fa
+        expect(@crc.calc('123456789')).to eql 0x995dc9bbdf1939fa
       end
     end
   end

data/spec/utilities/csv_spec.rb

@@ -42,52 +42,52 @@ module Cosmos
     end
 
     describe "access" do
-      it "should allow hash style access" do
-        @csv["test"].should eq(%w(1 2 3))
+      it "allows hash style access" do
+        expect(@csv["test"]).to eq(%w(1 2 3))
       end
 
-      it "should return all valid keys" do
-        @csv.keys.should eq(%w(test more foo))
+      it "returns all valid keys" do
+        expect(@csv.keys).to eq(%w(test more foo))
       end
     end
 
     describe "create_archive" do
-      it "should create a default archive file" do
+      it "creates a default archive file" do
         @csv.create_archive
-        File.exist?(@csv.archive_file).should be_truthy
+        expect(File.exist?(@csv.archive_file)).to be_truthy
         @csv.close_archive
       end
 
-      it "should create an archive file at an arbitrary path" do
+      it "creates an archive file at an arbitrary path" do
         if Kernel.is_windows?
           Dir.mkdir("C:/temp") unless File.directory?("C:/temp")
           @csv.create_archive("C:/temp")
-          File.exist?(@csv.archive_file).should be_truthy
+          expect(File.exist?(@csv.archive_file)).to be_truthy
           @csv.close_archive
         end
       end
     end
 
     describe "write_archive" do
-      it "should write to the archive file" do
+      it "writes to the archive file" do
         @csv.create_archive
         @csv.write_archive(%w(HI a b c))
         @csv.close_archive
         data = File.read @csv.archive_file
-        data.include?("HI,a,b,c").should be_truthy
+        expect(data.include?("HI,a,b,c")).to be_truthy
       end
 
-      it "should raise an exception if writing to an unopened archive" do
+      it "raises an exception if writing to an unopened archive" do
         expect {@csv.write_archive([])}.to raise_error
       end
 
-      it "should raise an exception if trying to reopen archive" do
+      it "raises an exception if trying to reopen archive" do
         @csv.create_archive
         expect {@csv.create_archive}.to raise_error
         @csv.close_archive
       end
 
-      it "should raise an exception if trying to write closed archive" do
+      it "raises an exception if trying to write closed archive" do
         @csv.create_archive
         @csv.close_archive
         expect {@csv.write_archive([])}.to raise_error

data/spec/utilities/logger_spec.rb

@@ -14,16 +14,16 @@ require "cosmos/utilities/logger"
 module Cosmos
   describe Logger do
     describe "initialize" do
-      it "should initialize the level to UNKNOWN" do
-        Logger.new.level.should eql Logger::UNKNOWN
+      it "initializes the level to UNKNOWN" do
+        expect(Logger.new.level).to eql Logger::UNKNOWN
         Logger.level = Logger::UNKNOWN
       end
     end
 
     describe "level" do
-      it "should get and set the level" do
+      it "gets and set the level" do
         Logger.level = Logger::DEBUG
-        Logger.level.should eql Logger::DEBUG
+        expect(Logger.level).to eql Logger::DEBUG
         Logger.level = Logger::UNKNOWN
       end
     end
@@ -34,66 +34,66 @@ module Cosmos
       Logger.level = level
       if block
         Logger.send(method, "Message1") { "Block1" }
-        stdout.string.should_not match "Message1"
-        stdout.string.should match "#{method.upcase}: Block1"
+        expect(stdout.string).not_to match "Message1"
+        expect(stdout.string).to match "#{method.upcase}: Block1"
       else
         Logger.send(method, "Message1")
-        stdout.string.should match "#{method.upcase}: Message1"
+        expect(stdout.string).to match "#{method.upcase}: Message1"
       end
       Logger::instance.level = level + 1
       if block
         Logger.debug("Message2") { "Block2" }
-        stdout.string.should_not match "Message2"
-        stdout.string.should_not match "Block2"
+        expect(stdout.string).not_to match "Message2"
+        expect(stdout.string).not_to match "Block2"
       else
         Logger.send(method, "Message2")
-        stdout.string.should_not match "Message2"
+        expect(stdout.string).not_to match "Message2"
       end
       $stdout = STDOUT
       Logger.level = Logger::UNKNOWN
     end
 
     describe "debug" do
-      it "should only print if level is DEBUG" do
+      it "only prints if level is DEBUG" do
         test_output(Logger::DEBUG, 'debug')
       end
-      it "should take a block" do
+      it "takes a block" do
         test_output(Logger::DEBUG, 'debug', true)
       end
     end
 
     describe "info" do
-      it "should only print if level is INFO" do
+      it "only prints if level is INFO" do
         test_output(Logger::INFO, 'info')
       end
-      it "should take a block" do
+      it "takes a block" do
         test_output(Logger::INFO, 'info', true)
       end
     end
 
     describe "warn" do
-      it "should only print if level is WARN" do
+      it "only prints if level is WARN" do
         test_output(Logger::WARN, 'warn')
       end
-      it "should take a block" do
+      it "takes a block" do
         test_output(Logger::WARN, 'warn', true)
       end
     end
 
     describe "error" do
-      it "should only print if level is ERROR" do
+      it "only prints if level is ERROR" do
         test_output(Logger::ERROR, 'error')
       end
-      it "should take a block" do
+      it "takes a block" do
         test_output(Logger::ERROR, 'error', true)
       end
     end
 
     describe "fatal" do
-      it "should only print if level is FATAL" do
+      it "only prints if level is FATAL" do
         test_output(Logger::FATAL, 'fatal')
       end
-      it "should take a block" do
+      it "takes a block" do
         test_output(Logger::FATAL, 'fatal', true)
       end
     end

data/spec/utilities/message_log_spec.rb

@@ -22,49 +22,49 @@ module Cosmos
     end
 
     describe "initialize" do
-      it "should accept a tool name and use the default LOG path" do
+      it "accepts a tool name and use the default LOG path" do
         log = MessageLog.new('TEST')
         log.start
         log.stop
         Cosmos.set_working_dir do
-          File.exist?(log.filename).should be_truthy
-          log.filename.should match 'TEST'
-          log.filename.should match 'logs'
+          expect(File.exist?(log.filename)).to be_truthy
+          expect(log.filename).to match 'TEST'
+          expect(log.filename).to match 'logs'
           File.delete log.filename
         end
       end
 
-      it "should accept a tool name and path" do
+      it "accepts a tool name and path" do
         log = MessageLog.new('TEST', File.expand_path(File.dirname(__FILE__)))
         log.start
         log.stop
-        File.exist?(log.filename).should be_truthy
-        log.filename.should match File.expand_path(File.dirname(__FILE__))
+        expect(File.exist?(log.filename)).to be_truthy
+        expect(log.filename).to match File.expand_path(File.dirname(__FILE__))
         File.delete log.filename
       end
     end
 
     describe "write" do
-      it "should write a message to the log" do
+      it "writes a message to the log" do
         log = MessageLog.new('TEST')
         log.write("Test message")
         log.stop
         Cosmos.set_working_dir do
-          File.read(log.filename).should eql "Test message"
+          expect(File.read(log.filename)).to eql "Test message"
           File.delete log.filename
         end
       end
     end
 
     describe "start" do
-      it "should create a new message log" do
+      it "creates a new message log" do
         log = MessageLog.new('TEST')
         log.start
         filename = log.filename
         # Allow a second to tick by so we have a unique filename
         sleep(1.001)
         log.start
-        log.filename.should_not eql filename
+        expect(log.filename).not_to eql filename
         log.stop
         Cosmos.set_working_dir do
           File.delete filename
@@ -74,12 +74,12 @@ module Cosmos
     end
 
     describe "stop" do
-      it "should close the message log and mark it read-only" do
+      it "closes the message log and mark it read-only" do
         log = MessageLog.new('TEST')
         log.start
         log.stop
         Cosmos.set_working_dir do
-          File.stat(log.filename).writable?.should be_falsey
+          expect(File.stat(log.filename).writable?).to be_falsey
           File.delete log.filename
         end
       end

data/spec/utilities/quaternion_spec.rb

@@ -16,90 +16,90 @@ module Cosmos
   describe Quaternion do
 
     describe "initialize" do
-      it "should create 0.0 elements" do
-        Quaternion.new.data.should eql [0.0,0.0,0.0,0.0]
+      it "creates 0.0 elements" do
+        expect(Quaternion.new.data).to eql [0.0,0.0,0.0,0.0]
       end
 
-      it "should take an initialization array" do
-        Quaternion.new([1.1,2.2,3.3,4.4]).data.should eql [1.1,2.2,3.3,4.4]
+      it "takes an initialization array" do
+        expect(Quaternion.new([1.1,2.2,3.3,4.4]).data).to eql [1.1,2.2,3.3,4.4]
       end
     end
 
     describe "[] and []=" do
-      it "should get and set individual elements" do
+      it "gets and set individual elements" do
         q = Quaternion.new
         q[0] = 5.5
-        q[0].should eql 5.5
+        expect(q[0]).to eql 5.5
       end
     end
 
     describe "data and data=" do
-      it "should get and set all elements" do
+      it "gets and set all elements" do
         q = Quaternion.new
         q.data = [1.1,2.2,3.3,4.4]
-        q.data.should eql [1.1,2.2,3.3,4.4]
+        expect(q.data).to eql [1.1,2.2,3.3,4.4]
       end
     end
 
     describe "q0, q1, q2, q3 getter and setter" do
-      it "should get and set an element" do
+      it "gets and set an element" do
         q = Quaternion.new()
         q.q0 = 1.1
         q.q1 = 2.2
         q.q2 = 3.3
         q.q3 = 4.4
-        q.q0.should eql 1.1
-        q.q1.should eql 2.2
-        q.q2.should eql 3.3
-        q.q3.should eql 4.4
+        expect(q.q0).to eql 1.1
+        expect(q.q1).to eql 2.2
+        expect(q.q2).to eql 3.3
+        expect(q.q3).to eql 4.4
       end
     end
 
     describe "*" do
-      it "should multiply quaternions" do
+      it "multiplies quaternions" do
         q1 = Quaternion.new([1,0,0,1])
         q2 = Quaternion.new([0,1,0,1])
-        (q1 * q2).data.should eql [1,1,1,1]
+        expect((q1 * q2).data).to eql [1,1,1,1]
         q1 = Quaternion.new([0,1,0,1])
         q2 = Quaternion.new([0,0,1,1])
-        (q1 * q2).data.should eql [1,1,1,1]
+        expect((q1 * q2).data).to eql [1,1,1,1]
         q1 = Quaternion.new([1,0,0,1])
         q2 = Quaternion.new([0,0,1,1])
-        (q1 * q2).data.should eql [1,-1,1,1]
+        expect((q1 * q2).data).to eql [1,-1,1,1]
       end
     end
 
     describe "inverse" do
-      it "should return the inverse" do
-        Quaternion.new([1,2,3,4]).inverse.data.should eql [-1,-2,-3,4]
+      it "returns the inverse" do
+        expect(Quaternion.new([1,2,3,4]).inverse.data).to eql [-1,-2,-3,4]
       end
     end
 
     describe "vecrot" do
-      it "should rotate the vector using the quaternion" do
-        Quaternion.new([1,0,0,1]).vecrot([1,1,1]).should eql [2,2,-2]
+      it "rotates the vector using the quaternion" do
+        expect(Quaternion.new([1,0,0,1]).vecrot([1,1,1])).to eql [2,2,-2]
       end
     end
 
     describe "Quaternion.signnz" do
-      it "should return 1 for zero" do
-        Quaternion.signnz(0).should eql 1.0
+      it "returns 1 for zero" do
+        expect(Quaternion.signnz(0)).to eql 1.0
       end
 
-      it "should return 1 for positive" do
-        Quaternion.signnz(0.5).should eql 1.0
+      it "returns 1 for positive" do
+        expect(Quaternion.signnz(0.5)).to eql 1.0
       end
 
-      it "should return -1 for negative" do
-        Quaternion.signnz(-123456789).should eql -1.0
+      it "returns -1 for negative" do
+        expect(Quaternion.signnz(-123456789)).to eql -1.0
       end
     end
 
     describe "Quaternion.qfromc" do
-      it "should create a quaternion from the matrix" do
+      it "creates a quaternion from the matrix" do
         q = Quaternion.qfromc(Matrix[[1,0,0],[0,1,0],[0,0,1]])
-        q.should be_a Quaternion
-        q.data.should eql [0.0,0.0,0.0,1.0]
+        expect(q).to be_a Quaternion
+        expect(q.data).to eql [0.0,0.0,0.0,1.0]
       end
     end
   end

data/spec/utilities/ruby_lex_utils_spec.rb

@@ -18,40 +18,40 @@ module Cosmos
     end
 
     describe "contains_begin?" do
-      it "should detect the begin keyword" do
-        @lex.contains_begin?("  begin  ").should be_truthy
-        @lex.contains_begin?("  begin # asdf  ").should be_truthy
+      it "detects the begin keyword" do
+        expect(@lex.contains_begin?("  begin  ")).to be_truthy
+        expect(@lex.contains_begin?("  begin # asdf  ")).to be_truthy
       end
     end
 
     describe "contains_keyword?" do
-      it "should detect the ruby keywords" do
-        @lex.contains_keyword?("if something").should be_truthy
-        @lex.contains_keyword?("obj.method = something").should be_falsey
+      it "detects the ruby keywords" do
+        expect(@lex.contains_keyword?("if something")).to be_truthy
+        expect(@lex.contains_keyword?("obj.method = something")).to be_falsey
       end
     end
 
     describe "contains_block_beginning?" do
-      it "should detect block beginning keywords" do
-        @lex.contains_block_beginning?("do").should be_truthy
-        @lex.contains_block_beginning?("[].each {").should be_truthy
-        @lex.contains_block_beginning?("begin").should be_truthy
+      it "detects block beginning keywords" do
+        expect(@lex.contains_block_beginning?("do")).to be_truthy
+        expect(@lex.contains_block_beginning?("[].each {")).to be_truthy
+        expect(@lex.contains_block_beginning?("begin")).to be_truthy
       end
     end
 
     describe "remove_comments" do
-      it "should remove comments" do
+      it "removes comments" do
 text = <<DOC
 # This is a comment
 blah = 5 # Inline comment
 # Another
 DOC
-        @lex.remove_comments(text).should eql "\nblah = 5 \n\n"
+        expect(@lex.remove_comments(text)).to eql "\nblah = 5 \n\n"
       end
     end
 
     describe "each_lexed_segment" do
-      it "should yield each segment" do
+      it "yields each segment" do
 text = <<DOC
 begin
   x = 0
@@ -63,7 +63,7 @@ DOC
           ["end\n",false,nil,3])  # can't instrument end
       end
 
-      it "should yield each segment" do
+      it "yields each segment" do
 text = <<DOC
 
 if x