rubg 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30c5fa847dde8f815c0bc0e5acef0586886a7eec299c6dd75f04b60878553616
-  data.tar.gz: 9228f84e1d438a246eb680057ef98646f4e31a3a8988c71fd2ffe9aad715ac2b
+  metadata.gz: 74e11b6f6090d28926b01b5370636d1974d96e3a8379371d7bdd3c6f0ab5adca
+  data.tar.gz: e5aee919fce9263f75d3fb5a8f18f98447787afabe1748eba55768cdf5628452
 SHA512:
-  metadata.gz: de0897838c786655f77303ea177870f652423ce5c3ff24ca22becd74affe3de512f1cffc3aad28e9260d55b997de1a333b920274b3a75e2b1084a791b34ced4e
-  data.tar.gz: d0315f45b876e5a6aa5ebca73fc7ed130b55dc3d7b30a2ead9294f9404015afa88e7e1b697f2e62b20b0a0ae00ff7ea491867457731b4e359c5d428fa4643115
+  metadata.gz: 0717ccdf1144e4cc74b764906ef08cf4a71e5031cc0523bf8e0cc9da7875ff7eb0cbd3635cad6557dc6269c5b512645ae10993e0efcd0a007a2660e36328c112
+  data.tar.gz: 10dcfbaa0242892d7c543cd73ab0ceebfb459b897dce7a4096f7bec2dc5a8af964d2b703afb3bb249eaa562ccbf65504bc0c4c2ab15339b9f2af595d2fe77d3c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rubg (0.1.3)
+    rubg (0.1.4)
       httparty (~> 0.16.2)
       json
 

data/README.md

@@ -6,20 +6,21 @@ It is also a side project I am using to build my own Ruby skills. As such, updat
 
 ## Status
 
-Development is very much in-progress.
+Development is very much in-progress. Note that breaking changes with new releases will be semi-frequent until initial development is complete (~1.0.0).
 
 #### Working:
 - The /status endpoint is fully functional.
-- The /players endpoint is partially functional. Queries may be performed, but the response is raw JSON only.
+- The /players endpoint is mostly functional. Queries may be performed, and player objects returned. Match data is ID strings only.
 
 #### To-do
-1. Finish /players endpoint, converting players to Player objects and matches to Match objects in response
-2. Add /player endpoint to retrieve a single player
-3. Add /matches endpoint to retrieve a single match, including objects for Rosters, etc.
-4. Telemetry
+1. Finish /players endpoint, allowing conversion of matches to Match objects in response
+2. Add /matches endpoint to retrieve a single match, including objects for Rosters, etc.
+3. Telemetry
 
 At some point in there I need to get testing coverage up to date.
 
+*Note: xbox shards may not work correctly - only pc is currently tested. If you encounter issues pulling data from Xbox shards please log an issue and I will address.*
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -38,10 +39,12 @@ Or install it yourself as:
 
 ## Usage
 
+Most methods take a hash as argument.
+
 #### Create a Client
 First, create a client and provide your API key:
 ```ruby
-client = RUBG::Client.new("your-api-key-here")
+client = RUBG::Client.new({:api_key =>"your-api-key-here"})
 ```
     
 The client object is used to make requests. If no key is added the gem will try and find it at ENV['PUBG_API_KEY'].
@@ -57,29 +60,41 @@ client.status.released_at    # "2018-04-01T18:00:20Z"
 ```
 
 #### /players Endpoint
-/players is currently only partially functional. Queries may be performed, but the response is JSON only. You can obtain match IDs to look up manually, however, until I implement /matches.
+/players is now mostly functional. Queries may be performed, and player objects returned. Match data is ID strings only, which you can use to look up manually until I implement /matches.
+
+.players takes two arguments: :shard and :query_params 
 
-.players requires an 'options' argument, which should be a hash containing:
+:shard
+- Specify the [shard](https://documentation.playbattlegrounds.com/en/making-requests.html#regions) to retreieve data from. If none is specified, "pc-na" will be used as default.
 
-- "shard" - Specify the [shard](https://documentation.playbattlegrounds.com/en/making-requests.html#regions) to retreieve data from. If none is specified, "pc-na" will be used as default.
-- "playerNames" - Comma-separated list of players to search for. Names are case-sensitive.
-- "playerIds" - Comma-separated list of player IDs to search for.
+"query_params" - a hash containing any query options. For .players, the hash should contain *one* of the following options:
+- "player_names" - Comma-separated list of players to search for. Names are case-sensitive.
+- "player_ids" - Comma-separated list of player IDs to search for.
 
-Note: If neither playerIds nor playerNames are included in options no results will be returned - at least one name or Id must be present.
+Note: If neither player_ids nor player_names are included in query_params no results will be returned - at least one name or Id must be present.
 
 ```ruby
-options = {"shard" => "pc-na", "playerNames" => "Shroud,JoshOG,PlayerUnknown"}
-players = client.players(options)
+args = {:shard => "pc-na", :query_params => {:player_names => "shroud,JoshOG,PlayerUnknown"}}
+players = client.players(args)
 ```
 
-The response will contain a top level object called 'errors' or 'data' depending on if the query failed or succeeded.
+The response will contain a top level object called 'errors' or 'data' and 'players', depending on if the query failed or succeeded.
 
 ```ruby
-players.errors .    # [{"title"=>"Not Found", "detail"=>"No players found matching criteria"}]
+players.errors .               # [{"title"=>"Not Found", "detail"=>"No players found matching criteria"}]
 ```
 
 ```ruby
-players.data        # Returns retrieved player data.
+players.data                      # Returns retrieved player data.
+
+players.players.first.name        #"shroud"
+players.players.first.name        #"account.d50fdc18fcad49c691d38466bed6f8fd"
+players.players.first.match_ids   #returns array of all match IDs for the player
+
+players.response_ts            # Time object containing date/time of response
+players.ratelimit              # Returns the max rate limit/min for your API key.
+players.ratelimit_remaining    # Returns the number of requests your API key has remaining before hitting the ratelimit.
+
 ```
 
 ## Contributing

data/lib/rubg/client.rb

@@ -6,25 +6,29 @@ module RUBG
     base_uri 'https://api.playbattlegrounds.com'
     attr_accessor :api_key, :content_type, :gzip
 
-    def initialize(api_key=ENV['PUBG_API_KEY'],gzip=false)
-      @api_key = api_key
-      @content_type = "application/vnd.api+json"
-      @gzip = gzip
+    def initialize( args )
+      args          = self.class.defaults.merge(args)
+      @api_key      = args[:api_key]
+      @content_type = args[:content_type]
+      @gzip         = args[:gzip]
     end
 
 
-    def status
-      RUBG::Status.fetch(self)
+    def status( args={} )
+      args = {:client => self }.merge(args)
+      RUBG::Status.fetch(args)
     end
 
 
-    def players(shard=$RUBG_DEFAULT_SHARD,query_options={})
-      RUBG::Players.fetch(self, shard, query_options)
+    def players( args )
+      args = {:client => self }.merge(args)
+      RUBG::Players.fetch( args )
     end
 
   
-    def player
-    
+    def player( args )
+      args = {:client => self }.merge(args)
+      RUBG::Player.fetch( args )
     end
 
 
@@ -42,5 +46,16 @@ module RUBG
 
     end
 
+
+    private
+
+    def self.defaults
+      {
+        :api_key      => ENV['PUBG_API_KEY'],
+        :content_type => "application/vnd.api+json",
+        :gzip         => false
+      }
+    end
+
   end
 end

data/lib/rubg/player.rb

@@ -1,8 +1,75 @@
-module RUBG
-  class Player
+module RUBG 
+  class Player < RubgEndpoint
+    attr_reader :player_id, :name, :created, :updated, :patch_version, :shard_id, :stats,
+      :title_id, :assets, :match_ids, :link
+
+    attr_accessor :matches
+
+    def initialize( args )
+      args                  = self.class.defaults.merge(args)
+      super({
+        :response => args[:response]
+        })
+      if args[:response]["data"]
+        @player_id      = args[:player_data]["id"]
+        @name           = args[:player_data]["attributes"]["name"]
+        @created        = args[:player_data]["attributes"]["createdAt"]
+        @updated        = args[:player_data]["attributes"]["updatedAt"]
+        @patch_version  = args[:player_data]["attributes"]["patchVersion"]
+        @shard_id       = args[:player_data]["attributes"]["shardId"]
+        @stats          = args[:player_data]["attributes"]["stats"]
+        @title_id       = args[:player_data]["attributes"]["titleId"]
+        @assets         = args[:player_data]["relationships"]["assets"]["data"]
+        @match_ids      = match_id_array(args[:player_data]["relationships"]["matches"]["data"])
+        @matches        = nil
+        @link           = args[:player_data]["links"]["self"]
+      end
+    end
+
+
+    def self.fetch( args )
+      args                  = self.defaults.merge(args)
+      STDERR.puts args.inspect
+      endpoint = "player"
+      
+      player_id = args[:query_params][:player_id]
+      args[:query_params].delete(:player_id)
+
+      super({
+        :client         => args[:client],
+        :endpoint       => endpoint,
+        :lookup_id      => player_id,
+        :shard          => args[:shard],
+        :query_params  => args[:query_params]
+        })
+      
+      player_data = @response["data"]
+      
+      RUBG::Player.new({
+        :client       => args[:client],
+        :response     => @response,
+        :player_data  => player_data
+        })
+    end
 
-  end
-end
 
+    private
 
-# response["data"][0]["relationships"]["matches"]["data"][0]["id"]
+    def match_id_array(data)
+      match_ids = []
+
+      data.each do |m|
+        id = m["id"]
+        match_ids << id
+      end
+
+      return match_ids
+    end
+
+
+    def self.defaults
+      super
+    end
+
+  end
+end

data/lib/rubg/players.rb

@@ -1,22 +1,54 @@
 module RUBG 
   class Players < RubgEndpoint
+    attr_reader :players
+
+    def initialize( args )
+      args     = self.class.defaults.merge(args)
 
-    def initialize(client,response)
       super
+      
+      @players = []
+      if args[:response]["data"]
+        args[:response]["data"].each do |player_data|
+          player = RUBG::Player.new({
+            :client       => args[:client],
+            :response     => args[:response],
+            :player_data  => player_data
+            })
+          
+
+          @players << player
+        end
+      end
     end
 
 
-    def self.fetch(client,shard,query_options)
+    def self.fetch( args )
+      args     = self.defaults.merge(args)
+
       endpoint = "players"
-      query_options["filter[playerNames]"] = query_options.delete("playerNames")
-      query_options["filter[playerIds]"] = query_options.delete("playerIds")
-      super(client,endpoint,shard,query_options)
 
-      RUBG::Players.new(client,@response)
+      args[:query_params]["filter[playerNames]"] = args[:query_params].delete(:player_names)
+      args[:query_params]["filter[playerIds]"]   = args[:query_params].delete(:player_ids)
+      super({
+        :client         => args[:client],
+        :endpoint       => endpoint,
+        :shard          => args[:shard],
+        :query_params  => args[:query_params]
+        })
+
+      RUBG::Players.new({
+        :client   => args[:client],
+        :response => @response
+        })
     end
 
-  end
-end
 
+    private
+
+      def self.defaults
+        super
+      end
 
-# response["data"][0]["relationships"]["matches"]["data"][0]["id"]
+  end
+end

data/lib/rubg/rubg_endpoint.rb

@@ -2,23 +2,37 @@ module RUBG
   class RubgEndpoint
     attr_reader :errors, :data, :response_ts, :ratelimit, :ratelimit_remaining, :raw_response
 
-    def initialize(client,response)
-      @errors               = response["errors"]
-      @data                 = response["data"]
-      @response_ts          = Time.parse(response.headers['date']) if response.headers['date']
-      @ratelimit            = response.headers['x-ratelimit-limit']
-      @ratelimit_remaining  = response.headers['x-ratelimit-remaining']
-      @raw_response         = response
+    def initialize( args )
+      args                  = self.class.defaults.merge(args)
+      @errors               = args[:response]["errors"]
+      @data                 = args[:response]["data"]
+      @response_ts          = Time.parse(args[:response].headers['date']) if args[:response].headers['date']
+      @ratelimit            = args[:response].headers['x-ratelimit-limit']
+      @ratelimit_remaining  = args[:response].headers['x-ratelimit-remaining']
+      @raw_response         = args[:response]
     end
 
 
-    def self.fetch(client,endpoint,shard={},query_options={})
-      @uri      = assemble_uri(shard,endpoint)
-      @headers  = assemble_headers(client)
-      @query    = assemble_query(client,query_options)
+    def self.fetch( args ) #client,endpoint,shard={},query_params={}
+      args     = self.defaults.merge(args)
+      
+      uri      = assemble_uri({
+        :shard          => args[:shard],
+        :endpoint       => args[:endpoint],
+        :lookup_id      => args[:lookup_id]
+        })
 
-      @response = client.class.get(@uri,{headers: @headers,
-                                        query:    @query})
+      headers  = assemble_headers({
+        :client         => args[:client]
+        })
+
+      query    = assemble_query({
+        :client         => args[:client],
+        :query_params  => args[:query_params]
+        })
+
+      @response = args[:client].class.get(uri,{headers: headers,
+                                        query:  query})
 
       return @response
     end
@@ -26,38 +40,56 @@ module RUBG
 
 
     private
-      def self.assemble_uri(shard,endpoint)
-        if endpoint == 'status'
+      
+      def self.defaults
+        {
+          :shard          => $RUBG_DEFAULT_SHARD,
+          :query_params  => {},
+        }
+      end
+
+
+      def self.assemble_uri( args )
+        args     = self.defaults.merge(args)
+
+        if args[:endpoint] == 'status'
           uri = '/status'
+        elsif args[:endpoint] == 'player'
+          uri = "/shards/#{args[:shard]}/players/#{args[:lookup_id]}"
         else
-          uri = "/shards/#{shard}/#{endpoint}"
+          uri = "/shards/#{args[:shard]}/#{args[:endpoint]}"
         end
-
         return uri
       end
 
 
-      def self.assemble_headers(client)
-        headers = { "Accept" => client.content_type }
+      def self.assemble_headers( args ) #client
+        args     = self.defaults.merge(args)
+
+        headers = { "Accept" => args[:client].content_type }
         
-        headers["Authorization"]    = client.api_key  if client.api_key
-        headers["Accept-Encoding"]  = "gzip"          if client.gzip
+        headers["Authorization"]    = args[:client].api_key   if args[:client].api_key
+        headers["Accept-Encoding"]  = "gzip"                  if args[:client].gzip
 
         return headers
       end
 
 
-      def self.assemble_query(client, query_options)
-        query_options.each do |key,value|
+      def self.assemble_query( args ) #client, query_params
+        args     = self.defaults.merge(args)
+
+        args[:query_params].each do |key,value|
           remove_spaces(value) if value
         end
-        query = query_options
+        query = args[:query_params]
         
         return query
       end
 
-      def self.remove_spaces(string)
-        string.gsub!(/((?<=,)\s+)|(\s+(?=,))/,"") if string
-      end
+
+      private
+        def self.remove_spaces(string)
+          string.gsub!(/((?<=,)\s+)|(\s+(?=,))/,"") if string
+        end
   end
 end

data/lib/rubg/status.rb

@@ -2,23 +2,39 @@ module RUBG
   class Status < RubgEndpoint
     attr_reader :released_at, :version
     
-    def initialize(client,response)
-      @alive = ((response.response.class == Net::HTTPOK) ? true : false)
-      @released_at = Time.parse(response["data"]["attributes"]["releasedAt"])
-      @version = response["data"]["attributes"]["version"]
+    def initialize( args )
+      args     = self.class.defaults.merge(args)
+
+      @alive        = ((args[:response].response.class == Net::HTTPOK) ? true : false)
+      @released_at  = Time.parse(args[:response]["data"]["attributes"]["releasedAt"])
+      @version      = args[:response]["data"]["attributes"]["version"]
       super
     end
 
 
-    def self.fetch(client)
+    def self.fetch( args )
       endpoint = "status"
-      super(client,endpoint)
+      super({
+        :client   => args[:client],
+        :endpoint => endpoint
+        })
 
-      RUBG::Status.new(client, @response)
+      RUBG::Status.new({
+        :client   => args[:client],
+        :response => @response
+        })
     end
 
     def alive?
       @alive ? true : false
     end
+
+
+    private
+
+      def self.defaults
+        super
+      end
+  
   end
 end

data/lib/rubg/version.rb

@@ -1,3 +1,3 @@
 module RUBG
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/lib/rubg.rb

@@ -1,6 +1,9 @@
 require "rubg/version"
 require "rubg/client"
 require "rubg/rubg_endpoint"
+require "rubg/match"
+require "rubg/matches"
+require "rubg/player"
 require "rubg/players"
 require "rubg/status"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubg
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Dor
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-05 00:00:00.000000000 Z
+date: 2018-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler