rmuh 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee6d35d0861a94192af934236bc6f749b43bf1ae
-  data.tar.gz: aae69a679fff65aa138f6f9328894f3403d444c0
+  metadata.gz: b63c73ace7a1211a2f87a68c08d9eb59214a5735
+  data.tar.gz: 6c8be181f4208f9d26c280af1b3247937fafcac8
 SHA512:
-  metadata.gz: 55e40a5069510f01a0f6b5957596184ff994b0f33a0b78a9666194f521e7520e7200689bd04d06ccb357f3e627622295be480a6a95e7d7dd0bc213604ceb79a7
-  data.tar.gz: d3e196a3bd246975d82fea8b7bfe08bff3ab947dd106fb5cf9ae6ba3f6b0a8390c54c68bd12ef318f848a3cff85d03d02250d4aa633f534cd2f728c183b0658f
+  metadata.gz: cb90e1fa7a2be37278be469d1fca17011907eec6f3abdb00c738dca5b78f0d8e85871a5da8b7336c3be766e0c8c4671d21f2d0b3b558a007146788845ee7ed7b
+  data.tar.gz: 40aacc1f5594affb5790f186a77c4b4f11e6a46df9f5f0ff4853af359b348873f132845d323015aa0f04b0152deb72aa110454aba44c7d11799b81b3ac7baa4e

data/.travis.yml

@@ -5,4 +5,4 @@ rvm:
 - 1.9.3
 notifications:
   email:
-  - tim+travisci@timheckman.net
+  - t+travisci@heckman.io

data/README.md

@@ -29,7 +29,7 @@ INSTALLATION
 This is packaged on the [RubyGems](https://rubygems.org/) site and can be
 installed via the `gem` command:
 
-```Ruby
+```Bash
 $ gem install rmuh
 ```
 
@@ -121,8 +121,8 @@ information directly from the server.
 
 Here is a quick overview of how to use this functionality:
 
-```
-require 'rmuh/serverstats/base
+```Ruby
+require 'rmuh/serverstats/base'
 UO_IP = '70.42.74.59'
 s = RMuh::ServerStats::Base.new(host: UO_IP)
 s.update_cache
@@ -135,14 +135,14 @@ the object.
 
 If you want to avoid using the cache:
 
-```
+```Ruby
 s = RMuh::ServerStats::Base.new(host: UO_IP, cache: false)
 ```
 If you want to be able to pull each part of the returned data set using
 dot-notation, you can use the `Advanced` class:
 
-```
-require 'rmuh/serverstats/base
+```Ruby
+require 'rmuh/serverstats/base'
 s = RMuh::ServerStats::Advanced.new(host: UO_IP)
 s.update_cache
 puts s.players

data/Rakefile

@@ -4,12 +4,9 @@ require 'rubocop/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-Rubocop::RakeTask.new(:rubocop) do |task|
-  task.patterns = [
-    'lib/**/*.rb', 'spec/*_spec.rb', 'Rakefile', 'rmuh.gemspec', 'Gemfile'
-  ]
-  # task.formatters = ['files']
-  task.fail_on_error = true
+Rubocop::RakeTask.new(:rubocop) do |t|
+  t.patterns = %w{ Rakefile Gemfile rmuh.gemspec lib/**/*.rb spec/*_spec.rb }
+  t.fail_on_error = true
 end
 
 task default: [:rubocop, :spec]

data/examples/basic_parsing.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+# This example file shows you how to do the following:
+# * fetch the size of a log
+# * fetch the first KB of log file
+# * parse the log with the base parser
+# * use awesome_print to print out the returned object
+#
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rmuh/rpt/log/fetch'
+require 'rmuh/rpt/log/parsers/base'
+require 'ap'
+
+# set a constant for the URL
+URL = 'http://arma2.unitedoperations.net/dump/SRV1/SRV1_LOG.txt'
+
+# instantiate a new fetcher object, telling it to get the first
+# 1024 bytes
+f = RMuh::RPT::Log::Fetch.new(URL, byte_start: 0, byte_end: 1024)
+
+# logfile will become a StringIO object that is the contents of the log
+logfile = f.log
+
+# print the log
+puts "#### The full log\n#{logfile.readlines.join("\n")}\n#### End of log!"
+
+# print the size of the log, f.size will return a Fixnum in bytes
+puts "Log size: #{f.size} byte(s)"
+
+# instantiate a new base parser, it takes no args
+p = RMuh::RPT::Log::Parsers::Base.new
+
+# this becomes an array of hashes, each item in the Array is a metadata
+# Hash for that specific log line
+parsed = p.parse(f.log)
+
+puts '#### Metadata Hash'
+ap parsed
+puts '#### End of Hashes'

data/examples/basic_serverstats.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+# This example shows you how to use the ServerStats class to pull real-time
+# information about the server from the GameSpy protocol
+#
+# This includes map name, mission name, player list, game version, required
+# mods, and a bunch of other information.
+#
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rmuh/serverstats/base'
+require 'ap'
+
+# specify the UnitedOperations server
+SRV = { host: 'srv1.unitedoperations.net', port: 2_302 }
+
+# get an instance of ServerStats and print the stats
+# by default this is a blocking operation. See serverstats_cache.rb for
+# alternative options
+s = RMuh::ServerStats::Base.new(host: SRV[:host], port: SRV[:port])
+ap s.stats

data/examples/serverstats_advanced.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+# This shows you how to use the ServerStats::Advanced class. The only
+# difference between ::Base and ::Advanced is that Advanced gives you stats
+# accessors using dot notation. You can see more about the ::Base class within
+# the basic_serverstats.rb file
+#
+# It also has all the same caching characteristics as the ::Base class and you
+# can learn more about those in the serverstats_cache.rb file.
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rmuh/serverstats/advanced'
+require 'ap'
+
+# specify the UnitedOperations server
+SRV = { host: 'srv1.unitedoperations.net', port: 2_302 }
+
+# build a new instance of ::Advanced
+s = RMuh::ServerStats::Advanced.new(host: SRV[:host], port: SRV[:port])
+
+# print the full stats out
+ap s.stats
+
+# print only the players Array
+ap s.players

data/examples/serverstats_cache.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+# By default the ServerStats::Base class caches the information from the
+# server in memory. By default the class is a blocking operation on the first
+# call to '.stats'. That's because if the cache is not populated it will
+# poll the server.
+#
+# You can avoid this being blocking by setting 'auto_cache: false'. This means,
+# however, that you will need to call the '.update_cache' method when you can
+# afford a blocking operation
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rmuh/serverstats/base'
+require 'ap'
+
+# specify the UnitedOperations server
+SRV = { host: 'srv1.unitedoperations.net', port: 2_302 }
+
+s = RMuh::ServerStats::Base.new(
+  host: SRV[:host], port: SRV[:port], auto_cache: false
+)
+ap s.stats # this should be nil
+
+# update the cache within the object from the server, then print the stats
+s.update_cache
+ap s.stats
+
+# You can also turn off the cache completely, which means '.stats' will be a
+# blocking call each time. You do this by passing 'cache: false'
+s = RMuh::ServerStats::Base.new(
+  host: SRV[:host], port: SRV[:port], cache: false
+)
+
+ap s.stats

data/lib/rmuh/serverstats/advanced.rb

@@ -11,8 +11,8 @@ module RMuh
     #
     class Advanced < RMuh::ServerStats::Base
       def method_missing(method, *args, &block)
-        super unless stats.key?(method)
-        stats[method]
+        super unless stats.key?(method.to_s)
+        stats[method.to_s]
       end
     end
   end

data/lib/rmuh/serverstats/base.rb

@@ -41,6 +41,7 @@ module RMuh
         fail ArgumentError, ':host is required' unless opts.key?(:host)
         opts[:port] ||= DEFAULT_PORT
         opts[:cache] = true unless opts.key?(:cache)
+        opts[:auto_cache] = true unless opts.key?(:auto_cache)
         nil
       end
 
@@ -50,6 +51,7 @@ module RMuh
 
       def remote_stats
         if @cache
+          update_cache if @serverstats.nil? && @auto_cache
           @serverstats
         else
           sync

data/lib/rmuh/version.rb

@@ -6,7 +6,7 @@
 module RMuh
   VERSION_MAJ ||= 0
   VERSION_MIN ||= 2
-  VERSION_REV ||= 1
+  VERSION_REV ||= 2
 
   VERSION ||= "#{VERSION_MAJ}.#{VERSION_MIN}.#{VERSION_REV}"
 end

data/spec/examples_spec.rb

@@ -0,0 +1,46 @@
+# -*- coding: UTF-8 -*-
+# These are just specs to make sure the example files run with an exit
+# code of zero.
+#
+require 'rspec'
+require 'open3'
+require 'helpers/spec_helper'
+
+DIR = File.expand_path('../../examples', __FILE__)
+
+describe 'exampple files' do
+
+  context "#{File.join(DIR, 'basic_parsing.rb')}" do
+    it 'should run and return a zero exit code' do
+      _, _, s = Open3.capture3("ruby #{File.join(DIR, 'basic_parsing.rb')}")
+      expect(s.success?).to be_true
+    end
+  end
+
+  context "#{File.join(DIR, 'basic_serverstats.rb')}" do
+    it 'should run and return a zero exit code' do
+      _, _, s = Open3.capture3(
+        "ruby #{File.join(DIR, 'basic_serverstats.rb')}"
+      )
+      expect(s.success?).to be_true
+    end
+  end
+
+  context "#{File.join(DIR, 'serverstats_advanced.rb')}" do
+    it 'should run and return a zero exit code' do
+      _, _, s = Open3.capture3(
+        "ruby #{File.join(DIR, 'serverstats_advanced.rb')}"
+      )
+      expect(s.success?).to be_true
+    end
+  end
+
+  context "#{File.join(DIR, 'serverstats_cache.rb')}" do
+    it 'should run an return a zero exit code' do
+      _, _, s = Open3.capture3(
+        "ruby #{File.join(DIR, 'serverstats_cache.rb')}"
+      )
+      expect(s.success?).to be_true
+    end
+  end
+end

data/spec/rmuh_rpt_log_fetch_spec.rb

@@ -11,28 +11,30 @@ describe RMuh::RPT::Log::Fetch do
   end
   let(:fetch) { RMuh::RPT::Log::Fetch.new(url) }
   context '#new' do
+    subject { fetch }
+
     it 'should return an instance of RMuh::RPT::Log::Fetch' do
-      fetch.should be_an_instance_of RMuh::RPT::Log::Fetch
+      expect(fetch).to be_an_instance_of RMuh::RPT::Log::Fetch
     end
 
     it 'should have a @log_url object which is an instance of String' do
-      fetch.log_url.should be_an_instance_of String
+      expect(fetch.log_url).to be_an_instance_of String
     end
 
     it 'should set the "byte_start" config item if specified' do
       rlfetch = RMuh::RPT::Log::Fetch.new(url, byte_start: 10)
-      rlfetch.byte_start.should eql 10
+      expect(rlfetch.byte_start).to eql 10
     end
 
     it 'should set the "byte_end" config item if specified' do
       rlfetch = RMuh::RPT::Log::Fetch.new(url, byte_end: 42)
-      rlfetch.byte_end.should eql 42
+      expect(rlfetch.byte_end).to eql 42
     end
   end
 
   context '#byte_start' do
     it 'should allow setting the value to Integer' do
-      expect { fetch.byte_start = 10 }.not_to raise_error
+      expect { fetch.byte_start = 10 }.to_not raise_error
     end
 
     it 'should raise an error if the value is nil' do
@@ -49,17 +51,17 @@ describe RMuh::RPT::Log::Fetch do
 
     it 'should update the @cfg.byte_start value' do
       fetch.byte_start = 10
-      fetch.byte_start.should eql 10
+      expect(fetch.byte_start).to eql 10
     end
   end
 
   context '#byte_end' do
     it 'should allow setting the value to Integer' do
-      expect { fetch.byte_end = 10 }.not_to raise_error
+      expect { fetch.byte_end = 10 }.to_not raise_error
     end
 
     it 'should allow setting the value is nil' do
-      expect { fetch.byte_end = nil }.not_to raise_error
+      expect { fetch.byte_end = nil }.to_not raise_error
     end
 
     it 'should raise an error if arg:1 is a String' do
@@ -72,27 +74,27 @@ describe RMuh::RPT::Log::Fetch do
 
     it 'should update the @cfg.byte_end value' do
       fetch.byte_end = 42
-      fetch.byte_end.should eql 42
+      expect(fetch.byte_end).to eql 42
     end
   end
 
   context '#size' do
     it 'should return a Integer object' do
-      fetch.size.should be_an_instance_of Fixnum
+      expect(fetch.size).to be_an_instance_of Fixnum
     end
 
     it 'should return the size' do
-      fetch.size.should eql 10
+      expect(fetch.size).to eql 10
     end
   end
 
   context '#log' do
     it 'should return a StringIO object' do
-      fetch.log.should be_an_instance_of StringIO
+      expect(fetch.log).to be_an_instance_of StringIO
     end
 
     it 'should return the log' do
-      fetch.log.read.should eql "RSpec, yo\n"
+      expect(fetch.log.read).to eql "RSpec, yo\n"
     end
   end
 
@@ -101,12 +103,12 @@ describe RMuh::RPT::Log::Fetch do
     let(:dos_newline) { /\r\n$/ }
 
     it 'should match the Regexp object' do
-      expect(dos_newline.match(dos)).not_to be nil
+      expect(dos_newline.match(dos)).to_not be nil
     end
 
     it 'should strip out DOS new lines' do
       match = /\r\n/.match(fetch.send(:dos2unix, dos))
-      match.should be nil
+      expect(match).to be_nil
     end
   end
 end

data/spec/rmuh_rpt_log_parsers_base_spec.rb

@@ -12,7 +12,7 @@ describe RMuh::RPT::Log::Parsers::Base do
 
   context 'text' do
     it 'should be a StringIO object' do
-      text.should be_an_instance_of StringIO
+      expect(text).to be_an_instance_of StringIO
     end
   end
 
@@ -24,7 +24,7 @@ describe RMuh::RPT::Log::Parsers::Base do
     end
 
     it 'should return an instance of RMuh::RPT::Log::Parsers::Base' do
-      base.should be_an_instance_of RMuh::RPT::Log::Parsers::Base
+      expect(base).to be_an_instance_of RMuh::RPT::Log::Parsers::Base
     end
   end
 
@@ -37,21 +37,44 @@ describe RMuh::RPT::Log::Parsers::Base do
       expect { base.parse }.to raise_error ArgumentError
     end
 
-    it 'should only accept a StringIO object' do
-      expect { base.parse('urmom') }.to raise_error ArgumentError
-      expect { base.parse(42) }.to raise_error ArgumentError
+    it 'should raise an error when passed nil' do
+      expect { base.parse(nil) }.to raise_error ArgumentError
+    end
+
+    it 'should raise an error when passed a String' do
+      expect { base.parse('') }.to raise_error ArgumentError
+    end
+
+    it 'should raise an error when passed a Fixnum' do
+      expect { base.parse(0) }.to raise_error ArgumentError
+    end
+
+    it 'should raise an error when passed a Float' do
+      expect { base.parse(0.0) }.to raise_error ArgumentError
+    end
+
+    it 'should raise an error when passed an Array' do
+      expect { base.parse([]) }.to raise_error ArgumentError
+    end
+
+    it 'should raise an error when passed a Hash' do
+      expect { base.parse({}) }.to raise_error ArgumentError
+    end
+
+    it 'should not raise an error when passed a StringIO object' do
+      expect { base.parse(StringIO.new) }.to_not raise_error
     end
 
     it 'should return an Array' do
       expect(base.parse(text)).to be_an_instance_of Array
     end
 
-    it 'the Array size should be 2' do
+    it 'should return an the Array with a size of 2' do
       expect(base.parse(text).size).to be 2
     end
 
     it 'should be an Array of hashes' do
-      base.parse(text).each { |p| p.should be_an_instance_of Hash }
+      base.parse(text).each { |p| expect(p).to be_an_instance_of Hash }
     end
   end
 end