mlb 0.7.0 → 0.8.0

data/lib/mlb/redirect_handler.rb

@@ -0,0 +1,55 @@
+require "net/http"
+require "uri"
+require_relative "connection"
+require_relative "errors/too_many_redirects"
+require_relative "request_builder"
+
+module MLB
+  class RedirectHandler
+    DEFAULT_MAX_REDIRECTS = 10
+
+    attr_accessor :max_redirects
+    attr_reader :connection, :request_builder
+
+    def initialize(connection: Connection.new, request_builder: RequestBuilder.new,
+      max_redirects: DEFAULT_MAX_REDIRECTS)
+      @connection = connection
+      @request_builder = request_builder
+      @max_redirects = max_redirects
+    end
+
+    def handle(response:, request:, base_url:, redirect_count: 0)
+      if response.is_a?(Net::HTTPRedirection)
+        raise TooManyRedirects, "Too many redirects" if redirect_count > max_redirects
+
+        new_uri = build_new_uri(response, base_url)
+
+        new_request = build_request(request, new_uri, Integer(response.code))
+        new_response = connection.perform(request: new_request)
+
+        handle(response: new_response, request: new_request, base_url:, redirect_count: redirect_count + 1)
+      else
+        response
+      end
+    end
+
+    private
+
+    def build_new_uri(response, base_url)
+      location = response.fetch("location")
+      # If location is relative, it will join with the original base URL, otherwise it will overwrite it
+      URI.join(base_url, location)
+    end
+
+    def build_request(request, uri, response_code)
+      http_method, body = case response_code
+      in 307 | 308
+        [request.method.downcase.to_sym, request.body]
+      else
+        [:get, nil]
+      end
+
+      request_builder.build(http_method:, uri:, body:)
+    end
+  end
+end

data/lib/mlb/request_builder.rb

@@ -0,0 +1,48 @@
+require "net/http"
+require "uri"
+require_relative "version"
+
+module MLB
+  class RequestBuilder
+    DEFAULT_HEADERS = {
+      "Content-Type" => "application/json; charset=utf-8",
+      "User-Agent" => "MLB-Client/#{VERSION} #{RUBY_ENGINE}/#{RUBY_VERSION} (#{RUBY_PLATFORM})"
+    }.freeze
+    HTTP_METHODS = {
+      get: Net::HTTP::Get,
+      post: Net::HTTP::Post,
+      put: Net::HTTP::Put,
+      delete: Net::HTTP::Delete
+    }.freeze
+
+    def build(http_method:, uri:, body: nil, headers: {})
+      request = create_request(http_method:, uri:, body:)
+      add_headers(request:, headers:)
+      request
+    end
+
+    private
+
+    def create_request(http_method:, uri:, body:)
+      http_method_class = HTTP_METHODS[http_method]
+
+      raise ArgumentError, "Unsupported HTTP method: #{http_method}" unless http_method_class
+
+      escaped_uri = escape_query_params(uri)
+      request = http_method_class.new(escaped_uri)
+      request.body = body
+      request
+    end
+
+    def add_headers(request:, headers:)
+      DEFAULT_HEADERS.merge(headers).each do |key, value|
+        request.delete(key)
+        request.add_field(key, value)
+      end
+    end
+
+    def escape_query_params(uri)
+      URI(uri).tap { |u| u.query = URI.encode_www_form(URI.decode_www_form(u.query)) if u.query }
+    end
+  end
+end

data/lib/mlb/response_parser.rb

@@ -0,0 +1,61 @@
+require "json"
+require "net/http"
+require_relative "errors/bad_gateway"
+require_relative "errors/bad_request"
+require_relative "errors/connection_exception"
+require_relative "errors/http_error"
+require_relative "errors/forbidden"
+require_relative "errors/gateway_timeout"
+require_relative "errors/gone"
+require_relative "errors/internal_server_error"
+require_relative "errors/not_acceptable"
+require_relative "errors/not_found"
+require_relative "errors/payload_too_large"
+require_relative "errors/service_unavailable"
+require_relative "errors/too_many_requests"
+require_relative "errors/unauthorized"
+require_relative "errors/unprocessable_entity"
+
+module MLB
+  class ResponseParser
+    ERROR_MAP = {
+      400 => BadRequest,
+      401 => Unauthorized,
+      403 => Forbidden,
+      404 => NotFound,
+      406 => NotAcceptable,
+      409 => ConnectionException,
+      410 => Gone,
+      413 => PayloadTooLarge,
+      422 => UnprocessableEntity,
+      429 => TooManyRequests,
+      500 => InternalServerError,
+      502 => BadGateway,
+      503 => ServiceUnavailable,
+      504 => GatewayTimeout
+    }.freeze
+    JSON_CONTENT_TYPE_REGEXP = %r{application/json}
+
+    def parse(response:, array_class: nil, object_class: nil)
+      raise error(response) unless response.is_a?(Net::HTTPSuccess)
+
+      return unless json?(response)
+
+      JSON.parse(response.body, array_class:, object_class:, symbolize_names: true)
+    end
+
+    private
+
+    def error(response)
+      error_class(response).new(response:)
+    end
+
+    def error_class(response)
+      ERROR_MAP[Integer(response.code)] || HTTPError
+    end
+
+    def json?(response)
+      JSON_CONTENT_TYPE_REGEXP.match?(response["content-type"])
+    end
+  end
+end

data/lib/mlb/team.rb

@@ -1,136 +1,38 @@
-require 'faraday'
-require 'multi_json'
+require "uri"
 
 module MLB
-  class Team
-    attr_reader :name, :league, :division, :manager, :wins, :losses, :founded, :mascot, :ballpark, :logo_url, :players
-
-    # Returns an array of Team objects
-    #
-    # @example
-    #   MLB::Team.all.first.name                    # => "Arizona Diamondbacks"
-    #   MLB::Team.all.first.league                  # => "National League"
-    #   MLB::Team.all.first.division                # => "National League West"
-    #   MLB::Team.all.first.manager                 # => "Bob Melvin"
-    #   MLB::Team.all.first.wins                    # => 82
-    #   MLB::Team.all.first.losses                  # => 80
-    #   MLB::Team.all.first.founded                 # => 1998
-    #   MLB::Team.all.first.mascot                  # => nil
-    #   MLB::Team.all.first.ballpark                # => "Chase Field"
-    #   MLB::Team.all.first.logo_url                # => "http://img.freebase.com/api/trans/image_thumb/wikipedia/images/en_id/13104064"
-    #   MLB::Team.all.first.players.first.name      # => "Alex Romero"
-    #   MLB::Team.all.first.players.first.number    # => 28
-    #   MLB::Team.all.first.players.first.position  # => "Right fielder"
-    def self.all
-      # Attempt to fetch the result from the Freebase API unless there is a
-      # connection error, in which case read from a fixture file
-      @all ||= begin
-        results_to_team(results_from_freebase)
-      rescue Faraday::Error::ConnectionFailed, Faraday::Error::TimeoutError
-        results_to_team(results_from_cache)
-      end
-    end
-
-    def self.reset
-      @all = nil
-    end
-
-  private
-
-    def initialize(attributes = {})
-      attributes.each do |key, value|
-        instance_variable_set("@#{key}", value) if self.respond_to?(key)
-      end
-    end
-
-    def self.results_from_freebase
-      Request.get('/freebase/v1/mqlread', :query => mql_query)
-    end
-
-    def self.results_from_cache
-      JSON.load(file_from_cache('teams.json').read)
-    end
-
-    def self.file_from_cache(file_name)
-      File.new(File.expand_path('../../../cache', __FILE__) + '/' + file_name)
-    end
-
-    def self.results_to_team(results) # rubocop:disable CyclomaticComplexity, MethodLength
-      results['result'].map do |result|
-        league      = result['league']
-        division    = result['division']
-        manager     = result['current_manager']
-        stats       = result['team_stats'].first
-        founded     = result['/sports/sports_team/founded'].first
-        mascot      = result['/sports/sports_team/team_mascot'].first
-        ballpark    = result['/sports/sports_team/arena_stadium'].first
-        logo_prefix = 'http://img.freebase.com/api/trans/image_thumb'
-        logo_suffix = result['/common/topic/image'].first
-        players     = result['/sports/sports_team/roster']
-
-        new(:name     => result['name'],
-            :league   => (league      ? league['name']                  : nil),
-            :division => (division    ? division['name']                : nil),
-            :manager  => (manager     ? manager['name']                 : nil),
-            :wins     => (stats       ? stats['wins'].to_i              : nil),
-            :losses   => (stats       ? stats['losses'].to_i            : nil),
-            :founded  => (founded     ? founded['value'].to_i           : nil),
-            :mascot   => (mascot      ? mascot['name']                  : nil),
-            :ballpark => (ballpark    ? ballpark['name']                : nil),
-            :logo_url => (logo_suffix ? logo_prefix + logo_suffix['id'] : nil),
-            :players  => (players     ? Player.all_from_roster(players) : []))
-      end
-    end
-
-    # Returns the MQL query for teams, as a Ruby hash
-    def self.mql_query # rubocop:disable MethodLength
-      query = <<-eos
-        [{
-          "name":          null,
-          "league": {
-            "name": null
-          },
-          "division": {
-            "name": null
-          },
-          "current_manager": {
-            "optional": true,
-            "name": null
-          },
-          "team_stats": [{
-            "wins":   null,
-            "losses": null,
-            "season": null,
-            "limit":  1,
-            "sort":   "-season"
-          }],
-          "/sports/sports_team/roster": [{
-            "player":   null,
-            "number":   null,
-            "from": null,
-            "to": null,
-            "position": [],
-            "sort":     "player"
-          }],
-          "/sports/sports_team/founded": [{
-            "value": null
-          }],
-          "/sports/sports_team/team_mascot": [{}],
-          "/sports/sports_team/arena_stadium": [{
-            "name": null
-          }],
-          "/common/topic/image": [{
-            "optional": true,
-            "id":        null,
-            "timestamp": null,
-            "sort":      "-timestamp",
-            "limit":     1
-          }],
-          "sort":          "name",
-          "type":          "/baseball/baseball_team"
-        }]
-        eos
-      query.gsub!("\n", '').gsub!(' ', '')
+  Team = Struct.new(:active_sw, :address, :address_city,
+    :address_country, :address_intl, :address_line1, :address_line2,
+    :address_line3, :address_province, :address_state, :address_zip, :all_star_sw,
+    :base_url, :bis_team_code, :city, :division, :division_abbrev, :division_full,
+    :division_id, :file_code, :first_year_of_play, :franchise_code, :home_opener,
+    :home_opener_time, :last_year_of_play, :league, :league_abbrev, :league_full,
+    :league_id, :mlb_org, :mlb_org_abbrev, :mlb_org_brief, :mlb_org_id,
+    :mlb_org_short, :name, :name_abbrev, :name_display_brief, :name_display_full,
+    :name_display_long, :name_display_short, :name_short, :phone_number, :season,
+    :sport_code, :sport_code_display, :sport_code_name, :sport_id, :spring_league,
+    :spring_league_abbrev, :spring_league_full, :spring_league_id, :state,
+    :store_url, :team_code, :team_id, :time_zone, :time_zone_alt,
+    :time_zone_generic, :time_zone_num, :time_zone_text, :venue_id, :venue_name,
+    :venue_short, :website_url, keyword_init: true) do
+    def self.all(season: Time.now.year, sort_order: "name_asc", all_star: false)
+      sport_code = "'mlb'"
+      season = "'#{season}'"
+      all_star_sw = all_star ? "'Y'" : "'N'"
+      params = {sport_code:, season:, sort_order:, all_star_sw:}
+      query_string = URI.encode_www_form(params)
+      response = CLIENT.get("named.team_all_season.bam?#{query_string}")
+      teams = response[:team_all_season][:queryResults][:row]
+      teams.collect { |team| Team.new(**team) }
+    end
+
+    def roster
+      require_relative "player"
+      params = {team_id:}
+      query_string = URI.encode_www_form(params)
+      response = CLIENT.get("named.roster_40.bam?#{query_string}")
+      players = response[:roster_40][:queryResults][:row]
+      players.collect { |player| Player.new(**player) }
     end
   end
 end

data/lib/mlb/transaction.rb

@@ -0,0 +1,37 @@
+require "date"
+require "uri"
+
+module MLB
+  Transaction = Struct.new(:conditional_sw, :effective_date, :final_asset,
+    :final_asset_type, :from_team, :from_team_id, :name_display_first_last,
+    :name_display_last_first, :name_sort, :note, :orig_asset, :orig_asset_type,
+    :player, :player_id, :resolution_cd, :resolution_date, :team, :team_id,
+    :trans_date, :trans_date_cd, :transaction_id, :type, :type_cd, keyword_init: true) do
+    def self.all(start_date: Date.today, end_date: Date.today)
+      sport_code = "'mlb'"
+      start_date = Date.parse(start_date.to_s).strftime("%Y%m%d")
+      end_date = Date.parse(end_date.to_s).strftime("%Y%m%d")
+      params = {sport_code:, start_date:, end_date:}
+      query_string = URI.encode_www_form(params)
+      response = CLIENT.get("named.transaction_all.bam?#{query_string}")
+      transactions = response.fetch(:transaction_all, {}).fetch(:queryResults, {}).fetch(:row, [])
+      transactions.collect { |transaction| Transaction.new(**transaction) }
+    end
+
+    def team
+      require_relative "team"
+      teams = effective_date.to_s.empty? ? Team.all : Team.all(season: effective_date.to_s[0...4].to_i)
+      teams.find { |t| t[:team_id] == team_id.to_s }
+    end
+
+    def player
+      params = {team_id:}
+      query_string = URI.encode_www_form(params)
+      response = CLIENT.get("named.roster_40.bam?#{query_string}")
+      players = response[:roster_40][:queryResults][:row]
+      player = players.find { |p| p[:player_id] == player_id.to_s }
+      require_relative "player"
+      Player.new(**player)
+    end
+  end
+end

data/lib/mlb/version.rb

@@ -1,15 +1,5 @@
-module MLB
-  class Version
-    MAJOR = 0
-    MINOR = 7
-    PATCH = 0
-    PRE = nil
+require "rubygems/version"
 
-    class << self
-      # @return [String]
-      def to_s
-        [MAJOR, MINOR, PATCH, PRE].compact.join('.')
-      end
-    end
-  end
+module MLB
+  VERSION = Gem::Version.create("0.8.0")
 end

data/lib/mlb.rb

@@ -1,3 +1,3 @@
-require 'mlb/request'
-require 'mlb/team'
-require 'mlb/player'
+require_relative "mlb/client"
+require_relative "mlb/team"
+require_relative "mlb/transaction"

data/sig/mlb.rbs

@@ -0,0 +1,191 @@
+module MLB
+  CLIENT: Client
+  VERSION: Gem::Version
+
+  class Error < StandardError
+  end
+
+  class ClientError < HTTPError
+  end
+
+  class BadGateway < ClientError
+  end
+
+  class BadRequest < ClientError
+  end
+
+  class ConnectionException < ClientError
+  end
+
+  class HTTPError < Error
+    attr_reader response : Net::HTTPResponse
+    attr_reader code : String
+
+    def initialize: (response: Net::HTTPResponse) -> void
+  end
+
+  class Forbidden < ClientError
+  end
+
+  class GatewayTimeout < ClientError
+  end
+
+  class Gone < ClientError
+  end
+
+  class InternalServerError < ServerError
+  end
+
+  class NetworkError < Error
+  end
+
+  class NotAcceptable < ClientError
+  end
+
+  class NotFound < ClientError
+  end
+
+  class PayloadTooLarge < ClientError
+  end
+
+  class ServerError < HTTPError
+  end
+
+  class ServiceUnavailable < ServerError
+  end
+
+  class TooManyRedirects < Error
+  end
+
+  class TooManyRequests < ClientError
+  end
+
+  class Unauthorized < ClientError
+  end
+
+  class UnprocessableEntity < ClientError
+  end
+
+  class Connection
+    DEFAULT_HOST: String
+    DEFAULT_PORT: Integer
+    DEFAULT_OPEN_TIMEOUT: Integer
+    DEFAULT_READ_TIMEOUT: Integer
+    DEFAULT_WRITE_TIMEOUT: Integer
+    DEFAULT_DEBUG_OUTPUT: IO
+    NETWORK_ERRORS: Array[(singleton(Errno::ECONNREFUSED) | singleton(Errno::ECONNRESET) | singleton(Net::OpenTimeout) | singleton(Net::ReadTimeout) | singleton(OpenSSL::SSL::SSLError))]
+
+    @proxy_url: URI::Generic | String
+
+    extend Forwardable
+
+    attr_accessor open_timeout : Float | Integer
+    attr_accessor read_timeout : Float | Integer
+    attr_accessor write_timeout : Float | Integer
+    attr_accessor debug_output : IO
+
+    attr_reader proxy_uri: URI::Generic?
+    attr_reader proxy_host : String?
+    attr_reader proxy_port : Integer?
+    attr_reader proxy_user : String?
+    attr_reader proxy_pass : String?
+
+    def initialize: (?open_timeout: Float | Integer, ?read_timeout: Float | Integer, ?write_timeout: Float | Integer, ?proxy_url: URI::Generic? | String?, ?debug_output: IO) -> void
+    def proxy_url=: (URI::Generic | String proxy_url) -> void
+    def perform: (request: Net::HTTPRequest) -> Net::HTTPResponse
+
+    private
+    def build_http_client: (?String host, ?Integer port) -> Net::HTTP
+    def configure_http_client: (Net::HTTP http_client) -> Net::HTTP
+  end
+
+  class RequestBuilder
+    HTTP_METHODS: Hash[Symbol, (singleton(Net::HTTP::Get) | singleton(Net::HTTP::Post) | singleton(Net::HTTP::Put) | singleton(Net::HTTP::Delete))]
+    DEFAULT_HEADERS: Hash[String, String]
+
+    def initialize: (?content_type: String, ?user_agent: String) -> void
+    def build: (http_method: Symbol, uri: URI::Generic, ?body: String?, ?headers: Hash[String, String]) -> (Net::HTTPRequest)
+
+    private
+    def create_request: (http_method: Symbol, uri: URI::Generic, body: String?) -> (Net::HTTPRequest)
+    def add_headers: (request: Net::HTTPRequest, headers: Hash[String, String]) -> void
+    def escape_query_params: (URI::Generic uri) -> URI::Generic
+  end
+
+  class RedirectHandler
+    DEFAULT_MAX_REDIRECTS: Integer
+
+    attr_reader connection: Connection
+    attr_reader request_builder: RequestBuilder
+    attr_reader max_redirects: Integer
+    def initialize: (?connection: Connection, ?request_builder: RequestBuilder, ?max_redirects: Integer) -> void
+    def handle: (response: Net::HTTPResponse, request: Net::HTTPRequest, base_url: String, ?redirect_count: Integer) -> Net::HTTPResponse
+
+    private
+    def build_new_uri: (Net::HTTPResponse response, String base_url) -> URI::Generic
+    def build_request: (Net::HTTPRequest request, URI::Generic new_uri, Integer response_code) -> Net::HTTPRequest
+    def send_new_request: (URI::Generic new_uri, Net::HTTPRequest new_request) -> Net::HTTPResponse
+  end
+
+  class ResponseParser
+    ERROR_MAP: Hash[Integer, singleton(BadGateway) | singleton(BadRequest) | singleton(ConnectionException) | singleton(Forbidden) | singleton(GatewayTimeout) | singleton(Gone) | singleton(InternalServerError) | singleton(NotAcceptable) | singleton(NotFound) | singleton(PayloadTooLarge) | singleton(ServiceUnavailable) | singleton(TooManyRequests) | singleton(Unauthorized) | singleton(UnprocessableEntity)]
+    JSON_CONTENT_TYPE_REGEXP: Regexp
+
+    def parse: (response: Net::HTTPResponse, ?array_class: Class?, ?object_class: Class?) -> untyped
+
+    private
+    def error: (Net::HTTPResponse response) -> HTTPError
+    def error_class: (Net::HTTPResponse response) -> (singleton(BadGateway) | singleton(BadRequest) | singleton(ConnectionException) | singleton(Forbidden) | singleton(GatewayTimeout) | singleton(Gone) | singleton(InternalServerError) | singleton(NotAcceptable) | singleton(NotFound) | singleton(PayloadTooLarge) | singleton(ServiceUnavailable) | singleton(TooManyRequests) | singleton(Unauthorized) | singleton(UnprocessableEntity))
+    def json?: (Net::HTTPResponse response) -> bool
+  end
+
+  class Client
+    DEFAULT_BASE_URL: String
+    DEFAULT_ARRAY_CLASS: singleton(Array)
+    DEFAULT_OBJECT_CLASS: singleton(Hash)
+    extend Forwardable
+    @connection: Connection
+    @request_builder: RequestBuilder
+    @redirect_handler: RedirectHandler
+    @response_parser: ResponseParser
+
+    attr_accessor base_url: String
+    attr_accessor default_array_class: singleton(Array)
+    attr_accessor default_object_class: singleton(Hash)
+    def initialize: (?base_url: String, ?open_timeout: Integer, ?read_timeout: Integer, ?write_timeout: Integer, ?debug_output: untyped, ?proxy_url: nil, ?default_array_class: singleton(Array), ?default_object_class: singleton(Hash), ?max_redirects: Integer) -> void
+    def get: (String endpoint, ?headers: Hash[String, String], ?array_class: Class, ?object_class: Class) -> untyped
+    def post: (String endpoint, ?String? body, ?headers: Hash[String, String], ?array_class: Class, ?object_class: Class) -> untyped
+    def put: (String endpoint, ?String? body, ?headers: Hash[String, String], ?array_class: Class, ?object_class: Class) -> untyped
+    def delete: (String endpoint, ?headers: Hash[String, String], ?array_class: Class, ?object_class: Class) -> untyped
+
+    private
+    def initialize_default_classes: (singleton(Array) default_array_class, singleton(Hash) default_object_class) -> singleton(Hash)
+    def execute_request: (:delete | :get | :post | :put http_method, String endpoint, ?body: String?, ?headers: Hash[String, String], ?array_class: Class, ?object_class: Class) -> nil
+  end
+
+  attr_accessor effective_date: String
+  attr_accessor player_id: String
+  attr_accessor team_id: String
+
+  class Team < Struct[untyped]
+    attr_accessor team_id: String
+    def self.new: -> void
+    def self.all: (?season: Integer, ?sort_order: String, ?all_star: false) -> Array[Team]
+    def roster: -> Array[Player]
+  end
+
+  class Transaction < Struct[untyped]
+    attr_accessor player_id: String
+    attr_accessor team_id: String
+    def self.new: -> void
+    def self.all: (?season: Integer, ?sort_order: String, ?all_star: false) -> Array[Team]
+    def team: -> Team
+    def player: -> Player
+  end
+
+  class Player < Struct[untyped]
+    attr_accessor player_id: String
+    def self.new: -> void
+    def team: -> Team
+  end
+end