ruby-lol 0.12.2 → 1.0.0

data/lib/lol/match_request.rb

@@ -1,16 +1,58 @@
 module Lol
+  # Bindings for the Match API.
+  #
+  # See: https://developer.riotgames.com/api-methods/#match-v3
   class MatchRequest < Request
-    # Returns the supported API Version
-    # @return [String] the supported api version
-    def self.api_version
-      "v2.2"
+    # @!visibility private
+    def api_base_path
+      "/lol/match/#{self.class.api_version}"
     end
 
-    # Returns a match with the given id
-    # @param match_id [Fixnum] Match ID
-    # @return [Hash] match object
-    def get match_id
-      perform_request(api_url("match/#{match_id}"))
+    # Get match by match ID.
+    # @param [Integer] match_id Match ID
+    # @param [String] tournament_code Optional tournament code the match belongs to
+    # @return [DynamicModel] Match representation
+    def find match_id, tournament_code: nil
+      url = "matches/#{match_id}".tap do |u|
+        u << "/by-tournament-code/#{tournament_code}" if tournament_code
+      end
+      DynamicModel.new perform_request api_url url
+    end
+
+    # Get match timeline by match ID.
+    # @param [Integer] match_id Match ID
+    # @return [DynamicModel] Timeline represantion
+    def find_timeline match_id
+      DynamicModel.new perform_request api_url "timelines/by-match/#{match_id}"
+    end
+
+    # Get match IDs by tournament code.
+    # @param [String] tournament_code Tournament code
+    # @return [Array<Integer>] List of match IDs
+    def ids_by_tournament_code tournament_code
+      perform_request api_url "matches/by-tournament-code/#{tournament_code}/ids"
+    end
+
+    # Get matchlist for ranked games played on given account ID and platform ID and filtered using given filter parameters, if any.
+    # @param [Integer] account_id Account ID
+    # @param [Hash] options the options to pass to the call
+    # @option options [Array<Integer>] queue Set of queue IDs for which to filtering matchlist.
+    # @option options [Integer] beginTime The begin time to use for filtering matchlist specified as epoch milliseconds.
+    # @option options [Integer] endTime The end time to use for filtering matchlist specified as epoch milliseconds.
+    # @option options [Integer] beginIndex The begin index to use for filtering matchlist.
+    # @option options [Integer] endIndex The end index to use for filtering matchlist.
+    # @option options [Array<Integer>] season Set of season IDs for which to filtering matchlist.
+    # @option options [Array<Integer>] champion Set of champion IDs for which to filtering matchlist.
+    # @return [DynamicModel] MatchList represantion
+    def all options={}, account_id:
+      DynamicModel.new perform_request api_url "matchlists/by-account/#{account_id}", options
+    end
+
+    # Get matchlist for last 20 matches played on given account ID and platform ID.
+    # @param [Integer] account_id Account ID
+    # @return [DynamicModel] MatchList represantion
+    def recent account_id:
+      DynamicModel.new perform_request api_url "matchlists/by-account/#{account_id}/recent"
     end
   end
 end

data/lib/lol/request.rb

@@ -24,22 +24,71 @@ module Lol
     # @return [Object] the cache_store
     attr_reader :cache_store
 
-    # Stub method. Each subclass should have its own api version
-    # @return [String] api version
+    # Returns the supported API Version.
+    # @return [String] v3
     def self.api_version
-      "v1.1"
+      "v3"
+    end
+
+    def self.platforms
+      {
+        :br   => 'br1',
+        :eune => 'eun1',
+        :euw  => 'euw1',
+        :jp   => 'jp1',
+        :kr   => 'kr1',
+        :lan  => 'la1',
+        :las  => 'la2',
+        :na   => 'na1',
+        :oce  => 'oc1',
+        :ru   => 'ru',
+        :tr   => 'tr1',
+      }
+    end
+
+    # Initializes a new Request
+    # @param api_key [String] the Riot Games API key
+    # @param region [String] the region you want to use in API calls
+    # @param cache_store [Hash]
+    # @option cache_store [Redis] :redis Redis instance to use
+    # @option cache_store [Boolean] :cached should the request be cached
+    # @option cacche_store [Integer] :ttl ttl for cache keys
+    # @return [Request]
+    def initialize api_key, region, cache_store = {}
+      @cache_store = cache_store
+      raise InvalidCacheStore if cached? && !store.is_a?(Redis)
+      @api_key = api_key
+      @region = region
+    end
+
+    def platform
+      self.class.platforms[region.to_sym]
+    end
+
+    # Returns the supported API Version.
+    # @return [String] v3
+    def api_version
+      self.class.api_version
     end
 
     # Returns a full url for an API call
     # @param path [String] API path to call
     # @return [String] full fledged url
     def api_url path, params = {}
-      url = "#{api_base_url}/api/lol/#{region}/#{self.class.api_version}/#{path}"
+      url = File.join File.join(api_base_url, api_base_path), path
       "#{url}?#{api_query_string params}"
     end
 
+    # Returns the API base domain
+    # @return [String] path domain
     def api_base_url
-      "https://#{region}.api.pvp.net"
+      "https://#{platform}.api.riotgames.com"
+    end
+
+    # Returns the API base path, which is everything between the domain and the request-specific path
+    # @return [String] API path
+    def api_base_path
+      "/lol/platform/#{api_version}"
     end
 
     def api_query_string params = {}
@@ -105,24 +154,9 @@ module Lol
       cache_store[:cached]
     end
 
-    # @return [Fixnum] the ttl to apply to cached keys
+    # @return [Integer] the ttl to apply to cached keys
     def ttl
       cache_store[:ttl]
     end
-
-    # Initializes a new Request
-    # @param api_key [String] the Riot Games API key
-    # @param region [String] the region you want to use in API calls
-    # @param cache_store [Hash]
-    # @option cache_store [Redis] :redis Redis instance to use
-    # @option cache_store [Boolean] :cached should the request be cached
-    # @option cacche_store [Fixnum] :ttl ttl for cache keys
-    # @return [Request]
-    def initialize api_key, region, cache_store = {}
-      @cache_store = cache_store
-      raise InvalidCacheStore if cached? && !store.is_a?(Redis)
-      @api_key = api_key
-      @region = region
-    end
   end
 end

data/lib/lol/runes_request.rb

@@ -0,0 +1,14 @@
+module Lol
+  # Bindings for the Runes API.
+  #
+  # See: https://developer.riotgames.com/api-methods/#runes-v3
+  class RunesRequest < Request
+    # Get rune pages for a given summoner ID
+    # @param [Integer] summoner_id Summoner ID
+    # @return [Array<DynamicModel>] Rune pages
+    def by_summoner_id summoner_id
+      result = perform_request api_url "runes/by-summoner/#{summoner_id}"
+      result["pages"].map { |p| DynamicModel.new p }
+    end
+  end
+end

data/lib/lol/spectator_request.rb

@@ -0,0 +1,24 @@
+module Lol
+  # Bindings for the Match API.
+  #
+  # See: https://developer.riotgames.com/api-methods/#match-v3
+  class SpectatorRequest < Request
+    # @!visibility private
+    def api_base_path
+      "/lol/spectator/#{self.class.api_version}"
+    end
+
+    # Get current game information for the given summoner ID.
+    # @param [Integer] summoner_id Summoner ID
+    # @return [DynamicModel] Current game representation
+    def current_game summoner_id:
+      DynamicModel.new perform_request api_url "active-games/by-summoner/#{summoner_id}"
+    end
+
+    # Get list of featured games.
+    # @return [FeaturedGameList] list of featured games
+    def featured_games
+      FeaturedGameList.new perform_request api_url "featured-games"
+    end
+  end
+end

data/lib/lol/static_request.rb

@@ -1,57 +1,68 @@
 module Lol
   class StaticRequest < Request
-    STANDARD_ENDPOINTS = %w(champion item mastery rune summoner_spell)
+    # @!visibility private
+    def api_base_path
+      "/lol/static-data/#{self.class.api_version}"
+    end
+
+    {
+      "champion"       => "champions",
+      "item"           => "items",
+      "mastery"        => "masteries",
+      "rune"           => "runes",
+      "summoner_spell" => "summoner_spells"
+    }.each do |old_endpoint, new_endpoint|
+      define_method new_endpoint do
+        Proxy.new self, new_endpoint
+      end
+    end
 
-    def self.api_version
-      "v1.2"
+    def language_strings params={}
+      perform_request(api_url "language-strings", params).to_hash["data"]
     end
 
-    # Returns a full url for an API call
-    # Overrides api_url from Request
-    # @param path [String] API path to call
-    # @return [String] full fledged url
-    def api_url path, params = {}
-      super(path,params).gsub(/api\/lol/, "api/lol/static-data").gsub(/\/\/#{region}/, "//global")
+    def languages
+      perform_request api_url "languages"
     end
 
-    STANDARD_ENDPOINTS.each do |endpoint|
-      define_method(endpoint) { Proxy.new self, endpoint }
+    def maps
+      Proxy.new self, "maps"
     end
 
-    def realm
-      Proxy.new self, 'realm'
+    def profile_icons params={}
+      all "profile_icons", params
+    end
+
+    def realms
+      Proxy.new self, "realms"
     end
 
     def versions
-      Proxy.new self, 'versions'
+      Proxy.new self, "versions"
     end
 
     def get(endpoint, id=nil, params={})
-      return perform_request(api_url("versions")).map {|x| x} if endpoint == "versions"
+      return perform_request(api_url("versions")) if endpoint == "versions"
       id ? find(endpoint, id, params) : all(endpoint, params)
     end
 
     private
 
     def find(endpoint, id, params={})
-      model_class(endpoint).new \
+      OpenStruct.new \
         perform_request(api_url("#{endpoint.dasherize}/#{id}", params)).to_hash
     end
 
     def all(endpoint, params={})
-      if %w(realm).include? endpoint
-        model_class(endpoint).new perform_request(api_url(endpoint.dasherize, params)).to_hash
+      if %w(realms).include? endpoint
+        OpenStruct.new perform_request(api_url(endpoint.dasherize, params)).to_hash
       else
         perform_request(api_url(endpoint.dasherize, params))["data"].map do |id, values|
-          model_class(endpoint).new(values.merge(id: values["id"] || id))
+          OpenStruct.new(values.merge(id: values["id"] || id))
         end
       end
     end
 
-    def model_class(endpoint)
-      OpenStruct
-    end
-
     class Proxy
       def initialize(request, endpoint)
         @request = request

data/lib/lol/summoner_request.rb

@@ -1,62 +1,33 @@
 module Lol
+  # Bindings for the Summoner API.
+  #
+  # See: https://developer.riotgames.com/api-methods/#summoner-v3
   class SummonerRequest < Request
-    # Returns the supported API Version
-    # @return [String] the supported api version
-    def self.api_version
-      "v1.4"
+    # @!visibility private
+    def api_base_path
+      "/lol/summoner/#{self.class.api_version}"
     end
 
-    # Looks for a summoner name and returns the associated summoner
-    # @param [Array] summoner names
-    # @return [Array] matching summoners
-    def by_name *names
-      escaped_names = names.flatten.map { |name| CGI.escape name.downcase.gsub(/\s/, '') }
-      perform_request(api_url("summoner/by-name/#{escaped_names.join(",")}")).map do |key, data|
-        Summoner.new data
-      end
+    # Get a summoner by summoner ID.
+    # @param [Integer] id Summoner ID
+    # @return [DynamicModel] Summoner representation
+    def find id
+      DynamicModel.new perform_request api_url "summoners/#{id}"
     end
 
-    # Get list of summoner names by summoner IDs
-    # @param [Array] summoner_ids
-    # @return [Hash] Hash in the form { "id" => "name" }
-    def name *summoner_ids
-      perform_request(api_url("summoner/#{summoner_ids.join(",")}/name"))
+    # Get a summoner by summoner name.
+    # @param [String] name Summoner name
+    # @return [DynamicModel] Summoner representation
+    def find_by_name name
+      name = CGI.escape name.downcase.gsub(/\s/, '')
+      DynamicModel.new perform_request api_url "summoners/by-name/#{name}"
     end
 
-    # Get a list of summoners by summoner ID
-    # @param [Array] summoner_ids
-    # @return [Array] matching summoners
-    def get *summoner_ids
-      perform_request(api_url("summoner/#{summoner_ids.join(",")}")).map do |key, data|
-        Summoner.new data
-      end
-    end
-
-    # Get rune pages by summoner ID
-    # @param [Array] summoner_ids
-    # @return [Array] array of Lol::RunePage
-    def runes *summoner_ids
-      extract_pages RunePage, "runes", summoner_ids
-    end
-
-    # Get mastery pages by summoner ID
-    # @param [Array] summoner_ids
-    # @return [Array] array of Lol::MasteryPage
-    def masteries *summoner_ids
-      extract_pages MasteryPage, "masteries", summoner_ids
-    end
-
-    private
-
-    # Extract pages by summoner ID
-    # @param klass [Class] class used to instance objects in arrays
-    # @param page_type [String] path of the request
-    # @param *summoner_ids [Array] array of summoner_ids
-    def extract_pages klass, page_type, *summoner_ids
-      perform_request(api_url("summoner/#{summoner_ids.join(",")}/#{page_type}")).inject({}) do |ack, data|
-        ack[data.first] = data.last["pages"].map {|m| klass.new m}
-        ack
-      end
+    # Get a summoner by account ID.
+    # @param [Integer] account_id Account ID
+    # @return [DynamicModel] Summoner representation
+    def find_by_account_id account_id
+      DynamicModel.new perform_request api_url "summoners/by-account/#{account_id}"
     end
   end
 end

data/lib/lol/tournament_request.rb

@@ -0,0 +1,95 @@
+module Lol
+  class TournamentRequest < Request
+    # @!visibility private
+    def api_base_path
+      "/lol/tournament/#{self.class.api_version}"
+    end
+
+    # @!visibility private
+    def api_base_url
+      "https://global.api.riotgames.com"
+    end
+
+    # Creates a tournament provider and returns its ID.
+    # @param [String] url The provider's callback URL to which tournament game results in this region should be posted. The URL must be well-formed, use the http or https protocol, and use the default port for the protocol
+    # @return [Integer] Provider ID
+    def create_provider url:
+      body = {
+        "url"    => url,
+        "region" => region.upcase
+      }
+      perform_request api_url("providers"), :post, body
+    end
+
+    # Creates a tournament and returns its ID.
+    # @param [Integer] provider_id The provider ID to specify the regional registered provider data to associate this tournament.
+    # @param [String] name Name of the tournament
+    # @return [Integer] Tournament ID
+    def create_tournament provider_id:, name: nil
+      body = {
+        "providerId" => provider_id,
+        "name"       => name
+      }.compact
+      perform_request api_url("tournaments"), :post, body
+    end
+
+    # Create a tournament code for the given tournament.
+    # @param [Integer] count The number of codes to create (max 1000)
+    # @param [Integer] tournament_id The tournament ID
+    # @param [String] spectator_type The spectator type of the game. Valid values are NONE, LOBBYONLY, ALL.
+    # @param [Integer] team_size The team size of the game. Valid values are 1-5.
+    # @param [String] pick_type The pick type of the game. Valid values are BLIND_PICK, DRAFT_MODE, ALL_RANDOM, TOURNAMENT_DRAFT.
+    # @param [String] map_type The map type of the game. Valid values are SUMMONERS_RIFT, TWISTED_TREELINE, CRYSTAL_SCAR, and HOWLING_ABYSS.
+    # @param [Array<Integer>] allowed_participants List of participants in order to validate the players eligible to join the lobby.
+    # @param [String] metadata Optional string that may contain any data in any format, if specified at all. Used to denote any custom information about the game.
+    # @return [Array<String>] generated tournament codes
+    def create_codes tournament_id:, count: nil, allowed_participants: nil,
+                       map_type: "SUMMONERS_RIFT", metadata: nil, team_size: 5,
+                       pick_type: "TOURNAMENT_DRAFT", spectator_type: "ALL"
+      body = {
+        "allowedParticipants" => allowed_participants,
+        "mapType"             => map_type,
+        "metadata"            => metadata,
+        "pickType"            => pick_type,
+        "spectatorType"       => spectator_type,
+        "teamSize"            => team_size
+      }.compact
+      uri_params = {
+        "tournamentId" => tournament_id,
+        "count"        => count
+      }.compact
+      perform_request api_url("codes", uri_params), :post, body
+    end
+
+    # Update the pick type, map, spectator type, or allowed summoners for a code.
+    # @param [String] tournament_code The tournament code to update
+    # @param [Array<Integer>] allowed_participants List of participants in order to validate the players eligible to join the lobby.
+    # @param [String] map_type The map type of the game. Valid values are SUMMONERS_RIFT, TWISTED_TREELINE, CRYSTAL_SCAR, and HOWLING_ABYSS.
+    # @param [String] pick_type The pick type of the game. Valid values are BLIND_PICK, DRAFT_MODE, ALL_RANDOM, TOURNAMENT_DRAFT.
+    # @param [String] spectator_type The spectator type of the game. Valid values are NONE, LOBBYONLY, ALL.
+    def update_code tournament_code, allowed_participants: nil, map_type: nil, pick_type: nil, spectator_type: nil
+      body = {
+        "allowedParticipants" => allowed_participants,
+        "mapType"             => map_type,
+        "pickType"            => pick_type,
+        "spectatorType"       => spectator_type
+      }.compact
+      perform_request api_url("codes/#{tournament_code}"), :put, body
+    end
+
+    # Returns the tournament code details
+    # @param [String] tournament_code the tournament code string
+    # @return [DynamicModel] A tournament code representation
+    def find_code tournament_code
+      DynamicModel.new perform_request api_url "codes/#{tournament_code}"
+    end
+
+    # Gets a list of lobby events by tournament code
+    # @param [String] tournament_code the tournament code string
+    # @return [Array<DynamicModel>] List of lobby events
+    def all_lobby_events tournament_code:
+      result = perform_request api_url "lobby-events/by-code/#{tournament_code}"
+      result["eventList"].map { |e| DynamicModel.new e }
+    end
+  end
+end