rmuh 0.2.1 → 0.2.2

data/spec/rmuh_rpt_log_parsers_unitedoperationslog_spec.rb

@@ -24,8 +24,9 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
     end
 
     it 'should return nil if arg 1 is a Hash' do
-      RMuh::RPT::Log::Parsers::UnitedOperationsLog.validate_opts({})
-        .should be_nil
+      expect(
+        RMuh::RPT::Log::Parsers::UnitedOperationsLog.validate_opts({})
+      ).to be_nil
     end
 
     it 'should fail if to_zulu is not boolean' do
@@ -63,49 +64,50 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
 
     it 'should return an instance of UnitedOperationsLog' do
       u = RMuh::RPT::Log::Parsers::UnitedOperationsLog.new
-      u.should be_an_instance_of RMuh::RPT::Log::Parsers::UnitedOperationsLog
+      expect(u)
+        .to be_an_instance_of RMuh::RPT::Log::Parsers::UnitedOperationsLog
     end
 
     it 'should not include chat by default' do
       u = uolog.instance_variable_get(:@include_chat)
-      u.should be_false
+      expect(u).to be_false
     end
 
     it 'should convert to zulu by default' do
       u = uolog.instance_variable_get(:@to_zulu)
-      u.should be_true
+      expect(u).to be_true
     end
 
     it 'should use the UO timezone by default' do
       t = RMuh::RPT::Log::Util::UnitedOperations::UO_TZ
       u = uolog.instance_variable_get(:@timezone)
-      u.should eql t
+      expect(u).to eql t
     end
 
     it 'should not include chat if passed as false' do
       u = RMuh::RPT::Log::Parsers::UnitedOperationsLog.new(chat: false)
-      u.instance_variable_get(:@include_chat).should eql false
+      expect(u.instance_variable_get(:@include_chat)).to eql false
     end
 
     it 'should include chat if passed as true' do
       u = RMuh::RPT::Log::Parsers::UnitedOperationsLog.new(chat: true)
-      u.instance_variable_get(:@include_chat).should eql true
+      expect(u.instance_variable_get(:@include_chat)).to eql true
     end
 
     it 'should not convert to zulu if passed as false' do
       u = RMuh::RPT::Log::Parsers::UnitedOperationsLog.new(to_zulu: false)
-      u.instance_variable_get(:@to_zulu).should eql false
+      expect(u.instance_variable_get(:@to_zulu)).to eql false
     end
 
     it 'should convert to zulu if passed as true' do
       u = RMuh::RPT::Log::Parsers::UnitedOperationsLog.new(to_zulu: true)
-      u.instance_variable_get(:@to_zulu).should eql true
+      expect(u.instance_variable_get(:@to_zulu)).to eql true
     end
 
     it 'should specify a custom timezone if passed in' do
       t = TZInfo::Timezone.get('Etc/UTC')
       u = RMuh::RPT::Log::Parsers::UnitedOperationsLog.new(timezone: t)
-      u.instance_variable_get(:@timezone).should eql t
+      expect(u.instance_variable_get(:@timezone)).to eql t
     end
   end
 
@@ -119,25 +121,26 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
     it 'should return today if it is between 0400 and 2359' do
       tz = RMuh::RPT::Log::Util::UnitedOperations::UO_TZ
       t = Time.new(2014, 1, 1, 4, 0, 0)
-      uolog.send(:date_of_line_based_on_now, t).to_s.should eql tz.now.to_s
+      expect(uolog.send(:date_of_line_based_on_now, t).to_s).to eql tz.now.to_s
       t = Time.new(2014, 1, 1, 23, 59, 59)
-      uolog.send(:date_of_line_based_on_now, t).to_s.should eql tz.now.to_s
+      expect(uolog.send(:date_of_line_based_on_now, t).to_s).to eql tz.now.to_s
       t = Time.new(2014, 1, 1, 0, 0, 0)
-      uolog.send(:date_of_line_based_on_now, t).to_s.should_not eql tz.now.to_s
+      expect(uolog.send(:date_of_line_based_on_now, t).to_s)
+        .to_not eql tz.now.to_s
     end
 
     it 'should return yesterday if it is between 0000 and 0359' do
       tz = RMuh::RPT::Log::Util::UnitedOperations::UO_TZ
       d = RMuh::RPT::Log::Util::UnitedOperationsLog::ONE_DAY
       t = Time.new(2014, 1, 1, 0, 0, 0)
-      uolog.send(:date_of_line_based_on_now, t)
-        .to_s.should(eql((tz.now - d).to_s))
+      expect(uolog.send(:date_of_line_based_on_now, t).to_s)
+        .to eql((tz.now - d).to_s)
       t = Time.new(2014, 1, 1, 3, 59, 59)
-      uolog.send(:date_of_line_based_on_now, t)
-        .to_s.should(eql((tz.now - d).to_s))
+      expect(uolog.send(:date_of_line_based_on_now, t).to_s)
+        .to eql((tz.now - d).to_s)
       t = Time.new(2014, 1, 1, 4, 0, 0)
-      uolog.send(:date_of_line_based_on_now, t)
-        .to_s.should_not(eql((tz.now - d).to_s))
+      expect(uolog.send(:date_of_line_based_on_now, t).to_s)
+        .to_not eql((tz.now - d).to_s)
     end
   end
 
@@ -158,21 +161,21 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
       tz = uolog.instance_variable_get(:@timezone)
       l = {}
       uolog.send(:set_line_date!, l)
-      l[:year].should eql tz.now.year
+      expect(l[:year]).to eql tz.now.year
     end
 
     it "should set the line's month to this month" do
       tz = uolog.instance_variable_get(:@timezone)
       l = {}
       uolog.send(:set_line_date!, l)
-      l[:month].should eql tz.now.month
+      expect(l[:month]).to eql tz.now.month
     end
 
     it "should set the line's date to this day" do
       tz = uolog.instance_variable_get(:@timezone)
       l = {}
       uolog.send(:set_line_date!, l)
-      l[:day].should eql tz.now.day
+      expect(l[:day]).to eql tz.now.day
     end
   end
 
@@ -197,9 +200,9 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
       l = yday_line.dup
       uolog.stub(:date_of_line_based_on_now) { tz.now }
       uolog.send(:when_am_i!, l)
-      l[:year].should eql tz.now.year
-      l[:month].should eql tz.now.month
-      l[:day].should eql tz.now.day
+      expect(l[:year]).to eql tz.now.year
+      expect(l[:month]).to eql tz.now.month
+      expect(l[:day]).to eql tz.now.day
     end
 
     it 'should set the date as yday if line (0400-2359) now not same range' do
@@ -208,18 +211,18 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
       l = yday_line.dup
       uolog.stub(:date_of_line_based_on_now) { tz.now - d }
       uolog.send(:when_am_i!, l)
-      l[:year].should(eql((tz.now - d).year))
-      l[:month].should(eql((tz.now - d).month))
-      l[:day].should(eql((tz.now - d).day))
+      expect(l[:year]).to eql((tz.now - d).year)
+      expect(l[:month]).to eql((tz.now - d).month)
+      expect(l[:day]).to eql((tz.now - d).day)
     end
 
     it 'should set the date as today if time between 0000 and 0359' do
       tz = uolog.instance_variable_get(:@timezone)
       l = today_line.dup
       uolog.send(:when_am_i!, l)
-      l[:year].should eql tz.now.year
-      l[:month].should eql tz.now.month
-      l[:day].should eql tz.now.day
+      expect(l[:year]).to eql tz.now.year
+      expect(l[:month]).to eql tz.now.month
+      expect(l[:day]).to eql tz.now.day
     end
   end
 
@@ -239,22 +242,22 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
     it 'should call where_am_i! and set the year/month/day' do
       l = { hour: 4, min: 0, sec: 0 }
       x = uolog.send(:line_modifiers, l)
-      x.key?(:year).should be_true
-      x.key?(:month).should be_true
-      x.key?(:day).should be_true
+      expect(x.key?(:year)).to be_true
+      expect(x.key?(:month)).to be_true
+      expect(x.key?(:day)).to be_true
     end
 
     it 'sould call zulu! and set the time to zulu' do
       l = { hour: 4, min: 0, sec: 0 }
       x = uolog.send(:line_modifiers, l)
-      x.key?(:iso8601).should be_true
-      x.key?(:dtg).should be_true
+      expect(x.key?(:iso8601)).to be_true
+      expect(x.key?(:dtg)).to be_true
     end
 
     it 'should call add_guid! and add the event_guid' do
       l = { hour: 4, min: 0, sec: 0 }
       x = uolog.send(:line_modifiers, l)
-      x.key?(:event_guid).should be_true
+      expect(x.key?(:event_guid)).to be_true
     end
   end
 
@@ -285,44 +288,47 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
     end
 
     it 'should return an Array' do
-      uolog.send(:regex_matches, StringIO.new).should be_an_instance_of Array
+      expect(uolog.send(:regex_matches, StringIO.new))
+        .to be_an_instance_of Array
     end
 
     it 'should iterate over multiple log lines' do
       x = uolog.send(:regex_matches, loglines)
-      x.should be_an_instance_of Array
-      x.length.should eql 2
+      expect(x).to be_an_instance_of Array
+      expect(x.length).to eql 2
     end
 
     it 'should properly match a guid line' do
       x = uolog.send(:regex_matches, StringIO.new(guid_line))
-      x[0][:type].should eql :beguid
+      expect(x[0][:type]).to eql :beguid
     end
 
     it 'should properly match a chat line' do
       x = uolog.send(:regex_matches, StringIO.new(chat_line))
-      x[0][:type].should eql :chat
+      expect(x[0][:type]).to eql :chat
     end
 
     it 'should not match a chat line if chat matching is disabled' do
       u = RMuh::RPT::Log::Parsers::UnitedOperationsLog.new
-      u.send(:regex_matches, StringIO.new(chat_line)).empty?.should be_true
+      expect(
+        u.send(:regex_matches, StringIO.new(chat_line)).empty?
+      ).to be_true
     end
 
     it 'should compact the Array' do
       l = StringIO.new("Something1\nSomething2\n")
       x = uolog.send(:regex_matches, l)
-      x.include?(nil).should be_false
+      expect(x.include?(nil)).to be_false
     end
 
     it 'should call #line_modifiers' do
       x = uolog.send(:regex_matches, StringIO.new(guid_line))
-      x[0].key?(:year).should be_true
-      x[0].key?(:month).should be_true
-      x[0].key?(:day).should be_true
-      x[0].key?(:iso8601).should be_true
-      x[0].key?(:dtg).should be_true
-      x[0].key?(:event_guid).should be_true
+      expect(x[0].key?(:year)).to be_true
+      expect(x[0].key?(:month)).to be_true
+      expect(x[0].key?(:day)).to be_true
+      expect(x[0].key?(:iso8601)).to be_true
+      expect(x[0].key?(:dtg)).to be_true
+      expect(x[0].key?(:event_guid)).to be_true
     end
   end
 
@@ -341,7 +347,7 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
     end
 
     it 'should not fail if arg1 is a StringIO object' do
-      expect { uolog.parse(StringIO.new) }.not_to raise_error
+      expect { uolog.parse(StringIO.new) }.to_not raise_error
     end
 
     it 'should fail if arg1 is a String' do
@@ -373,18 +379,18 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsLog do
     end
 
     it 'should return an Array' do
-      uolog.parse(StringIO.new).should be_an_instance_of Array
+      expect(uolog.parse(StringIO.new)).to be_an_instance_of Array
     end
 
     it 'should call #regex_matches' do
       x = uolog.parse(StringIO.new(guid_line))
-      x[0].key?(:type).should be_true
-      x[0].key?(:year).should be_true
-      x[0].key?(:month).should be_true
-      x[0].key?(:day).should be_true
-      x[0].key?(:iso8601).should be_true
-      x[0].key?(:dtg).should be_true
-      x[0].key?(:event_guid).should be_true
+      expect(x[0].key?(:type)).to be_true
+      expect(x[0].key?(:year)).to be_true
+      expect(x[0].key?(:month)).to be_true
+      expect(x[0].key?(:day)).to be_true
+      expect(x[0].key?(:iso8601)).to be_true
+      expect(x[0].key?(:dtg)).to be_true
+      expect(x[0].key?(:event_guid)).to be_true
     end
   end
 end

data/spec/rmuh_rpt_log_parsers_unitedoperationsrpt_spec.rb

@@ -21,8 +21,9 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsRPT do
     end
 
     it 'should not fail if arg 1 is a Hash' do
-      RMuh::RPT::Log::Parsers::UnitedOperationsRPT
-        .validate_opts({}).should be_nil
+      expect(
+        RMuh::RPT::Log::Parsers::UnitedOperationsRPT.validate_opts({})
+      ).to be_nil
     end
 
     it 'should fail if arg 1 is an Array' do
@@ -84,7 +85,7 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsRPT do
     it 'should not fail if arg 1 is a hash' do
       expect do
         RMuh::RPT::Log::Parsers::UnitedOperationsRPT.new
-      end.not_to raise_error
+      end.to_not raise_error
     end
 
     it 'should fail if arg 1 is an Array' do
@@ -132,22 +133,22 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsRPT do
     it 'should fail if arg 1 is nil' do
       expect do
         RMuh::RPT::Log::Parsers::UnitedOperationsRPT.new(nil)
-      end
+      end.to raise_error ArgumentError
     end
 
     it 'should return an instance of itself' do
-      uorpt.should be_an_instance_of(
+      expect(uorpt).to be_an_instance_of(
         RMuh::RPT::Log::Parsers::UnitedOperationsRPT
       )
     end
 
     it 'should set @to_zulu to true if nothing provided' do
-      uorpt.instance_variable_get(:@to_zulu).should be_true
+      expect(uorpt.instance_variable_get(:@to_zulu)).to be_true
     end
 
     it 'should set @timezone to America/Los_Angeles if nothing provided' do
       tz = TZInfo::Timezone.get('America/Los_Angeles')
-      uorpt.instance_variable_get(:@timezone).should eql tz
+      expect(uorpt.instance_variable_get(:@timezone)).to eql tz
     end
   end
 
@@ -165,23 +166,23 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsRPT do
     end
 
     it 'should return nil if line matches nothing' do
-      uorpt.send(:regex_match, '').should be_nil
+      expect(uorpt.send(:regex_match, '')).to be_nil
     end
 
     it 'should return a Hash if the line matches ANNOUNCEMENT' do
       l = '2014/02/16,  4:13:10 "############################# Start ' \
           'CO08_Escape_Chernarus_V1 #############################"'
       x = uorpt.send(:regex_match, l)
-      x.should be_an_instance_of Hash
-      x[:type].should eql :announcement
+      expect(x).to be_an_instance_of Hash
+      expect(x[:type]).to eql :announcement
     end
 
     it 'should return a Hash if the line matches WOUNDED' do
       l = '2014/02/16,  5:22:55 "4152.41 seconds: Sherminator (CIV) has ' \
           'been team wounded by Xcenocide (WEST) for 1.50828 damage."'
       x = uorpt.send(:regex_match, l)
-      x.should be_an_instance_of Hash
-      x[:type].should eql :wounded
+      expect(x).to be_an_instance_of Hash
+      expect(x[:type]).to eql :wounded
     end
 
     it 'should return a Hash if the line matches KILLED' do
@@ -191,8 +192,8 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsRPT do
           '[6498.62,6916.71,0.0204163] (GRID 0649806916). Distance between: ' \
           '71.1653 meters. Near players (100m): None."'
       x = uorpt.send(:regex_match, l)
-      x.should be_an_instance_of Hash
-      x[:type].should eql :killed
+      expect(x).to be_an_instance_of Hash
+      expect(x[:type]).to eql :killed
     end
 
     it 'should return a Hash if the line matches DIED' do
@@ -200,8 +201,8 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsRPT do
           '[4602.18,7490.26,2.2435] (GRID 0460207490). Near players (100m): ' \
           '["Olli","nametag47","Villanyi"]"'
       x = uorpt.send(:regex_match, l)
-      x.should be_an_instance_of Hash
-      x[:type].should eql :died
+      expect(x).to be_an_instance_of Hash
+      expect(x[:type]).to eql :died
     end
   end
 
@@ -239,14 +240,14 @@ describe RMuh::RPT::Log::Parsers::UnitedOperationsRPT do
     it 'should return an Array' do
       ll = StringIO.new
       x = uorpt.parse(ll)
-      x.should be_an_instance_of Array
+      expect(x).to be_an_instance_of Array
     end
 
     it 'should return an Array of hashes if a line matches' do
       x = uorpt.parse(loglines)
-      x.should be_an_instance_of Array
-      x.empty?.should be_false
-      x.each { |y| y.should be_an_instance_of Hash }
+      expect(x).to be_an_instance_of Array
+      expect(x.empty?).to be_false
+      x.each { |y| expect(y).to be_an_instance_of Hash }
     end
   end
 end

data/spec/rmuh_rpt_log_util_unitedoperations_spec.rb

@@ -61,21 +61,21 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
     it 'should return a Hash' do
       ml = @uo_util.m_to_h(@mi.match('2013/12/31 16:00:00'))
       mr = @uo_util.zulu!(ml, uo_tz)
-      mr.should be_an_instance_of Hash
+      expect(mr).to be_an_instance_of Hash
     end
 
     it 'should properly convert the time to zulu' do
-      zulued[:iso8601].should eql good_time
+      expect(zulued[:iso8601]).to eql good_time
     end
 
     it 'should properly format the time in iso8601' do
       m = /^\d+-\d+-\d+T\d+:\d+:\d+Z$/
-      m.match(zulued[:iso8601]).should be_an_instance_of MatchData
+      expect(m.match(zulued[:iso8601])).to be_an_instance_of MatchData
     end
 
     it 'should properly format the time in DTG' do
       m = /^\d+Z\s([A-Z]){3}\s\d+$/
-      m.match(zulued[:dtg]).should be_an_instance_of MatchData
+      expect(m.match(zulued[:dtg])).to be_an_instance_of MatchData
     end
   end
 
@@ -96,23 +96,23 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
     end
 
     it 'should return a String if key :iso8601 is there' do
-      @uo_util.__guid_data_base(@full_line).should be_an_instance_of String
+      expect(@uo_util.__guid_data_base(@full_line)).to be_an_instance_of String
     end
 
     it 'should return a String if key :iso8608 is missing' do
-      @uo_util.__guid_data_base(fline).should be_an_instance_of String
+      expect(@uo_util.__guid_data_base(fline)).to be_an_instance_of String
     end
 
     it 'should return iso8601 + type if key :is8601 is there' do
       x = @uo_util.__guid_data_base(@full_line)
-      x.should eql "#{@full_line[:iso8601]}#{@full_line[:type].to_s}"
+      expect(x).to eql "#{@full_line[:iso8601]}#{@full_line[:type].to_s}"
     end
 
     it 'should be year + month + day + hr + min + sec + type if !iso8601' do
       x = @uo_util.__guid_data_base(fline)
       s = "#{fline[:year]}#{fline[:month]}#{fline[:day]}#{fline[:hour]}" \
           "#{fline[:min]}#{fline[:sec]}#{fline[:type].to_s}"
-      x.should eql s
+      expect(x).to eql s
     end
   end
 
@@ -131,17 +131,17 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
 
     it 'should return a String' do
       l = {}
-      @uo_util.__guid_add_data(l, :year).should be_an_instance_of String
+      expect(@uo_util.__guid_add_data(l, :year)).to be_an_instance_of String
     end
 
     it 'should return the key you requested by as a String' do
       l = { year: 2014 }
-      @uo_util.__guid_add_data(l, :year).should eql '2014'
+      expect(@uo_util.__guid_add_data(l, :year)).to eql '2014'
     end
 
     it 'should return an empty String if the key does not exist' do
       l = { year: 2014 }
-      @uo_util.__guid_add_data(l, :month).should eql ''
+      expect(@uo_util.__guid_add_data(l, :month)).to eql ''
     end
   end
 
@@ -157,53 +157,53 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
     end
 
     it 'should return a Hash' do
-      @uo_util.add_guid!(@full_line).should be_an_instance_of Hash
+      expect(@uo_util.add_guid!(@full_line)).to be_an_instance_of Hash
     end
 
     it 'should return a Hash that matches the reference' do
-      @uo_util.add_guid!(@full_line).should eql guid_line
+      expect(@uo_util.add_guid!(@full_line)).to eql guid_line
     end
 
     it 'should properly set the :event_guid for killed' do
       x = @uo_util.add_guid!(spec_killed_line)
       y = spec_guid_reference_implementation(spec_killed_line)
-      x.key?(:event_guid).should be_true
-      x[:event_guid].should eql y[:event_guid]
+      expect(x.key?(:event_guid)).to be_true
+      expect(x[:event_guid]).to eql y[:event_guid]
     end
 
     it 'should properly set the :event_guid for died' do
       x = @uo_util.add_guid!(spec_died_line)
       y = spec_guid_reference_implementation(spec_died_line)
-      x.key?(:event_guid).should be_true
-      y[:event_guid].should eql y[:event_guid]
+      expect(x.key?(:event_guid)).to be_true
+      expect(y[:event_guid]).to eql y[:event_guid]
     end
 
     it 'should properly set the :event_guid for wounded' do
       x = @uo_util.add_guid!(spec_wounded_line)
       y = spec_guid_reference_implementation(spec_wounded_line)
-      x.key?(:event_guid).should be_true
-      x[:event_guid].should eql y[:event_guid]
+      expect(x.key?(:event_guid)).to be_true
+      expect(x[:event_guid]).to eql y[:event_guid]
     end
 
     it 'should properly set the :event_guid for announcements' do
       x = @uo_util.add_guid!(spec_announcement_line)
       y = spec_guid_reference_implementation(spec_announcement_line)
-      x.key?(:event_guid).should be_true
-      x[:event_guid].should eql y[:event_guid]
+      expect(x.key?(:event_guid)).to be_true
+      expect(x[:event_guid]).to eql y[:event_guid]
     end
 
     it 'should properly set the :event_guid for beguid' do
       x = @uo_util.add_guid!(spec_beguid_line)
       y = spec_guid_reference_implementation(spec_beguid_line)
-      x.key?(:event_guid).should be_true
-      x[:event_guid].should eql y[:event_guid]
+      expect(x.key?(:event_guid)).to be_true
+      expect(x[:event_guid]).to eql y[:event_guid]
     end
 
     it 'should properly set the :event_guid for chat' do
       x = @uo_util.add_guid!(spec_chat_line)
       y = spec_guid_reference_implementation(spec_chat_line)
-      x.key?(:event_guid).should be_true
-      x[:event_guid].should eql y[:event_guid]
+      expect(x.key?(:event_guid)).to be_true
+      expect(x[:event_guid]).to eql y[:event_guid]
     end
   end
 
@@ -238,8 +238,8 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
       md = @mf.match('2321.3 0.342 123.45')
       %w{server_time damage distance}.each do |m|
         x = @uo_util.__modifiers(md, m)
-        x.should be_an_instance_of Float
-        x.should eql md[m].to_f
+        expect(x).to be_an_instance_of Float
+        expect(x).to eql md[m].to_f
       end
     end
 
@@ -247,16 +247,16 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
       chat = 'Group'
       md = /(?<channel>.*)/.match(chat)
       x = @uo_util.__modifiers(md, 'channel')
-      x.should be_an_instance_of String
-      /[[:lower:]]+/.match(x).should_not be_nil
-      x.should eql chat.downcase
+      expect(x).to be_an_instance_of String
+      expect(/[[:lower:]]+/.match(x)).to_not be_nil
+      expect(x).to eql chat.downcase
     end
 
     it 'should convert the nearby players to Array' do
       md = @ma.match('["one","two","three"]"')
       x = @uo_util.__modifiers(md, 'nearby_players')
-      x.should be_an_instance_of Array
-      x.length.should be 3
+      expect(x).to be_an_instance_of Array
+      expect(x.length).to be 3
     end
   end
 
@@ -275,8 +275,8 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
       md = @mi.match('2014/02/09 14:44:44')
       %w{year month day hour min sec}.each do |m|
         x = @uo_util.__line_modifiers(md, m)
-        x.should be_an_instance_of Fixnum
-        x.should eql md[m].to_i
+        expect(x).to be_an_instance_of Fixnum
+        expect(x).to eql md[m].to_i
       end
     end
 
@@ -284,8 +284,8 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
       md = @mf.match('2321.3 0.342 123.45')
       %w{server_time damage distance}.each do |m|
         x = @uo_util.__modifiers(md, m)
-        x.should be_an_instance_of Float
-        x.should eql md[m].to_f
+        expect(x).to be_an_instance_of Float
+        expect(x).to eql md[m].to_f
       end
     end
 
@@ -293,8 +293,8 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
       d = '042ZYK'
       md = /(?<something>.*)/.match(d)
       x = @uo_util.__line_modifiers(md, 'something')
-      x.should be_an_instance_of md['something'].class
-      x.should eql md['something']
+      expect(x).to be_an_instance_of md['something'].class
+      expect(x).to eql md['something']
     end
   end
 
@@ -313,14 +313,14 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
 
     it 'should return a Hash' do
       h = @uo_util.m_to_h(/.*/.match('thing'))
-      h.should be_an_instance_of Hash
+      expect(h).to be_an_instance_of Hash
     end
 
     it 'should properly convert the correct values to int' do
       md = @mi.match('2014/02/09 14:44:44')
       h = @uo_util.m_to_h(md)
       [:year, :month, :day, :hour, :min, :sec].each do |m|
-        h[m].should be_an_instance_of Fixnum
+        expect(h[m]).to be_an_instance_of Fixnum
       end
     end
 
@@ -328,27 +328,27 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
       md = @mf.match('2321.3 0.342 123.45')
       h = @uo_util.m_to_h(md)
       [:server_time, :damage, :distance].each do |m|
-        h[m].should be_an_instance_of Float
+        expect(h[m]).to be_an_instance_of Float
       end
     end
 
     it 'should convert the nearby players to an Array of Strings' do
       md = @ma.match('["one","two","three"]"')
       h = @uo_util.m_to_h(md)
-      h[:nearby_players].should be_an_instance_of Array
-      h[:nearby_players].length.should be 3
+      expect(h[:nearby_players]).to be_an_instance_of Array
+      expect(h[:nearby_players].length).to be 3
 
       h[:nearby_players].each do |p|
-        p.should be_an_instance_of String
-        p.empty?.should be false
+        expect(p).to be_an_instance_of String
+        expect(p.empty?).to be false
       end
     end
 
     it 'should convert nearby players to an empty Array if it is None' do
       md = @ma.match('None."')
       h = @uo_util.m_to_h(md)
-      h[:nearby_players].should be_an_instance_of Array
-      h[:nearby_players].empty?.should be_true
+      expect(h[:nearby_players]).to be_an_instance_of Array
+      expect(h[:nearby_players].empty?).to be_true
     end
   end
 
@@ -367,17 +367,17 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
 
     it 'should return nil if the key does not exist' do
       h = { one: 'two' }
-      @uo_util.validate_bool_opt(h, :two).should be_nil
+      expect(@uo_util.validate_bool_opt(h, :two)).to be_nil
     end
 
     it 'should return nil if the key is true' do
       h = { x: true }
-      @uo_util.validate_bool_opt(h, :x).should be_nil
+      expect(@uo_util.validate_bool_opt(h, :x)).to be_nil
     end
 
     it 'should return nil if the key is false' do
       h = { x: false }
-      @uo_util.validate_bool_opt(h, :x).should be_nil
+      expect(@uo_util.validate_bool_opt(h, :x)).to be_nil
     end
 
     it 'should raise ArgumentError if the key is a String' do
@@ -431,7 +431,7 @@ describe RMuh::RPT::Log::Util::UnitedOperations do
     end
 
     it 'should return nil if arg 1 is an instance of TZInfo::DataTimezone' do
-      @uo_util.validate_timezone(timezone: uo_tz).should be_nil
+      expect(@uo_util.validate_timezone(timezone: uo_tz)).to be_nil
     end
 
     it 'should raise ArgumentError if arg 1 is a String' do