q3_servers 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f82fbeb9b327a11aedb51d1ad6f3dd98d20ff7863d5d1c108e70680cfc4f3ffb
+  data.tar.gz: 45fa2991f473f0714823d3574a1965dc56b249fc2a7a63c1a753e15bd752bcd9
+SHA512:
+  metadata.gz: 96f27480478d3f3443cd5451cd2876f036949037d2cc22731dc8c39734ec561d6f005430489fb133bdd286153b76289bf7d317f6d7330464ab40a0ded0d0d16b
+  data.tar.gz: '01168eac86e3c2bfa307c5c323b204b154e1bab4242387660504300553f9598ee19c732c9d67365c7cda751d74dca55d447c5451c2655fba6ba18b3e1eab3fd0'

data/.gitignore

@@ -0,0 +1,56 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.7.2
+before_install: gem install bundler -v 2.1.4

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in q3_servers.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "minitest", "~> 5.0"

data/Gemfile.lock

@@ -0,0 +1,42 @@
+PATH
+  remote: .
+  specs:
+    q3_servers (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    minitest (5.14.4)
+    parallel (1.20.1)
+    parser (3.0.1.1)
+      ast (~> 2.4.1)
+    rainbow (3.0.0)
+    rake (12.3.3)
+    regexp_parser (2.1.1)
+    rexml (3.2.5)
+    rubocop (1.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.0.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.7.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.7.0)
+      parser (>= 3.0.1.1)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (2.0.0)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  minitest (~> 5.0)
+  q3_servers!
+  rake (~> 12.0)
+  rubocop
+
+BUNDLED WITH
+   2.2.17

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 jpgarritano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,95 @@
+# Q3Servers
+
+This gem will help you browse through Quake3-style master servers (Protocol 68) (tested only with Urban Terror)
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'q3_servers'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install q3_servers
+
+
+## Usage
+```ruby
+    q3_urt_list = Q3Servers::List.new
+    
+    #### Some defaults settings you can change
+    # q3_urt_list.master_address
+    # q3_urt_list.only_favorites = false
+    # q3_urt_list.timeout = 1
+    # q3_urt_list.master_cache_secs = 600
+    # q3_urt_list.info_cache_secs = 60
+    # q3_urt_list.debug = true
+    ####
+    # q3_urt_list.add_favorite('XXX.XXX.XXX.XXX', '27960')
+    # q3_urt_list.add_favorite('YYY.YYY.YYY.YYY', '27961')
+    
+    servers = q3_urt_list.fetch_servers({})
+```
+##### Threads
+  You can use use_threads keyword, for multi-threaded fetching (one for each server found!)
+   ```ruby
+   q3_urt_list.fetch_servers({}, use_threads: true)
+   ```
+
+##### Filter
+  Filter by keys from "info" attribute in Q3Servers::Server
+  example:
+  ```ruby
+   q3_urt_list.fetch_servers({hostname: "Arg"})
+   ```
+
+#### And now read information from each server
+##### Examples:
+```ruby
+    # print info from a server
+    servers.first.tap do |server| 
+      puts server.info['hostname'] ## server.name_c_sanitized exclude symbols and colors from hostname field
+      puts server.gametype # print gametype mapped in Q3Servers::Server::GT Hash
+      puts server.info.keys # for more information you can access
+    end
+
+    # get only servers with clients
+    server_with_clients = servers.select { |server| server.info['clients'].to_i > 0 }
+    
+    # show players 
+    server_with_clients.each do |server|
+      server.info['sv_status']['players'].each do |player|
+      puts "#{player.name} has ping: #{player.ping} with #{player.kills} kills"
+      end    
+    end
+```
+
+#### More info
+
+You can set `only_favorites = true` for fetch only servers added with `add_favorite(host, port)` method
+
+#### TODO
+- Tests
+- Pool of threads
+
+#### This gem was built only for fun :)
+
+##### Used in `UrbanterrorBot` on Telegram
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jpgarritano/q3_servers.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "q3_servers"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/q3_servers.rb

@@ -0,0 +1,11 @@
+require "q3_servers/version"
+
+module Q3Servers
+  class Error < StandardError; end
+  
+  require 'q3_servers/player'
+  require 'q3_servers/server_connection'
+  require 'q3_servers/server'
+  require 'q3_servers/massive_helper'
+  require 'q3_servers/list'
+end

data/lib/q3_servers/list.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'date'
+
+module Q3Servers
+  class List
+    PROTOCOL = 68
+    MAX_LENGTH = 65_536
+
+    attr_reader :master_socket, :threads, :servers, :favorites
+    attr_accessor :cache, :timeout, :master_updated_at, :debug, :master_cache_secs, :info_cache_secs, :only_favorites,
+                  :master_address, :master_port
+    alias only_favorites? only_favorites
+    alias cache? cache
+
+    def initialize
+      @master_socket = UDPSocket.new
+      @servers = []
+      @cache = true
+      @timeout = 1
+      @master_updated_at = nil
+      @debug = false
+      @master_cache_secs = 600
+      @info_cache_secs = 60
+      @favorites = []
+      @master_port = 27_900
+      @master_address = 'master.urbanterror.info' # 51.75.224.242
+      @threads = []
+    end
+
+    def fetch_servers(filter = {}, use_threads: false)
+      servers_list_from_master if master_server_outdated? && !only_favorites?
+      fetch_info_servers(filter, use_threads)
+    end
+
+    def request_server_info(server, filter, use_threads)
+      print_debug("INFO Server: Connecting to Server id => #{server.unique_index}")
+      if use_threads
+        thread_server_info(server, filter)
+      else
+        server.request_info
+      end
+    end
+
+    def cached_info?(server)
+      cache? && server_info?(server) && !server_info_outdated?(server)
+    end
+
+    def cached_status?(server)
+      cache? && server_status?(server) && !server_status_outdated?(server)
+    end
+
+    def add_server(server)
+      servers << server
+    end
+
+    def add_favorite(ip, port)
+      favorites << new_favorite = Server.new(ip, port, {})
+      add_server(new_favorite)
+    end
+
+    def favorite?(server)
+      favorites.any? { |fav| server.unique_index == fav.unique_index }
+    end
+
+    private
+
+    def thread_server_info(server, filter)
+      @threads << Thread.new { get_server_info_status_filter(server, filter) }
+    rescue ThreadError => e
+      p "Can't create thread! => #{e.inspect}"
+    end
+
+    def get_server_info_status_filter(server, filter)
+      server.get_info_connect
+      server.request_and_get_status if server.filter_info(filter)
+      server.info
+    end
+
+    def server_info?(server)
+      !server.info.empty?
+    end
+
+    def server_status?(server)
+      server_info?(server) && !server.info_status.empty?
+    end
+
+    def fill_list_favorites
+      favorites.each do |fav|
+        add_server(fav)
+      end
+    end
+
+    def fill_list_master(response)
+      response = response.unpack('CCCCA18Ca*')
+      response = response[6]
+      until response.empty?
+        response = response.unpack('NnCa*')
+        new_sv = Server.new(to_ip(response[0]), response[1], {}) # response[2] is \\ (EOT)
+        add_server(new_sv)
+        response = response[3] # prepare for next step
+      end
+      servers
+    end
+
+    def fetch_info_servers(filter, use_threads)
+      servers.each do |server|
+        cache_or_request_server_info(server, filter, use_threads)
+      end
+      # wait for "info servers"
+      if use_threads
+        @threads.each(&:join) # wait for threads
+      else
+        massive_read_info_status(servers, filter)
+      end
+      destroy_socket_servers
+      servers.select { |server| server.filter_info(filter) }
+    end
+
+    def cache_or_request_server_info(server, filter, use_threads)
+      if cached_info?(server)
+        print_debug("INFO Server cached => #{server.unique_index}")
+      else
+        request_server_info(server, filter, use_threads)
+      end
+    end
+
+    def servers_list_from_master
+      servers.clear # #clean servers list
+      print_debug("Connecting to master server: cache => #{cache} | timeout => #{timeout}")
+      connect_request_master_socket
+      response_all_servers = []
+      loop do
+        response_all_servers << master_socket.recvfrom(MAX_LENGTH).first
+        size = response_all_servers.last.size
+        print_debug(size)
+        break if size < 1394
+      end
+      response_all_servers.each { |r_server| fill_list_master(r_server) } unless only_favorites?
+      self.master_updated_at = DateTime.now
+    end
+
+    def print_debug(info)
+      p info if @debug
+    end
+
+    def to_ip(decimal)
+      [decimal].pack('N').unpack('CCCC').join('.')
+    end
+
+    def master_server_outdated?
+      !master_updated_at or (DateTime.now > (master_updated_at + Rational(master_cache_secs, 86_400)))
+    end
+
+    def server_info_outdated?(server)
+      (!server_info?(server) or (DateTime.now > (server.updated_at + Rational(info_cache_secs, 86_400))))
+    end
+
+    def server_status_outdated?(server)
+      (!server_status?(server) or (DateTime.now > (server.status_updated_at + Rational(info_cache_secs, 86_400))))
+    end
+
+    def massive_read_info_status(servers, filter)
+      massive_helper = MassiveHelper.new(servers.select(&:request_status?), self)
+      alive_servers = massive_helper.read_info_servers(2, timeout) do |server|
+        server.read_info unless cached_info?(server)
+      end
+
+      filtered_servers = alive_servers.select { |server| server.filter_info(filter) }
+      filtered_servers.each(&:request_status)
+
+      massive_helper.read_status_servers(filtered_servers, 2, timeout) do |server|
+        server.read_status unless cached_status?(server)
+      end
+    end
+
+    def destroy_socket_servers
+      servers.each(&:destroy_socket)
+    end
+
+    def connect_request_master_socket
+      master_socket.connect(master_address, master_port)
+      master_socket.send("#{prepend_oob_data}getservers #{PROTOCOL} full empty", 0)
+    end
+
+    def prepend_oob_data
+      "\xFF" * 4
+    end
+  end
+end

data/lib/q3_servers/massive_helper.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Q3Servers
+  class MassiveHelper
+    attr_accessor :sockets, :servers
+
+    def initialize(servers, context)
+      @context = context
+      @servers = servers.each_with_object({}) do |server, hsh|
+        hsh[server.unique_index] = server
+      end
+    end
+  
+    def read_info_servers(max_retries, timeout, &block)
+      puts '======== Read Info servers ========'
+      read_info(servers.map { |_unique_index, server| server.socket }, max_retries, timeout, &Proc.new)
+    end
+  
+    def read_status_servers(servers, max_retries, timeout)
+      puts '======== Read Status servers ========'
+      read_info(servers.map(&:socket), max_retries, timeout, &Proc.new)
+    end
+  
+    def read_info(sockets, max_retries, timeout, &block)
+      servers_with_info = []
+      sockets_completed = 0
+      retries = 0
+      sockets.size.times do |_i|
+        break if (sockets_completed >= sockets.size) || (retries >= max_retries)
+  
+        ready_sockets = IO.select(sockets, nil, nil, timeout)
+        if ready_sockets && (ready_sockets = ready_sockets[0])
+          retries = 0
+          ready_sockets.each do |socket|
+            sockets_completed += 1
+            server = servers[calculate_index(socket)]
+            block.call(server)
+            servers_with_info << server
+          end
+        else
+          retries += 1
+          puts "Retry n #{retries}"
+        end
+      end
+      servers_with_info
+    end
+  
+    def calculate_index(socket)
+      # to determine which socket answered
+      addr = socket.peeraddr(false)
+      ServerConnection.new(addr.last, addr[1]).unique_index
+    end  
+  end
+end

data/lib/q3_servers/player.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Q3Servers
+  Player = Struct.new(:name, :kills, :ping)
+end

data/lib/q3_servers/server.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Q3Servers
+  class Server
+    attr_accessor :connection, :info, :status
+
+    STATUS = %i[request request_status response response_status destroyed].freeze
+    GT = { '0' => 'FFA', '4' => 'TS', '7' => 'CTF', '9' => 'JMP' }.freeze
+
+    def initialize(ip, port, info)
+      @connection = ServerConnection.new(ip, port)
+      @info = info || {}
+    end
+
+    def name_c_sanitized
+      info['hostname'].gsub(/(\^[0-9]{1})/, '') if info.key?('hostname')
+    end
+
+    def gametype
+      GT.fetch(info['gametype'], '')
+    end
+
+    def filter_info(filter)
+      return false if info.empty?
+      return true if filter.empty?
+
+      info['hostname'] = name_c_sanitized if info.key?('hostname')
+      f = filter.select { |k, v| info.key?(k.to_s) and (info[k.to_s].downcase =~ /#{v.to_s.downcase}/) }
+      !f.empty?
+    end
+
+    def get_info_connect
+      request_info
+      read_info
+    end
+
+    def request_info
+      self.status = :request
+      puts "Requesting info to #{connection}"
+      connection.request_info_server
+    end
+
+    def request_status
+      self.status = :request_status
+      puts "Requesting status to #{connection}"
+      connection.request_status_server
+    end
+
+    def read_info
+      self.status = :response
+      self.info = connection.read_info_server
+      touch!
+      info
+    end
+
+    def read_status
+      self.status = :response_status
+      info['sv_status'] = connection.read_status_server
+      status_touch!
+      info['sv_status']
+    end
+
+    def request_and_get_status
+      info['sv_status'] = connection.request_and_get_server_status # step 2 more info from server
+      status_touch!
+      info['sv_status']
+    end
+
+    def socket
+      connection.socket
+    end
+
+    def unique_index
+      connection.unique_index
+    end
+
+    def destroy_socket
+      status = :destroyed
+      connection.socket.close
+    end
+
+    def updated_at
+      info['updated_at']
+    end
+
+    def status_updated_at
+      info.dig('sv_status', 'updated_at')
+    end
+
+    def info_status
+      info['sv_status'] || {}
+    end
+
+    STATUS.each do |status|
+      define_method("#{status}_status?") { self.status == status }
+    end
+
+    private
+
+    def touch!
+      info['updated_at'] = DateTime.now
+    end
+
+    def status_touch!
+      info['sv_status']['updated_at'] = DateTime.now
+    end
+  end
+end

data/lib/q3_servers/server_connection.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'digest'
+module Q3Servers
+  class ServerConnection
+    attr_accessor :ip, :port, :socket, :timeout, :url_maps
+
+    MAX_LENGTH = 65_536
+
+    def initialize(ip, port, timeout = 1)
+      @ip = ip
+      @port = port
+      @timeout = timeout
+      @url_maps = 'https://www.urbanterror.info/files/static/images/levels/wide/'
+    end
+
+    def to_s
+      "#{ip}:#{port}"
+    end
+
+    def unique_index
+      Digest::MD5.hexdigest("#{ip}:#{port}")
+    end
+
+    def server_info_connect
+      request_info_server
+      read_info_server
+    end
+
+    def connect
+      @socket&.close
+      @socket = UDPSocket.new
+      @socket.connect(ip, port)
+      @socket
+    end
+
+    def request_info_server
+      connect
+      send_data("#{prepend_oob_data}getinfo xxx") # request step 1
+    end
+
+    # INFO 1/2
+    def read_info_server
+      sv_info = read_data
+      sv_info ? parse_sv_info(sv_info) : {} # parse step 1 info
+    end
+
+    # INFO 2/2
+    def request_and_get_server_status
+      # sv_status = send_and_read(prepend_oob_data + 'getstatus')
+      # sv_status ? parse_sv_status(sv_status) : {} # parse step 2
+      request_status_server
+      read_status_server
+    end
+
+    def request_status_server
+      send_data("#{prepend_oob_data}getstatus") # request step 2
+    end
+
+    # INFO 2/2
+    def read_status_server
+      sv_status = read_data
+      sv_status ? parse_sv_status(sv_status) : {} # parse step 2
+    end
+
+    private
+
+    def send_and_read(data)
+      send_data(data)
+      read_data
+    end
+
+    def send_data(data)
+      socket.send(data, 0)
+    end
+
+    def read_data
+      IO.select([socket], nil, nil, timeout)
+      response_info = socket.recvfrom_nonblock(MAX_LENGTH)
+    rescue IO::WaitReadable, Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+      nil
+    else
+      response_info[0]
+    end
+
+    def parse_sv_info(sv_response)
+      response = sv_response.unpack('CCCCA12CCa*') # infoResponse (len 12) string
+      response = response[7].split('\\')
+      result = Hash[*response]
+      result['map_image_url'] = map_url(result['mapname'])
+      result
+    end
+
+    def parse_sv_status(sv_response)
+      response = sv_response.unpack('CCCCA14CCa*') # statusResponse (len 14) string
+      response = response[7].split("\n")
+      status = Hash[*response[0].split('\\')]
+      players = parse_players(response[1..-1])
+      status['players'] = players
+      status
+    end
+
+    def parse_players(array_str)
+      array_str.map do |player|
+        kills, ping, player_name = player.split
+        Player.new(player_name[1..-2], kills, ping)
+      end
+    end
+
+    def prepend_oob_data
+      "\xFF" * 4
+    end
+
+    def map_url(map_name)
+      "#{url_maps}#{map_name}.jpg"
+    end
+  end
+end

data/lib/q3_servers/version.rb

@@ -0,0 +1,3 @@
+module Q3Servers
+  VERSION = "0.1.0"
+end

data/q3_servers.gemspec

@@ -0,0 +1,23 @@
+require_relative 'lib/q3_servers/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "q3_servers"
+  spec.version       = Q3Servers::VERSION
+  spec.authors       = ["Juan Pablo Garritano"]
+  spec.email         = ["tuny22@gmail.com"]
+
+  spec.summary       = "Browse servers from Quake3/Urban-Terror game"
+  spec.homepage      = "https://github.com/jpgarritano/q3_servers"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/jpgarritano/q3_servers"
+  spec.metadata["changelog_uri"] = "https://github.com/jpgarritano/q3_servers"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: q3_servers
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Juan Pablo Garritano
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-06-22 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- tuny22@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/q3_servers.rb
+- lib/q3_servers/list.rb
+- lib/q3_servers/massive_helper.rb
+- lib/q3_servers/player.rb
+- lib/q3_servers/server.rb
+- lib/q3_servers/server_connection.rb
+- lib/q3_servers/version.rb
+- q3_servers.gemspec
+homepage: https://github.com/jpgarritano/q3_servers
+licenses: []
+metadata:
+  homepage_uri: https://github.com/jpgarritano/q3_servers
+  source_code_uri: https://github.com/jpgarritano/q3_servers
+  changelog_uri: https://github.com/jpgarritano/q3_servers
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Browse servers from Quake3/Urban-Terror game
+test_files: []