rito 0.1.0

data/lib/rito/endpoints/lol/spectator_v5.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Rito
+  module Endpoints
+    module Lol
+      class SpectatorV5 < Base
+        ROUTING = :platform
+
+        # Returns nil when the summoner is not in an active game (HTTP 404).
+        def active_game(summoner_id, region: nil)
+          get("/lol/spectator/v5/active-games/by-summoner-id/#{escape(summoner_id)}", region)
+        rescue NotFound
+          nil
+        end
+
+        def featured_games(region: nil)
+          get('/lol/spectator/v5/featured-games', region)
+        end
+      end
+    end
+  end
+end

data/lib/rito/endpoints/lol/status_v4.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rito
+  module Endpoints
+    module Lol
+      class StatusV4 < Base
+        ROUTING = :platform
+
+        def platform_data(region: nil)
+          get('/lol/status/v4/platform-data', region)
+        end
+      end
+    end
+  end
+end

data/lib/rito/endpoints/lol/summoner_v4.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rito
+  module Endpoints
+    module Lol
+      class SummonerV4 < Base
+        ROUTING = :platform
+
+        def by_puuid(puuid, region: nil)
+          Models::Summoner.from_api(
+            get("/lol/summoner/v4/summoners/by-puuid/#{escape(puuid)}", region)
+          )
+        end
+
+        def by_name(name, region: nil)
+          Models::Summoner.from_api(
+            get("/lol/summoner/v4/summoners/by-name/#{escape(name)}", region)
+          )
+        end
+
+        def by_account_id(account_id, region: nil)
+          Models::Summoner.from_api(
+            get("/lol/summoner/v4/summoners/by-account/#{escape(account_id)}", region)
+          )
+        end
+
+        def by_summoner_id(summoner_id, region: nil)
+          Models::Summoner.from_api(
+            get("/lol/summoner/v4/summoners/#{escape(summoner_id)}", region)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rito/endpoints/lol/tournament_v5.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Rito
+  module Endpoints
+    module Lol
+      class TournamentV5 < Base
+        ROUTING = :platform
+        PREFIX = '/lol/tournament/v5'
+
+        def code(tournament_code, region: nil)
+          get("#{PREFIX}/codes/by-code/#{escape(tournament_code)}", region)
+        end
+
+        def create_codes(tournament_id:, count: nil, body: {}, region: nil)
+          params = { 'tournamentId' => tournament_id }
+          params['count'] = count if count
+          post("#{PREFIX}/codes", region, params: params, body: body)
+        end
+
+        def update_code(tournament_code, body: {}, region: nil)
+          put("#{PREFIX}/codes/by-code/#{escape(tournament_code)}", region, body: body)
+        end
+
+        def lobby_events(tournament_code, region: nil)
+          get("#{PREFIX}/lobby-events/by-code/#{escape(tournament_code)}", region)
+        end
+
+        def create_provider(body:, region: nil)
+          post("#{PREFIX}/providers", region, body: body)
+        end
+
+        def create_tournament(body:, region: nil)
+          post("#{PREFIX}/tournaments", region, body: body)
+        end
+      end
+
+      class TournamentStubV5 < Base
+        ROUTING = :platform
+        PREFIX = '/lol/tournament-stub/v5'
+
+        def code(tournament_code, region: nil)
+          get("#{PREFIX}/codes/by-code/#{escape(tournament_code)}", region)
+        end
+
+        def create_codes(tournament_id:, count: nil, body: {}, region: nil)
+          params = { 'tournamentId' => tournament_id }
+          params['count'] = count if count
+          post("#{PREFIX}/codes", region, params: params, body: body)
+        end
+
+        def update_code(tournament_code, body: {}, region: nil)
+          put("#{PREFIX}/codes/by-code/#{escape(tournament_code)}", region, body: body)
+        end
+
+        def lobby_events(tournament_code, region: nil)
+          get("#{PREFIX}/lobby-events/by-code/#{escape(tournament_code)}", region)
+        end
+
+        def create_provider(body:, region: nil)
+          post("#{PREFIX}/providers", region, body: body)
+        end
+
+        def create_tournament(body:, region: nil)
+          post("#{PREFIX}/tournaments", region, body: body)
+        end
+      end
+    end
+  end
+end

data/lib/rito/endpoints/lor.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Rito
+  module Endpoints
+    module Lor
+      class MatchV1 < Base
+        ROUTING = :regional
+
+        def ids_by_puuid(puuid, region: nil)
+          get("/lor/match/v1/matches/by-puuid/#{escape(puuid)}/ids", region)
+        end
+
+        def by_id(match_id, region: nil)
+          get("/lor/match/v1/matches/#{escape(match_id)}", region)
+        end
+      end
+
+      class RankedV1 < Base
+        ROUTING = :regional
+
+        def leaderboards(region: nil)
+          get('/lor/ranked/v1/leaderboards', region)
+        end
+      end
+
+      class StatusV1 < Base
+        ROUTING = :regional
+
+        def platform_data(region: nil)
+          get('/lor/status/v1/platform-data', region)
+        end
+      end
+
+      class DeckV1 < Base
+        ROUTING = :regional
+
+        # Requires the client to be configured with a bearer_token (RSO).
+        def my_decks(region: nil)
+          get('/lor/deck/v1/decks/me', region)
+        end
+
+        def deck(deck_id, region: nil)
+          get("/lor/deck/v1/decks/me/#{escape(deck_id)}", region)
+        end
+      end
+
+      class InventoryV1 < Base
+        ROUTING = :regional
+
+        # Requires the client to be configured with a bearer_token (RSO).
+        def my_cards(region: nil)
+          get('/lor/inventory/v1/cards/me', region)
+        end
+      end
+    end
+
+    class Riftbound < Base
+      ROUTING = :regional
+
+      def contents(locale: nil, region: nil)
+        params = {}
+        params['locale'] = locale if locale
+        get('/riftbound/content/v1/contents', region, params: params)
+      end
+    end
+  end
+
+  module Lor
+    class Api
+      def initialize(client)
+        @client = client
+      end
+
+      def matches
+        Endpoints::Lor::MatchV1.new(@client)
+      end
+
+      def ranked
+        Endpoints::Lor::RankedV1.new(@client)
+      end
+
+      def status
+        Endpoints::Lor::StatusV1.new(@client)
+      end
+
+      def decks
+        Endpoints::Lor::DeckV1.new(@client)
+      end
+
+      def inventory
+        Endpoints::Lor::InventoryV1.new(@client)
+      end
+    end
+  end
+end

data/lib/rito/endpoints/tft.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Rito
+  module Endpoints
+    module Tft
+      class SummonerV1 < Base
+        ROUTING = :platform
+        PREFIX = '/tft/summoner/v1/summoners'
+
+        def by_puuid(puuid, region: nil)
+          Models::Summoner.from_api(get("#{PREFIX}/by-puuid/#{escape(puuid)}", region))
+        end
+
+        def by_account_id(account_id, region: nil)
+          Models::Summoner.from_api(get("#{PREFIX}/by-account/#{escape(account_id)}", region))
+        end
+
+        def by_summoner_id(summoner_id, region: nil)
+          Models::Summoner.from_api(get("#{PREFIX}/#{escape(summoner_id)}", region))
+        end
+
+        # Requires the client to be configured with a bearer_token (RSO).
+        def me(region: nil)
+          Models::Summoner.from_api(get("#{PREFIX}/me", region))
+        end
+      end
+
+      class LeagueV1 < Base
+        ROUTING = :regional
+
+        def entries_by_summoner_id(summoner_id, queue: nil, tier: nil, division: nil, region: nil)
+          params = {}
+          params['queue'] = queue if queue
+          params['tier'] = tier if tier
+          params['division'] = division if division
+          get("/tft/league/v1/entries/by-summoner/#{escape(summoner_id)}", region, params: params)
+        end
+
+        def challenger(region: nil)
+          get('/tft/league/v1/challenger', region)
+        end
+
+        def grandmaster(region: nil)
+          get('/tft/league/v1/grandmaster', region)
+        end
+
+        def master(region: nil)
+          get('/tft/league/v1/master', region)
+        end
+
+        def rated_ladder_top(queue, region: nil)
+          get("/tft/league/v1/rated-ladders/#{escape(queue)}/top", region)
+        end
+      end
+
+      class MatchV1 < Base
+        ROUTING = :regional
+
+        def ids_by_puuid(puuid, count: nil, start: nil, region: nil)
+          params = {}
+          params['count'] = count if count
+          params['start'] = start if start
+          get("/tft/match/v1/matches/by-puuid/#{escape(puuid)}/ids", region, params: params)
+        end
+
+        def by_id(match_id, region: nil)
+          get("/tft/match/v1/matches/#{escape(match_id)}", region)
+        end
+      end
+
+      class StatusV1 < Base
+        ROUTING = :platform
+
+        def platform_data(region: nil)
+          get('/tft/status/v1/platform-data', region)
+        end
+      end
+
+      class SpectatorTftV5 < Base
+        ROUTING = :platform
+
+        # Returns nil when the summoner is not in an active game (HTTP 404).
+        def active_game(summoner_id, region: nil)
+          get("/tft/spectator/v5/active-games/by-summoner-id/#{escape(summoner_id)}", region)
+        rescue NotFound
+          nil
+        end
+
+        def featured_games(region: nil)
+          get('/tft/spectator/v5/featured-games', region)
+        end
+      end
+    end
+  end
+
+  module Tft
+    class Api
+      def initialize(client)
+        @client = client
+      end
+
+      def summoner
+        Endpoints::Tft::SummonerV1.new(@client)
+      end
+
+      def leagues
+        Endpoints::Tft::LeagueV1.new(@client)
+      end
+
+      def matches
+        Endpoints::Tft::MatchV1.new(@client)
+      end
+
+      def status
+        Endpoints::Tft::StatusV1.new(@client)
+      end
+
+      def spectator
+        Endpoints::Tft::SpectatorTftV5.new(@client)
+      end
+    end
+  end
+end

data/lib/rito/endpoints/valorant.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Rito
+  module Endpoints
+    module Valorant
+      class ContentV1 < Base
+        ROUTING = :valorant_platform
+
+        def contents(locale: nil, region: nil)
+          params = {}
+          params['locale'] = locale if locale
+          get('/val/content/v1/contents', region, params: params)
+        end
+      end
+
+      class MatchV1 < Base
+        ROUTING = :valorant_platform
+
+        def by_id(match_id, region: nil)
+          get("/val/match/v1/matches/#{escape(match_id)}", region)
+        end
+
+        def ids_by_puuid(puuid, region: nil)
+          get("/val/match/v1/matchlists/by-puuid/#{escape(puuid)}", region)
+        end
+
+        def recent_by_queue(queue, region: nil)
+          get("/val/match/v1/recent-matches/by-queue/#{escape(queue)}", region)
+        end
+      end
+
+      class ConsoleMatchV1 < Base
+        ROUTING = :valorant_console_platform
+
+        def by_id(match_id, region: nil)
+          get("/val/console/match/v1/matches/#{escape(match_id)}", region)
+        end
+
+        def ids_by_puuid(puuid, region: nil)
+          get("/val/console/match/v1/matchlists/by-puuid/#{escape(puuid)}", region)
+        end
+      end
+
+      class RankedV1 < Base
+        ROUTING = :valorant_platform
+
+        def leaderboard(act_id, size: nil, start_index: nil, region: nil)
+          params = {}
+          params['size'] = size if size
+          params['startIndex'] = start_index if start_index
+          get("/val/ranked/v1/leaderboards/by-act/#{escape(act_id)}", region, params: params)
+        end
+      end
+
+      class StatusV1 < Base
+        ROUTING = :valorant_platform
+
+        def platform_data(region: nil)
+          get('/val/status/v1/platform-data', region)
+        end
+      end
+    end
+  end
+
+  module Val
+    class Api
+      def initialize(client)
+        @client = client
+      end
+
+      def content
+        Endpoints::Valorant::ContentV1.new(@client)
+      end
+
+      def matches
+        Endpoints::Valorant::MatchV1.new(@client)
+      end
+
+      def console_matches
+        Endpoints::Valorant::ConsoleMatchV1.new(@client)
+      end
+
+      def ranked
+        Endpoints::Valorant::RankedV1.new(@client)
+      end
+
+      def status
+        Endpoints::Valorant::StatusV1.new(@client)
+      end
+    end
+  end
+end

data/lib/rito/errors.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Rito
+  class Error < StandardError
+    attr_reader :response, :status
+
+    def initialize(message = nil, response: nil)
+      @response = response
+      @status = response&.status
+      super(message || default_message)
+    end
+
+    private
+
+    def default_message
+      base = self.class.name.split('::').last
+      detail = @status ? " (HTTP #{@status})" : ''
+      "#{base}#{detail}"
+    end
+  end
+
+  class ConfigError < Error; end
+
+  class BadRequest < Error; end
+  class Unauthorized < Error; end
+  class Forbidden < Error; end
+  class NotFound < Error; end
+  class MethodNotAllowed < Error; end
+  class UnsupportedMediaType < Error; end
+
+  class RateLimited < Error
+    attr_reader :retry_after, :limit_type
+
+    def initialize(message = nil, retry_after: nil, limit_type: nil, response: nil)
+      @retry_after = retry_after
+      @limit_type = limit_type
+      super(message, response: response)
+    end
+  end
+
+  class ServerError < Error; end
+  class ServiceUnavailable < ServerError; end
+
+  class ConnectionError < Error
+    attr_reader :wrapped
+
+    def initialize(message = nil, wrapped: nil)
+      @wrapped = wrapped
+      super(message)
+    end
+  end
+
+  class TimeoutError < ConnectionError; end
+  class SSLError < ConnectionError; end
+end

data/lib/rito/instrumentation.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Rito
+  # Emits `request.rito` events via ActiveSupport::Notifications when
+  # ActiveSupport is available; a no-op otherwise.
+  module Instrumentation
+    EVENT = 'request.rito'
+
+    class << self
+      def emit(payload)
+        return unless defined?(ActiveSupport::Notifications)
+
+        ActiveSupport::Notifications.instrument(EVENT, payload)
+      end
+    end
+  end
+end

data/lib/rito/middleware/authentication.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Rito
+  module Middleware
+    class Authentication < Faraday::Middleware
+      def initialize(app, client:)
+        super(app)
+        @client = client
+      end
+
+      def call(env)
+        if @client.api_key
+          env.request_headers['X-Riot-Token'] = @client.api_key
+        elsif @client.bearer_token
+          env.request_headers['Authorization'] = "Bearer #{@client.bearer_token}"
+        end
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/rito/middleware/rate_limit_observe.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rito
+  module Middleware
+    # First response middleware: syncs limiter state from rate limit headers
+    # before RiotErrors raises, so blocks are in place before any retry.
+    class RateLimitObserve < Faraday::Middleware
+      def initialize(app, client:)
+        super(app)
+        @client = client
+      end
+
+      def on_complete(env)
+        limiter = @client.limiter
+        return if limiter.nil? || @client.api_key.nil?
+
+        limiter.observe!(Faraday::Response.new(env), key: @client.api_key,
+                                                     region: region_from(env), bucket: bucket_from(env))
+      end
+
+      private
+
+      def region_from(env)
+        env.url.host.to_s.split('.').first
+      end
+
+      def bucket_from(env)
+        env.url.path.split('/').first(2).join('/')
+      end
+    end
+  end
+end

data/lib/rito/middleware/rate_limit_throttle.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Rito
+  module Middleware
+    # Runs before the network call: blocks until the adaptive limiter allows
+    # the request, and retries RateLimited responses until max_retries is
+    # exhausted (the limiter blocks the bucket before the rescue, so the retry
+    # honors Retry-After automatically). Region and endpoint bucket are derived
+    # from the request URL.
+    class RateLimitThrottle < Faraday::Middleware
+      def initialize(app, client:)
+        super(app)
+        @client = client
+      end
+
+      def call(env)
+        limiter = @client.limiter
+        key = @client.api_key
+        return @app.call(env) if limiter.nil? || key.nil?
+
+        attempts = 0
+        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        begin
+          limiter.acquire!(key: key, region: region_from(env), bucket: bucket_from(env))
+          response = @app.call(env)
+          emit(env, response.status, started, attempts)
+          response
+        rescue Rito::RateLimited => e
+          emit(env, e.status, started, attempts, error: e.class.name)
+          attempts += 1
+          retry if attempts <= @client.max_retries
+          raise
+        end
+      end
+
+      private
+
+      def emit(env, status, started, attempts, error: nil)
+        Instrumentation.emit(
+          http_method: env.method,
+          url: env.url.to_s,
+          status: status,
+          attempts: attempts,
+          duration_ms: ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round(2),
+          error: error
+        )
+      end
+
+      def region_from(env)
+        env.url.host.to_s.split('.').first
+      end
+
+      def bucket_from(env)
+        env.url.path.split('/').first(2).join('/')
+      end
+    end
+  end
+end