steam_hlds_log_parser 0.4.9 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
-SHA512: 
-  data.tar.gz: 08cb3bad994427212c11fe525b01f3070026ee629ecf59d6d885501112868755babe41c6feb05978f7a197d12c0da6f41a7ba531f5bc676af0c49f96b0676578
-  metadata.gz: 14e277ccb27704544482fade1bbe62309a311ce29929d48f99c2f0bbd59392752aa6d846d7ffee645379db04d5acf092fbba5d09d368e7f8b9bb99aa29ec3068
 SHA1: 
-  data.tar.gz: c5637bd10ef2466395f66221b4a0e4122a6fff56
-  metadata.gz: 04231e210d86a8e6b14a24cd6c9b9f6151bfa0b3
+  metadata.gz: 0d6f4970900f52377acd0e1b941a3b9929afadec
+  data.tar.gz: c899a1a093ffdbd74130d2d0df208aee17427e8f
+SHA512: 
+  metadata.gz: 20193bfa2615cd4ff28c46d4ede73655dc2ba6dd2f8ad9bc8c296444efcda8e2009cb7b7c699a9157e7625965c6e1e2e1262791598065dab8f9a6911fae6d966
+  data.tar.gz: 6cee787d6eb11cb295d8634f53f259b586b510d3f3630b916a7e845a5930fcd9e9f8e546b1275b00b0a2490a4d9106808f3f946f63f5064c450b1220464ee90e

data/lib/steam_hlds_log_parser/version.rb

@@ -1,4 +1,4 @@
 module SteamHldsLogParser
   # Gem Version
-  VERSION = "0.4.9"
+  VERSION = "0.5.0"
 end

data/spec/client_spec.rb

@@ -16,88 +16,87 @@ module SteamHldsLogParser
       context "when a 'Client' is created with default options"
       it { should be_an_instance_of Client }
       it "has a 'displayer'" do
-        default_client.displayer.should_not be_nil      
-        default_client.displayer.class.should be(Class)
-        default_client.displayer.should be(RSpecDisplayer)
+        expect(default_client.displayer).not_to be_nil      
+        expect(default_client.displayer.class).to be(Class)
+        expect(default_client.displayer).to be(RSpecDisplayer)
       end
       it "has a default 'options' Hash" do
-        default_client.options.should_not be_nil      
-        default_client.options.class.should be(Hash)
+        expect(default_client.displayer).not_to be_nil      
+        expect(default_client.displayer.class).to be(Class)
       end
       it "has a default 'host'" do
-        default_client.options[:host].should_not be_nil      
-        default_client.options[:host].should eq("0.0.0.0")
+        expect(default_client.options[:host]).not_to be_nil      
+        expect(default_client.options[:host]).to eq("0.0.0.0")      
       end
       it "has a default 'port'" do
-        default_client.options[:port].should_not be_nil      
-        default_client.options[:port].should eq(27115)
+        expect(default_client.options[:port]).not_to be_nil      
+        expect(default_client.options[:port]).to be(27115)
       end
       it "has a default 'locale'" do
-        default_client.options[:locale].should_not be_nil      
-        default_client.options[:locale].class.should eq(Symbol)      
-        default_client.options[:locale].should eq(:en)
+        expect(default_client.options[:locale]).not_to be_nil      
+        expect(default_client.options[:locale].class).to be(Symbol)
+        expect(default_client.options[:locale]).to be(:en)
       end
       it "has a default 'display_kills'" do
-        default_client.options[:display_kills].should_not be_nil      
-        default_client.options[:display_kills].should be(true)
+        expect(default_client.options[:display_kills]).not_to be_nil      
+        expect(default_client.options[:display_kills]).to be_true      
       end
       it "has a default 'display_actions'" do
-        default_client.options[:display_actions].should_not be_nil      
-        default_client.options[:display_actions].should be(true)
+        expect(default_client.options[:display_actions]).not_to be_nil      
+        expect(default_client.options[:display_actions]).to be_true      
       end
       it "has a default 'display_changelevel'" do
-        default_client.options[:display_changelevel].should_not be_nil      
-        default_client.options[:display_changelevel].should be(true)
+        expect(default_client.options[:display_changelevel]).not_to be_nil      
+        expect(default_client.options[:display_changelevel]).to be_true      
       end
       it "has a default 'display_chat'" do
-        default_client.options[:display_chat].should_not be_nil      
-        default_client.options[:display_chat].should be(true)
+        expect(default_client.options[:display_chat]).not_to be_nil      
+        expect(default_client.options[:display_chat]).to be_true      
       end
       it "has a default 'display_team_chat'" do
-        default_client.options[:display_team_chat].should_not be_nil      
-        default_client.options[:display_team_chat].should be(true)
+        expect(default_client.options[:display_team_chat]).not_to be_nil      
+        expect(default_client.options[:display_team_chat]).to be_true      
       end
 
       subject(:custom_client) { Client.new(RSpecDisplayer, custom_options) }
       context "when custom parameters are given"
       it { should be_an_instance_of Client }
       it "has a default 'options' Hash" do
-        custom_client.options.should_not be_nil      
-        custom_client.options.should_not be(nil)
-        custom_client.options.class.should be(Hash)
+        expect(custom_client.options).not_to be_nil      
+        expect(custom_client.options.class).to be(Hash)      
       end
       it "has a custom 'host'" do
-        custom_client.options[:host].should_not be_nil      
-        custom_client.options[:host].should eq("127.0.0.1")
+        expect(custom_client.options[:host]).not_to be_nil      
+        expect(custom_client.options[:host]).to eq("127.0.0.1")      
       end
       it "has a custom 'port'" do
-        custom_client.options[:port].should_not be_nil      
-        custom_client.options[:port].should eq(12345)
+        expect(custom_client.options[:port]).not_to be_nil      
+        expect(custom_client.options[:port]).to be(12345)  
       end
       it "has a custom 'locale'" do
-        custom_client.options[:locale].should_not be_nil      
-        custom_client.options[:locale].class.should eq(Symbol)      
-        custom_client.options[:locale].should eq(:fr)
+        expect(custom_client.options[:locale]).not_to be_nil      
+        expect(custom_client.options[:locale].class).to be(Symbol)      
+        expect(custom_client.options[:locale]).to be(:fr)  
       end
       it "has a custom 'display_kills'" do
-        custom_client.options[:display_kills].should_not be_nil      
-        custom_client.options[:display_kills].should be(false)
+        expect(custom_client.options[:display_kills]).not_to be_nil      
+        expect(custom_client.options[:display_kills]).to be_false  
       end
       it "has a custom 'display_actions'" do
-        custom_client.options[:display_actions].should_not be_nil      
-        custom_client.options[:display_actions].should be(false)
+        expect(custom_client.options[:display_actions]).not_to be_nil      
+        expect(custom_client.options[:display_actions]).to be_false      
       end
       it "has a custom 'display_changelevel'" do
-        custom_client.options[:display_changelevel].should_not be_nil      
-        custom_client.options[:display_changelevel].should be(false)
+        expect(custom_client.options[:display_changelevel]).not_to be_nil      
+        expect(custom_client.options[:display_changelevel]).to be_false      
       end
       it "has a custom 'display_chat'" do
-        custom_client.options[:display_chat].should_not be_nil      
-        custom_client.options[:display_chat].should be(false)
+        expect(custom_client.options[:display_chat]).not_to be_nil      
+        expect(custom_client.options[:display_chat]).to be_false      
       end
       it "has a custom 'display_team_chat'" do
-        custom_client.options[:display_team_chat].should_not be_nil      
-        custom_client.options[:display_team_chat].should be(false)
+        expect(custom_client.options[:display_team_chat]).not_to be_nil      
+        expect(custom_client.options[:display_team_chat]).to be_false      
       end
 
       describe "#start and #stop" do
@@ -105,9 +104,9 @@ module SteamHldsLogParser
         context "when 'start' and 'stop' are triggered one after the other"
         it "starts then stops an eventmachine with appropriate messages" do
           EM.run {
-            capture_stdout { default_client.start }.should eq("## 0.0.0.0:27115 => HLDS connected and sending data\n")
+            expect(capture_stdout { default_client.start }).to eq("## 0.0.0.0:27115 => HLDS connected and sending data\n")
             EM.add_timer(0.2) {
-              capture_stdout { default_client.stop }.should eq("## 0.0.0.0:27115 => HLDS Log Parser stopped.\n")
+              expect(capture_stdout { default_client.stop }).to eq("## 0.0.0.0:27115 => HLDS Log Parser stopped.\n")
             }
           }
         end

data/spec/displayer_spec.rb

@@ -20,33 +20,33 @@ module SteamHldsLogParser
       context "when 'data' is given" do
 
         it "creates a 'Displayer'" do
-          @displayer.should be_an_instance_of Displayer
+          expect(@displayer).to be_an_instance_of Displayer
         end
 
         describe "#get_data" do
           it "returns 'data' given as argument" do
-            @displayer.get_data.should_not be_nil      
-            @displayer.get_data.should be(@data)      
+            expect(@displayer.get_data).not_to be_nil      
+            expect(@displayer.get_data).to be(@data)      
           end
         end
 
         describe "#display_data" do
           it "displays 'data' given as argument" do
-            eval(capture_stdout { @displayer.display_data }).should eq(@data)
+            expect(eval(capture_stdout { @displayer.display_data })).to eq(@data)
           end
         end
 
         describe "#get_translation" do
           it "returns translated 'data' given as argument" do
-            @displayer.get_translation.should_not be_nil      
-            @displayer.get_translation.class.should be(String)      
-            @displayer.get_translation.should eq("[CT] 3 - 0 [T]")      
+            expect(@displayer.get_translation).not_to be_nil      
+            expect(@displayer.get_translation.class).to be(String)      
+            expect(@displayer.get_translation).to eq("[CT] 3 - 0 [T]")      
           end
         end
 
         describe "#display_translation" do
           it "displays translated 'data' given as argument" do
-            capture_stdout { @displayer.display_translation }.should eq("[CT] 3 - 0 [T]\n")
+            expect(capture_stdout { @displayer.display_translation }).to eq("[CT] 3 - 0 [T]\n")
           end
         end
 

data/spec/handler_spec.rb

@@ -24,23 +24,23 @@ module SteamHldsLogParser
         context "when 'host' and 'port' are given"
         it { should be_an_instance_of Handler }
         it "has a 'host' option" do
-          @handler.options[:host].should_not be_nil      
-          @handler.options[:host].should eq("0.0.0.0")
+          expect(@handler.options[:host]).not_to be_nil      
+          expect(@handler.options[:host]).to eq("0.0.0.0")
         end
         it "has a 'port' option" do
-          @handler.options[:port].should_not be_nil      
-          @handler.options[:port].should eq(27115)
+          expect(@handler.options[:port]).not_to be_nil      
+          expect(@handler.options[:port]).to be(27115)
         end
 
         describe "#post_init" do
           it "displays a console message when hlds connects" do
-            capture_stdout { @handler.post_init }.should eq("## 0.0.0.0:27115 => HLDS connected and sending data\n")
+            expect(capture_stdout { @handler.post_init }).to eq("## 0.0.0.0:27115 => HLDS connected and sending data\n")
           end
         end
 
         describe "#unbind" do
           it "displays a console message when hlds disconnects" do
-            capture_stdout { @handler.unbind }.should eq("## 0.0.0.0:27115 => HLDS disconnected? No data is received.\n")
+            expect(capture_stdout { @handler.unbind }).to eq("## 0.0.0.0:27115 => HLDS disconnected? No data is received.\n")
           end
         end
 
@@ -49,7 +49,7 @@ module SteamHldsLogParser
           context "when data is not supported" do
             it "returns anything" do
               data = '# L 05/10/2000 - 12:34:56: I am a fake line of log'
-              @handler.receive_data(data).should eq(nil)
+              expect(@handler.receive_data(data)).to be_nil
             end
           end
 
@@ -58,9 +58,9 @@ module SteamHldsLogParser
               data = '# L 05/10/2000 - 12:34:56: Team "CT" scored "17" with "0" players"'
               expected = {:type=>"map_ends", :params=>{:winner=>"CT", :score=>"17"}}
               puts @handler.receive_data(data)
-              @handler.receive_data(data).class.should eq(RSpecDisplayer)
-              @handler.receive_data(data).data.should eq(expected)
-              @handler.receive_data(data).data.class.should eq(Hash)
+              expect(@handler.receive_data(data).class).to be(RSpecDisplayer)
+              expect(@handler.receive_data(data).data).to eq(expected)
+              expect(@handler.receive_data(data).data.class).to be(Hash)
             end
           end
 
@@ -68,9 +68,9 @@ module SteamHldsLogParser
             it "returns Hash on victory" do
               data = '# L 05/10/2000 - 12:34:56: Team "CT" triggered "CTs_Win" (CT "3") (T "0")'
               expected = {:type=>"victory", :params=>{:score_ct=>"3", :score_t=>"0"}}
-              @handler.receive_data(data).class.should eq(RSpecDisplayer)
-              @handler.receive_data(data).data.should eq(expected)
-              @handler.receive_data(data).data.class.should eq(Hash)
+              expect(@handler.receive_data(data).class).to be(RSpecDisplayer)
+              expect(@handler.receive_data(data).data).to eq(expected)
+              expect(@handler.receive_data(data).data.class).to be(Hash)
             end
           end
 
@@ -78,9 +78,9 @@ module SteamHldsLogParser
             it "returns Hash on killed" do
               data = '# L 05/10/2000 - 12:34:56: "Killer | Player<66><STEAM_ID_LAN><TERRORIST>" killed "Killed | Player<60><STEAM_ID_LAN><CT>" with "ak47"'
               expected = {:type=>"kill", :params => {:killer_team=>"T", :killer=>"Killer | Player",  :killed_team=>"CT", :killed=>"Killed | Player", :weapon=>"ak47"}}
-              @handler.receive_data(data).class.should eq(RSpecDisplayer)
-              @handler.receive_data(data).data.should eq(expected)
-              @handler.receive_data(data).data.class.should eq(Hash)
+              expect(@handler.receive_data(data).class).to be(RSpecDisplayer)
+              expect(@handler.receive_data(data).data).to eq(expected)
+              expect(@handler.receive_data(data).data.class).to be(Hash)
             end
           end
 
@@ -88,9 +88,9 @@ module SteamHldsLogParser
             it "returns Hash on killed" do
               data = '# L 05/10/2000 - 12:34:56: "Killer | Player<66><STEAM_0:0:12345><TERRORIST>" killed "Killed | Player<60><STEAM_0:0:12345><CT>" with "ak47"'
               expected = {:type=>"kill", :params => {:killer_team=>"T", :killer=>"Killer | Player",  :killed_team=>"CT", :killed=>"Killed | Player", :weapon=>"ak47"}}
-              @handler.receive_data(data).class.should eq(RSpecDisplayer)
-              @handler.receive_data(data).data.should eq(expected)
-              @handler.receive_data(data).data.class.should eq(Hash)
+              expect(@handler.receive_data(data).class).to be(RSpecDisplayer)
+              expect(@handler.receive_data(data).data).to eq(expected)
+              expect(@handler.receive_data(data).data.class).to be(Hash)
             end
           end
 
@@ -98,9 +98,9 @@ module SteamHldsLogParser
             it "returns Hash on suicide" do
               data = '# L 05/10/2000 - 12:34:56: "Player<66><STEAM_ID_LAN><TERRORIST>" committed suicide with "worldspawn" (world)'
               expected = {:type=>"suicide", :params=>{:killed=>"Player"}}
-              @handler.receive_data(data).class.should eq(RSpecDisplayer)
-              @handler.receive_data(data).data.should eq(expected)
-              @handler.receive_data(data).data.class.should eq(Hash)
+              expect(@handler.receive_data(data).class).to be(RSpecDisplayer)
+              expect(@handler.receive_data(data).data).to eq(expected)
+              expect(@handler.receive_data(data).data.class).to be(Hash)
             end
           end
 
@@ -108,9 +108,9 @@ module SteamHldsLogParser
             it "returns Hash on suicide" do
               data = '# L 05/10/2000 - 12:34:56: "Player<66><STEAM_0:0:12345><TERRORIST>" committed suicide with "worldspawn" (world)'
               expected = {:type=>"suicide", :params=>{:killed=>"Player"}}
-              @handler.receive_data(data).class.should eq(RSpecDisplayer)
-              @handler.receive_data(data).data.should eq(expected)
-              @handler.receive_data(data).data.class.should eq(Hash)
+              expect(@handler.receive_data(data).class).to be(RSpecDisplayer)
+              expect(@handler.receive_data(data).data).to eq(expected)
+              expect(@handler.receive_data(data).data.class).to be(Hash)
             end
           end
 
@@ -118,9 +118,9 @@ module SteamHldsLogParser
             it "returns Hash on event" do
               data = '# L 05/10/2000 - 12:34:56: "Killer | Player<66><STEAM_ID_LAN><CT>" triggered "Defused_The_Bomb"'
               expected = {:type=>"event", :params=> {:person_team=>"CT", :person=>"Killer | Player", :event_item=>"Defused_The_Bomb", :event_i18n=>"defused the bomb"}}
-              @handler.receive_data(data).class.should eq(RSpecDisplayer)
-              @handler.receive_data(data).data.should eq(expected)
-              @handler.receive_data(data).data.class.should eq(Hash)
+              expect(@handler.receive_data(data).class).to be(RSpecDisplayer)
+              expect(@handler.receive_data(data).data).to eq(expected)
+              expect(@handler.receive_data(data).data.class).to be(Hash)
             end
           end
 
@@ -128,9 +128,9 @@ module SteamHldsLogParser
             it "returns Hash on event" do
               data = '# L 05/10/2000 - 12:34:56: "Killer | Player<66><STEAM_0:0:12345><CT>" triggered "Defused_The_Bomb"'
               expected = {:type=>"event", :params=> {:person_team=>"CT", :person=>"Killer | Player", :event_item=>"Defused_The_Bomb", :event_i18n=>"defused the bomb"}}
-              @handler.receive_data(data).class.should eq(RSpecDisplayer)
-              @handler.receive_data(data).data.should eq(expected)
-              @handler.receive_data(data).data.class.should eq(Hash)
+              expect(@handler.receive_data(data).class).to be(RSpecDisplayer)
+              expect(@handler.receive_data(data).data).to eq(expected)
+              expect(@handler.receive_data(data).data.class).to be(Hash)
             end
           end
 
@@ -138,9 +138,9 @@ module SteamHldsLogParser
             it "returns Hash on changelevel" do
               data = '# L 05/10/2000 - 12:34:56: Loading map "de_dust2"'
               expected = {:type=>"loading_map", :params=>{:map=>"de_dust2"}}
-              @handler.receive_data(data).class.should eq(RSpecDisplayer)
-              @handler.receive_data(data).data.should eq(expected)
-              @handler.receive_data(data).data.class.should eq(Hash)
+              expect(@handler.receive_data(data).class).to be(RSpecDisplayer)
+              expect(@handler.receive_data(data).data).to eq(expected)
+              expect(@handler.receive_data(data).data.class).to be(Hash)
             end
           end
 
@@ -148,9 +148,9 @@ module SteamHldsLogParser
             it "returns Hash on changelevel" do
               data = '# L 05/10/2000 - 12:34:56: "Player<15><STEAM_0:0:12345><TERRORIST>" say "gg" (dead)'
               expected = {:type=>"chat", :params=>{:player=>"Player", :player_team=>"T", :chat=>"gg"}}
-              @handler.receive_data(data).class.should eq(RSpecDisplayer)
-              @handler.receive_data(data).data.should eq(expected)
-              @handler.receive_data(data).data.class.should eq(Hash)
+              expect(@handler.receive_data(data).class).to be(RSpecDisplayer)
+              expect(@handler.receive_data(data).data).to eq(expected)
+              expect(@handler.receive_data(data).data.class).to be(Hash)
             end
           end
           
@@ -158,9 +158,9 @@ module SteamHldsLogParser
             it "returns Hash on changelevel" do
               data = '# L 05/10/2000 - 12:34:56: "Player<15><STEAM_0:0:12345><TERRORIST>" say_team "Rush B"'
               expected = {:type=>"team_chat", :params=>{:player=>"Player", :player_team=>"T", :chat=>"Rush B"}}
-              @handler.receive_data(data).class.should eq(RSpecDisplayer)
-              @handler.receive_data(data).data.should eq(expected)
-              @handler.receive_data(data).data.class.should eq(Hash)
+              expect(@handler.receive_data(data).class).to be(RSpecDisplayer)
+              expect(@handler.receive_data(data).data).to eq(expected)
+              expect(@handler.receive_data(data).data.class).to be(Hash)
             end
           end
 
@@ -169,9 +169,9 @@ module SteamHldsLogParser
             it "returns Hash on changelevel provided by 'displayer'" do
               data = '# L 05/10/2000 - 12:34:56: Loading map "de_dust2"'
               expected = {:type=>"loading_map", :params=>{:map=>"de_dust2"}}
-              @custom_handler.displayer.should eq(RSpecDisplayer)
-              @custom_handler.options[:display_changelevel].should be(true)
-              @custom_handler.receive_data(data).data.should eq(expected)
+              expect(@custom_handler.displayer).to be(RSpecDisplayer)
+              expect(@custom_handler.options[:display_changelevel]).to be_true
+              expect(@custom_handler.receive_data(data).data).to eq(expected)
             end
           end
 
@@ -180,16 +180,16 @@ module SteamHldsLogParser
         describe "#get_full_team_name" do
           context "when short name is given"
           it "returns full name" do
-            @handler.get_full_team_name("T").should eq("Terrorist")
-            @handler.get_full_team_name("CT").should eq("Counter-Terrorist")
+            expect(@handler.get_full_team_name("T")).to eq("Terrorist")
+            expect(@handler.get_full_team_name("CT")).to eq("Counter-Terrorist")
           end
         end
 
         describe "#get_short_team_name" do
           context "when full name is given"
           it "returns short name" do
-            @handler.get_short_team_name("TERRORIST").should eq("T")
-            @handler.get_short_team_name("CT").should eq("CT")
+            expect(@handler.get_short_team_name("TERRORIST")).to eq("T")
+            expect(@handler.get_short_team_name("CT")).to eq("CT")
           end
         end
 

data/spec/log_tester_spec.rb

@@ -17,10 +17,10 @@ module SteamHldsLogParser
             f.each_line do |line|
               obj = @handler.receive_data(line)
               unless obj.nil?
-                obj.class.should eq(RSpecDisplayer)
+                expect(obj.class).to be(RSpecDisplayer)
                 hash = obj.data
                 string = Displayer.new(hash).get_translation
-                string.class.should eq(String)
+                expect(string.class).to be(String)
               end
             end
           end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: steam_hlds_log_parser
 version: !ruby/object:Gem::Version 
-  version: 0.4.9
+  version: 0.5.0
 platform: ruby
 authors: 
 - Thomas VIAL
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-08-21 00:00:00 Z
+date: 2013-08-26 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: bundler