csstats 1.1.0 → 1.2.0

data/lib/csstats/parser/reader/players.rb

@@ -0,0 +1,41 @@
+module CSstats
+  module Parser
+    module Reader
+      class Players
+        attr_reader :file_path, :max_players
+
+        def initialize(file_path, options = {})
+          @file_path = file_path
+          @max_players = options[:max_players] || 0
+        end
+
+        def parse
+          players = []
+
+          file_reader.read do |streamer, index|
+            parse_player(streamer, index, players)
+          end
+
+          players
+        end
+
+        private
+
+        def parse_player(streamer, index, players)
+          player_parser = CSstats::Parser::Reader::Player.new(streamer)
+          player = player_parser.parse
+          return unless player
+
+          player.rank = index + 1
+          players[index] = player
+        end
+
+        def file_reader
+          @file_reader ||= CSstats::Parser::Reader::FileReader.new(
+            file_path, limit: max_players
+          )
+        end
+      end
+    end
+  end
+end

data/lib/csstats/{writer.rb → parser/writer.rb}

@@ -1,8 +1,10 @@
-require_relative 'writer/file_writer/handler'
+require_relative 'writer/file_streamer'
 require_relative 'writer/player'
 require_relative 'writer/players'
 
 module CSstats
-  module Writer
+  module Parser
+    module Writer
+    end
   end
 end

data/lib/csstats/{writer/file_writer/handler.rb → parser/writer/file_streamer.rb}

@@ -1,26 +1,25 @@
 module CSstats
-  module Writer
-    class FileWriter
-      class Handler
-        attr_reader :handle
+  module Parser
+    module Writer
+      class FileStreamer
+        attr_reader :stream
 
-        def initialize(handle)
-          @handle = handle
+        def initialize(stream)
+          @stream = stream
         end
 
         def write_int_data(int)
           data = [int].pack('V')
-          handle.write(data)
+          stream.write(data)
         end
 
         def write_short_data(int)
           data = [int].pack('v')
-          handle.write(data)
+          stream.write(data)
         end
 
         def write_string_data(string)
-          data = "#{string}\x00"
-          handle.write(data)
+          stream.write(string)
         end
       end
     end

data/lib/csstats/parser/writer/player.rb

@@ -0,0 +1,34 @@
+module CSstats
+  module Parser
+    module Writer
+      class Player
+        attr_reader :streamer, :player
+
+        def initialize(streamer, player)
+          @streamer = streamer
+          @player = player
+        end
+
+        def write
+          CSstats::COLUMNS.each do |column|
+            next streamer.write_int_data(0) if column.empty?
+
+            value = player.send(column[:name])
+            send("write_#{column[:type]}", value)
+          end
+        end
+
+        private
+
+        def write_string(value)
+          streamer.write_short_data(value.length + 1)
+          streamer.write_string_data("#{value}\x00")
+        end
+
+        def write_integer(value)
+          streamer.write_int_data(value)
+        end
+      end
+    end
+  end
+end

data/lib/csstats/parser/writer/players.rb

@@ -0,0 +1,29 @@
+module CSstats
+  module Parser
+    module Writer
+      class Players
+        attr_reader :file_path
+
+        def initialize(file_path)
+          @file_path = file_path
+        end
+
+        def write(players)
+          file = File.new(file_path, 'w')
+
+          streamer(file).write_short_data(11) # File version
+
+          players.each do |player|
+            CSstats::Parser::Writer::Player.new(streamer(file), player).write
+          end
+
+          file.close
+        end
+
+        def streamer(file)
+          CSstats::Parser::Writer::FileStreamer.new(file)
+        end
+      end
+    end
+  end
+end

data/lib/csstats/player.rb

@@ -0,0 +1,34 @@
+module CSstats
+  class Player
+    attr_accessor :rank
+
+    def initialize(attributes = {})
+      CSstats::COLUMN_KEYS.each do |column|
+        self.class.send(:attr_accessor, column)
+      end
+
+      attributes.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+    def efficiency
+      kills_and_deaths = kills.to_f + deaths.to_f
+      return 0.0 if kills_and_deaths.zero?
+
+      (kills.to_f / kills_and_deaths * 100).round(2)
+    end
+
+    def accuracy
+      return 0.0 if shots.to_f.zero?
+
+      (hits.to_f / shots.to_f * 100).round(2)
+    end
+
+    def as_json
+      CSstats::COLUMN_KEYS.each_with_object({}) do |column, object|
+        object[column] = send(column)
+      end
+    end
+  end
+end

data/lib/csstats/players.rb

@@ -0,0 +1,52 @@
+module CSstats
+  class Players
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def all
+      players
+    end
+
+    def find(id)
+      players[id - 1]
+    end
+
+    def find_by(attributes = {})
+      players.find do |player|
+        attributes.all? do |column, value|
+          player.send(column) == value
+        end
+      end
+    end
+
+    def where(attributes = {})
+      players.select do |player|
+        attributes.all? do |column, value|
+          player.send(column) == value
+        end
+      end
+    end
+
+    # def save
+    #   CSstats::Parser.write_players(client, players)
+    # end
+
+    def method_missing(method_name, *args, &block)
+      return super unless respond_to?(method_name)
+      players.send(method_name, *args, &block)
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      players.respond_to?(method_name, include_private)
+    end
+
+    private
+
+    def players
+      @players ||= CSstats::Parser.get_players(client)
+    end
+  end
+end

data/lib/csstats/version.rb

@@ -1,3 +1,3 @@
 module CSstats
-  VERSION = '1.1.0'.freeze
+  VERSION = '1.2.0'.freeze
 end

data/spec/csstats/client_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe CSstats::Client do
+  let(:client) { CSstats::Client.new(path: csstats_file, max_players: 5) }
+
+  it 'has correct file path' do
+    expect(client.file_path).to eq(csstats_file)
+  end
+
+  it 'has correct max players value' do
+    expect(client.max_players).to eq(5)
+  end
+end

data/spec/csstats/parser/reader/player_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe CSstats::Parser::Reader::Player do
+  let(:file_stream) { File.new(csstats_file) }
+  let(:streamer) { CSstats::Parser::Reader::FileStreamer.new(file_stream) }
+  subject { described_class.new(streamer) }
+  let(:player_data) { subject.parse }
+
+  before do
+    # We need to read first bytes, because it's file version.
+    streamer.read_short_data
+  end
+
+  it 'has correct head' do
+    expect(player_data.head).to eq(402)
+  end
+end

data/spec/csstats/parser/writer/players_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe CSstats::Parser::Writer::Players do
+  let(:old_players) { CSstats.new(path: csstats_file).players }
+  let(:file_path) { tmp_file('test.dat') }
+  let(:new_players) { CSstats.new(path: file_path).players }
+
+  it 'has correct players count in main file' do
+    expect(old_players.length).to eq(208)
+  end
+
+  context 'new file' do
+    before do
+      described_class.new(file_path).write(old_players)
+    end
+
+    after do
+      FileUtils.rm(file_path)
+    end
+
+    it 'has correct players count' do
+      described_class.new(file_path).write(old_players)
+      expect(new_players.length).to eq(208)
+    end
+
+    it 'has same players data' do
+      expect(old_players.map(&:as_json)).to eq(new_players.map(&:as_json))
+    end
+  end
+end

data/spec/csstats/player_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe CSstats::Player do
+  let(:client) { CSstats::Client.new(path: csstats_file, max_players: 10) }
+  let(:players) { client.players }
+
+  it 'sets attributes from options' do
+    player = CSstats::Player.new(nick: 'Test')
+    expect(player.nick).to eq('Test')
+  end
+
+  it 'has ability to rewrite attribute' do
+    player = CSstats::Player.new
+    player.nick = 'Test'
+    expect(player.nick).to eq('Test')
+  end
+
+  context 'data' do
+    let(:player) { players.find_by(nick: 'CHMARSON') }
+
+    it 'has correct nick' do
+      expect(player.nick).to eq 'CHMARSON'
+    end
+
+    it 'has correct rank' do
+      expect(player.rank).to eq 2
+    end
+
+    it 'has correct teamkill' do
+      expect(player.teamkill).to eq 7
+    end
+
+    it 'has correct damage' do
+      expect(player.damage).to eq 101_543
+    end
+
+    it 'has correct deaths' do
+      expect(player.deaths).to eq 511
+    end
+
+    it 'has correct kills' do
+      expect(player.kills).to eq 759
+    end
+
+    it 'has correct shots' do
+      expect(player.shots).to eq 9421
+    end
+
+    it 'has correct hits' do
+      expect(player.hits).to eq 2885
+    end
+
+    it 'has correct headshots' do
+      expect(player.headshots).to eq 225
+    end
+
+    it 'has correct defusions' do
+      expect(player.defusions).to eq 15
+    end
+
+    it 'has correct defused' do
+      expect(player.defused).to eq 9
+    end
+
+    it 'has correct plants' do
+      expect(player.plants).to eq 33
+    end
+
+    it 'has correct explosions' do
+      expect(player.explosions).to eq 7
+    end
+
+    it 'has correct head' do
+      expect(player.head).to eq 275
+    end
+
+    it 'has correct chest' do
+      expect(player.chest).to eq 407
+    end
+
+    it 'has correct stomach' do
+      expect(player.stomach).to eq 376
+    end
+
+    it 'has correct leftarm' do
+      expect(player.leftarm).to eq 1126
+    end
+
+    it 'has correct rightarm' do
+      expect(player.rightarm).to eq 283
+    end
+
+    it 'has correct leftleg' do
+      expect(player.leftleg).to eq 202
+    end
+
+    it 'has correct rightleg' do
+      expect(player.rightleg).to eq 214
+    end
+
+    it 'has correct accuracy' do
+      expect(player.accuracy).to eq 30.62
+    end
+
+    it 'has correct efficiency' do
+      expect(player.efficiency).to eq 59.76
+    end
+  end
+end

data/spec/csstats/players_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe CSstats::Players do
+  let(:client) { CSstats::Client.new(path: csstats_file, max_players: 30) }
+  let(:players) { client.players }
+
+  it 'has correct players count' do
+    expect(players.count).to eq(30)
+  end
+
+  it 'returns players with all' do
+    expect(players.all.length).to eq(30)
+  end
+
+  it 'has array of Player class' do
+    expect(players.first).to be_a(CSstats::Player)
+  end
+
+  it 'has correct player data' do
+    expect(players.find(2).nick).to eq('CHMARSON')
+  end
+
+  it 'has correct count with where' do
+    expect(players.where(head: 102).count).to eq(2)
+  end
+
+  it 'has correct count with find_by' do
+    expect(players.find_by(head: 102).nick).to eq('LBM')
+  end
+end