gameday_api 0.5.0 → 0.5.1

data/lib/pitching_appearance.rb

@@ -0,0 +1,118 @@
+
+# This class holds data that represents a single pitching appearance by a pitcher.
+class PitchingAppearance
+  
+  attr_accessor :pid, :gid, :pitcher_name, :out, :inn, :er, :r, :h, :so, :hr, :bb, :bf
+  attr_accessor :w, :l, :era, :note, :start, :game
+  attr_accessor :pitches, :b, :s, :x, :max_speed, :min_speed
+  
+  # Used to initialize from box score data
+  def init(gid, element, count)
+    @pitches = []
+    @gid = gid
+    @pid                  = element.attributes['id']
+    @pitcher_name  = element.attributes['name']
+    @out               = element.attributes['out']
+    @inn               = convert_out_to_inn(element.attributes['out'])
+    @bf                = element.attributes['bf']
+    @er                = element.attributes['er']
+    @r                  = element.attributes['r']
+    @h                 = element.attributes['h']
+    @so                = element.attributes['so']
+    @hr                = element.attributes['hr']
+    @bb               = element.attributes['bb']
+    @w                = element.attributes['w']
+    @l                  = element.attributes['l']
+    @era              = element.attributes['era']
+    @note            = element.attributes['note']
+    if count == 1
+      @start = true
+    else
+      @start = false
+    end
+  end
+    
+   
+  # Returns true if this appearance is a start
+  def start?
+    start
+  end
+  
+  
+  # Returns true if this was a quality start
+  # A quality start is defined as being greater than or equal to 6 innings and allowing 3 runs or less
+  def quality_start?
+    if @inn.to_i >= 6 && @r.to_i < 4
+      return true
+    end
+    return false
+  end
+  
+  
+  # Returns an array of the atbats against this pitcher during this game
+  def get_vs_ab
+    results = []
+    abs = get_game.get_atbats
+    abs.each do |ab|
+      if ab.pitcher_id == @pid
+        results << ab
+      end
+    end
+    results
+  end
+  
+  
+  # Returns an array of pitches thrown by this pitcher during this game
+  def get_pitches
+    @pitches = []
+    ab = get_vs_ab
+    ab.each do |ab|
+      @pitches << ab.pitches
+    end
+    @pitches.flatten!
+  end
+  
+  
+  def set_pitch_stats
+    @b, @s, @x, @max_speed, @min_speed = 0, 0, 0, 0, 200
+    pitches = get_pitches
+    pitches.each do |pitch|
+      case pitch.type
+      when 'B'
+        @b += 1
+      when 'S'
+        @s += 1
+      when 'X'
+        @x += 1
+      end
+      if pitch.start_speed.to_f > @max_speed
+        @max_speed = pitch.start_speed.to_f
+      end
+      if pitch.start_speed.to_f < @min_speed
+        @min_speed = pitch.start_speed.to_f
+      end
+    end
+  end
+  
+  
+  def pitch_count
+    get_pitches.length
+  end
+  
+  
+  def get_game
+    if !@game
+      @game = Game.new(@gid)
+    end
+    @game
+  end
+    
+    
+  private
+  def convert_out_to_inn(outs)
+    num_out = outs.to_i
+    part = num_out % 3
+    return (num_out/3).to_s + '.' + part.to_s
+  end
+  
+end

data/lib/player.rb

@@ -0,0 +1,145 @@
+require 'gameday_fetcher'
+
+# This class represents a single MLB player from a single MLB game
+class Player
+  
+  # attributes from players.xml
+  attr_accessor :gid, :pid, :first, :last, :num, :boxname, :rl, :position, :status, :bat_order, :game_position 
+  attr_accessor :avg, :hr, :std_hr, :rbi, :wins, :losses, :era, :saves, :team_code
+  
+  # attributes from batters/13353333.xml or pitchers/1222112.xml
+  attr_accessor :team_abbrev, :type, :height, :weight, :bats, :throws, :dob
+    
+  # object pointers
+  attr_accessor :team_obj, :games, :appearances
+  
+  
+  # Initializes a Player object by reading the player data from the players.xml file for the player specified by game id and player id.
+  def load_from_id(gid, pid)
+    @gid = gid
+    @pid = pid
+    # fetch players.xml file
+    @xml_data = GamedayFetcher.fetch_players(gid)
+    @xml_doc = REXML::Document.new(@xml_data)
+    # find specific player in the file
+    pelement = @xml_doc.root.elements["team/player[@id=#{pid}]"]
+    init(pelement, gid)
+  end
+  
+  
+  # Initializes pitcher info from data read from the masterscoreboard.xml file
+  def init_pitcher_from_scoreboard(element)
+    @first = element.attributes['first']
+    @last = element.attributes['last']
+    @wins = element.attributes['wins']
+    @losses = element.attributes['losses']
+    @era = element.attributes['era']
+  end
+    
+   
+  # Returns an array of all the appearances (Batting or Pitching) made by this player
+  # for the season specified.
+  def get_all_appearances(year)
+    if !@appearances
+      @appearances = []
+      all_appearances = []
+      games = get_games_for_season(year)    
+      games.each do |game|
+        @team_abbrev == game.home_team_abbrev ? status = 'home' : status = 'away'
+        if @position == 'P'
+          all_appearances.push *(game.get_pitchers(status))
+        else
+          all_appearances.push *(game.get_batters(status))
+        end
+      end
+      # now go through all appearances to find those for this player
+      all_appearances.each do |appearance|
+        if appearance.pid == @pid
+         @appearances << appearance
+        end
+      end
+    end
+    @appearances
+  end
+  
+  
+  # Returns the number of at bats over the entire season for this player
+  def at_bats_count
+    gameday_info = GamedayUtil.parse_gameday_id(@gid)
+    appearances = get_all_appearances(gameday_info["year"])
+    count = appearances.inject(0) {|sum, a| sum + a.ab.to_i }    
+  end
+  
+  
+  # Returns the Team object representing the team for which this player plays
+  def get_team
+    if !@team_obj
+      @team_obj = Team.new(@team_abbrev)
+    end
+    @team_obj
+  end
+  
+  
+  # Returns an array of all the games for the team this player is on for the season specified
+  # currently will not handle a player who has played for multiple teams over a season
+  def get_games_for_season(year)
+    if !@games
+      @games = get_team.all_games(year)  
+    end
+    @games
+  end
+  
+  
+  # Initialize a player object by reading data from the players.xml file
+  def init(element, gid)
+    @gid = gid
+    @pid = element.attributes['id']
+    @first = element.attributes['first']
+    @last = element.attributes['last']
+    @num= element.attributes['num']
+    @boxname = element.attributes['boxname']
+    @rl, = element.attributes['rl']
+    @position = element.attributes['position']
+    @status = element.attributes['status']
+    @bat_order = element.attributes['bat_order']
+    @game_position = element.attributes['game_position']
+    @avg = element.attributes['avg']
+    @hr = element.attributes['hr']
+    @rbi = element.attributes['rbi']
+    @wins = element.attributes['wins']
+    @losses = element.attributes['losses']
+    @era = element.attributes['era']   
+    set_extra_info
+  end
+  
+  
+  private
+  
+  
+  # Set data that is read from the batter or pitcher file found in the batters/xxxxxxx.xml file or pitchers/xxxxxx.xml file
+  def set_extra_info
+    begin
+      if @position == 'P'
+        xml_data = GamedayFetcher.fetch_pitcher(@gid, @pid)
+      else
+        xml_data = GamedayFetcher.fetch_batter(@gid, @pid)
+      end
+      xml_doc = REXML::Document.new(xml_data)
+      @team_abbrev = xml_doc.root.attributes['team']
+      @type = xml_doc.root.attributes['type']
+      @height = xml_doc.root.attributes['height']
+      @weight = xml_doc.root.attributes['weight']
+      @bats = xml_doc.root.attributes['bats']
+      @throws = xml_doc.root.attributes['throws']
+      @dob = xml_doc.root.attributes['dob']
+    rescue
+      if @postion == 'P'
+        puts "Pitcher file pitchers/#{@pid}.xml not found"
+      else
+        puts "Batter file batters/#{@pid}.xml not found"
+      end
+    end
+  end
+  
+  
+end

data/lib/players.rb

@@ -0,0 +1,42 @@
+require 'roster'
+
+
+# This class represents the players.xml file found on the gameday server for each MLB game.
+#  The players.xml file contains a listing of all players on the home and away teams for the specified game
+class Players
+  
+  attr_accessor :xml_data, :gid, :venue, :date, :rosters, :umpires
+  
+  # Loads the players XML from the MLB gameday server and parses it using REXML
+  def load_from_id(gid)
+    @gid = gid
+    @rosters = []
+    @umpires = {}
+    @xml_data = GamedayFetcher.fetch_players(gid)
+    @xml_doc = REXML::Document.new(@xml_data)
+    if @xml_doc.root
+      self.set_rosters
+      self.set_umpires
+    end
+  end
+  
+  
+  def set_rosters()
+    away_roster = Roster.new
+    away_roster.init(@xml_doc.root.elements["team[@type='away']"], self.gid)
+    self.rosters << away_roster
+    home_roster = Roster.new
+    home_roster.init(@xml_doc.root.elements["team[@type='home']"], self.gid)
+    @rosters << home_roster
+  end
+  
+  
+  def set_umpires()
+    @umpires['home'] = @xml_doc.root.elements["umpires/umpire[@position='home']"].attributes["name"]
+    @umpires['first'] = @xml_doc.root.elements["umpires/umpire[@position='first']"].attributes["name"]
+    @umpires['second'] = @xml_doc.root.elements["umpires/umpire[@position='second']"].attributes["name"]
+    @umpires['third'] = @xml_doc.root.elements["umpires/umpire[@position='third']"].attributes["name"]
+  end
+  
+  
+end

data/lib/roster.rb

@@ -0,0 +1,61 @@
+require 'player'
+require 'coach'
+
+
+# This class represents a team's roster for a single game.
+# Both players and coaches can be read from the roster.
+class Roster
+  
+  attr_accessor :gid, :id, :team_name, :type, :players, :coaches
+  # type = home or away
+  
+  def init(element, gid)
+    self.gid = gid
+    self.team_name = element.attributes['name']
+    self.id = element.attributes['id']
+    self.type = element.attributes['type']
+    self.players = []
+    self.coaches = []
+    self.set_players(element)
+    self.set_coaches(element)
+  end
+  
+  
+  def find_player_by_last_name(last_name)
+    players.each do |player|
+      if player.last == last_name
+        return player
+      end
+    end
+    nil
+  end
+  
+  
+  def find_player_by_id(pid)
+    players.each do |player|
+      if player.pid == pid
+        return player
+      end
+    end
+    nil
+  end
+  
+  
+  def set_players(element)
+    element.elements.each("player") { |element|
+      player = Player.new
+      player.init(element, gid)
+      @players << player
+    }
+  end
+  
+  
+  def set_coaches(element)
+    element.elements.each("coach") { |element|
+      coach = Coach.new
+      coach.init(element)
+      self.coaches << coach
+    }
+  end
+  
+end

data/lib/schedule.rb

@@ -0,0 +1,53 @@
+require 'schedule_game'
+
+
+
+# This class is used to retrieve season schedule information and to query
+# for information related to the schedule.
+class Schedule
+  
+  attr_accessor :games
+  
+  
+  # Loads a single season schedule from a schedule text file
+  def initialize(year)
+    @games = []
+    read_file(get_sked_filename(year))
+  end
+  
+  
+  # Returns the date of opening day as a string with the format YYYYMMDD
+  def get_opening_day
+    games[0].date
+  end
+  
+  
+  # Returns an integer representing the number of games in the season specified
+  def get_season_length
+    games[games.size-1].home_game_number.to_i
+  end
+  
+  
+
+  def get_sked_filename(year)
+    #'schedules/' + year.to_s + 'SKED.TXT'
+    File.expand_path(File.dirname(__FILE__) + '/schedules/' + year.to_s + 'SKED.TXT')
+  end
+  
+  
+  # Reads the data from a schedule file
+  # Each line in the schedule file represents a single game.
+  # here is a sample of what a single line in the file looks like:
+  #    "20090405","0","Sun","ATL","NL",1,"PHI","NL",1,"n","",""
+  #  this is interpreted as:
+  #     date, 0, day, visiting team, visiting league, visiting game number, home team, home league, home game number, day or night (d or n), "", ""
+  def read_file(filename)
+    contents = ''
+    File.open(filename, "r") do |infile|
+      while (line = infile.gets)
+        @games << ScheduleGame.new(line)
+      end
+    end
+  end
+
+end

data/lib/schedule_game.rb

@@ -0,0 +1,24 @@
+
+# This class represents a single game from a game schedule
+# This class is used in conjunction with the Schedule class.
+# This is not the class you would use to retrieve game statistics.
+class ScheduleGame
+  
+  attr_accessor :date, :day_of_week, :away_team_abbrev, :away_league, :away_game_number
+  attr_accessor :home_team_abbrev, :home_league, :home_game_number, :day_or_night
+  
+  
+  def initialize(line)
+    temp = line.split(',')
+    @date = temp[0].tr_s('"', '').strip
+    @day_of_week = temp[2].tr_s('"', '').strip
+    @away_team_abbrev = temp[3].tr_s('"', '').strip
+    @away_league = temp[4].tr_s('"', '').strip
+    @away_game_number = temp[5].tr_s('"', '').strip
+    @home_team_abbrev = temp[6].tr_s('"', '').strip
+    @home_league = temp[7].tr_s('"', '').strip
+    @home_game_number = temp[8].tr_s('"', '').strip
+    @day_or_night = temp[9].tr_s('"', '').strip
+  end
+  
+end

data/lib/scoreboard.rb

@@ -0,0 +1,23 @@
+require 'gameday_fetcher'
+
+class Scoreboard
+  
+  attr_accessor :games  # An array of Game objects representing all of the games played on this date
+  attr_accessor :year, :month, :day
+  
+  def load_for_date(year, month, day)
+    @games = []
+    @year = year
+    @month = month
+    @day = day
+    @xml_data = GamedayFetcher.fetch_scoreboard(year, month, day)
+    @xml_doc = REXML::Document.new(@xml_data)
+    
+    @xml_doc.elements.each("games/game") { |element|
+      game = Game.new(element.attributes['gameday'])
+      game.load_from_scoreboard(element)
+      @games << game
+    }
+  end
+  
+end