gameday_api 0.5.0 → 0.5.1

data/lib/at_bat.rb

@@ -0,0 +1,40 @@
+require 'pitch'
+
+
+# This class represents a single atbat during a single game
+class AtBat
+  
+  attr_accessor :gid, :inning, :away_team, :home_team
+  attr_accessor :num, :b, :s, :o, :batter_id, :stand, :b_height, :pitcher_id, :p_throws, :des, :event
+  attr_accessor :pitches
+  
+  def init(element, gid, inning)
+    @inning = inning
+    @xml_doc = element
+  	@gid = gid
+  	@num = element.attributes["num"]
+  	@b = element.attributes["b"]
+  	@s = element.attributes["s"]
+  	@o = element.attributes["o"]
+  	@batter_id = element.attributes["batter"]
+  	@stand = element.attributes["stand"]
+  	@b_height = element.attributes["b_height"]
+  	@pitcher_id = element.attributes["pitcher"]
+  	@p_throws = element.attributes["p_throws"]
+  	@des = element.attributes["des"]
+  	@event = element.attributes["event"] 	
+  	set_pitches(element)
+  end
+  
+  
+  def set_pitches(element)
+  	@pitches = []
+    element.elements.each("pitch") do |element| 
+    	pitch = Pitch.new
+    	pitch.init(element)
+    	@pitches << pitch
+    end
+  end
+  
+  
+end

data/lib/batter.rb

@@ -0,0 +1,101 @@
+require 'player'
+
+# This class represents a single batter whom appeared in an MLB game
+class Batter < Player
+    
+  # attributes read from the batters/(pid).xml file
+  attr_accessor :team_abbrev, :pid, :pos, :first_name, :last_name, :jersey_number
+  attr_accessor :height, :weight, :bats, :throws, :dob
+  attr_accessor :season_stats, :career_stats, :month_stats, :empty_stats
+  attr_accessor :men_on_stats, :risp_stats, :loaded_stats, :vs_lhp_stats, :vs_rhp_stats
+  
+  
+  def load_from_id(gid, pid)
+    @gid = gid
+    @pid = pid
+    @xml_data = GamedayFetcher.fetch_batter(gid, pid)
+    @xml_doc = REXML::Document.new(@xml_data)
+    @team_abbrev = @xml_doc.root.attributes["team"]
+    @first_name = @xml_doc.root.attributes["first_name"]
+    @last_name = @xml_doc.root.attributes["last_name"]
+    @jersey_number = @xml_doc.root.attributes["jersey_number"]
+    @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']
+    set_batting_stats
+  end
+  
+  
+  # Returns an array of all the appearances (Batting) made by this player
+  # for the season specified, in which the player had more than 1 hit.
+  def get_multihit_appearances(year)
+    appearances = get_all_appearances(year)
+    mh_appearances = []
+    # now go through all appearances to find those for this player
+    appearances.each do |appearance|
+      if appearance.h.to_i > 1 #add only multihit games
+       mh_appearances << appearance
+      end
+    end
+    mh_appearances
+  end
+  
+  
+  # Returns an array of batter ids for the game specified
+  # batters are found by looking in the gid/batters directory on gameday
+  def self.get_all_ids_for_game(gid)
+    batters_page = GamedayFetcher.fetch_batters_page(gid)
+    results = []
+    if batters_page
+      doc = Hpricot(batters_page)
+      a = doc.at('ul')  
+      if a
+        (a/"a").each do |link|
+          # look at each link inside of a ul tag
+          if link.inner_html.include?(".xml") == true
+            # if the link contains the text '.xml' then it is a batter
+            str = link.inner_html
+            str.strip!
+            batter_id = str[0..str.length-5]
+            results << batter_id
+          end
+        end
+      end
+    end
+    results
+  end
+  
+  
+  private
+  
+  def set_batting_stats
+    @season_stats = BattingStats.new(@xml_doc.root.elements["season"])
+    @career_stats = BattingStats.new(@xml_doc.root.elements["career"])
+    @month_stats = BattingStats.new(@xml_doc.root.elements["month"])
+    @empty_stats = BattingStats.new(@xml_doc.root.elements["Empty"])
+    @men_on_stats = BattingStats.new(@xml_doc.root.elements["Men_On"])
+    @risp_stats = BattingStats.new(@xml_doc.root.elements["RISP"])
+    @loaded_stats = BattingStats.new(@xml_doc.root.elements["Loaded"])
+    @vs_lhp_stats = BattingStats.new(@xml_doc.root.elements["vs_LHP"])
+    @vs_rhp_stats = BattingStats.new(@xml_doc.root.elements["vs_RHP"])
+  end
+  
+end
+
+
+class BattingStats
+  attr_accessor :des, :avg, :ab, :hr, :bb, :so
+  
+  def initialize(element)
+    if element.attributes['des']
+      @des = element.attributes['des']
+    end
+    @avg = element.attributes['avg']
+    @ab = element.attributes['ab']
+    @hr = element.attributes['hr']
+    @bb = element.attributes['bb']
+    @so = element.attributes['so']
+  end
+end

data/lib/batting_appearance.rb

@@ -0,0 +1,55 @@
+require 'player'
+
+
+# This class represents a batting record for a single player for a single game
+# Note that this does NOT represent a single atbat of a player, but rather an appearance is a player's stats over an entire game.
+class BattingAppearance
+  
+  attr_accessor :pid, :batter_name, :pos, :bo, :ab, :po, :r, :bb, :a, :t, :sf, :h, :e, :d, :hbp, :so, :hr, :rbi, :lob, :sb, :avg, :fldg
+  attr_accessor :player, :atbats
+
+  # Used to initialize from box score data
+  def init(element)
+      self.pid = element.attributes['id']
+      self.batter_name = element.attributes['name']
+      self.pos = element.attributes['pos']
+      self.bo = element.attributes['bo']
+      self.ab = element.attributes['ab']
+      self.po = element.attributes['po']
+      self.r = element.attributes['r']
+      self.bb = element.attributes['bb']
+      self.a = element.attributes['a']
+      self.t = element.attributes['t']
+      self.sf = element.attributes['sf']
+      self.h = element.attributes['h']
+      self.e = element.attributes['e']
+      self.d = element.attributes['d']
+      self.hbp = element.attributes['hbp']
+      self.so = element.attributes['so']
+      self.hr = element.attributes['hr']
+      self.rbi = element.attributes['rbi']
+      self.lob = element.attributes['lob']
+      self.sb = element.attributes['sb']
+      self.avg = element.attributes['avg']  # season avg
+      self.fldg = element.attributes['fldg']
+    end
+    
+    
+  # Looks up the player record using the players.xml file for the player in this appearance
+  def get_player
+    if !self.player
+      # retrieve player object
+      player = Player.new
+      player.init()
+      self.player = player
+    end
+    self.player
+  end
+  
+  
+  # get the atbats associated with this appearance
+  def get_atbats
+    
+  end
+  
+end

data/lib/box_score.rb

@@ -0,0 +1,197 @@
+require 'team'
+require 'pitching_appearance'
+require 'batting_appearance'
+require 'gameday_fetcher'
+require 'line_score'
+require 'hpricot'
+require 'rexml/document'
+require 'gameday_util'
+
+
+# Parses the MLB Gameday XML representation of a boxscore and returns data in easy to use
+# arrays and hashes.  Can be used along with a view template to easily create a displayable
+# box score.
+class BoxScore
+  
+  attr_accessor :xml_data, :gid, :game, :linescore, :game_info, :home_batting_text, :away_batting_text
+  
+  attr_accessor :game_id, :game_pk, :home_sport_code, :away_team_code, :home_team_code
+  attr_accessor :away_id, :home_id, :away_fname, :home_fname, :away_sname, :home_sname
+  attr_accessor :date, :away_wins, :away_loss, :home_wins, :home_loss, :status_ind
+  
+  attr_accessor :home_runs, :away_runs
+  
+  attr_accessor :temp, :wind_speed, :wind_dir
+  
+  # complex attributes
+  attr_accessor :innings, :cities, :linescore_totals, :pitchers, :batters
+  
+  
+  # Loads the boxscore XML from the MLB gameday server and parses it using REXML
+  def load_from_id(gid)
+    @gid = gid
+    @xml_data = GamedayFetcher.fetch_boxscore(gid)
+    @xml_doc = REXML::Document.new(@xml_data)
+    if @xml_doc.root
+      @game = Game.new(@gid)
+      @game.boxscore = self
+      set_basic_info
+      @linescore = LineScore.new
+      @linescore.init(@xml_doc.root.elements["linescore"])
+      @home_runs = @linescore.home_team_runs
+      @away_runs = @linescore.away_team_runs
+      @game_info = @xml_doc.root.elements["game_info"].text
+	    set_batting_text
+      set_cities
+      set_pitchers
+      set_batters
+      set_weather
+    end
+  end
+  
+  
+  # Saves an HTML version of the boxscore
+  def dump_to_file
+    GamedayUtil.save_file("boxscore.html", to_html('boxscore.html.erb'))
+  end
+  
+  
+  # Converts the boxscore into a formatted HTML representation.
+  # Relies on the boxscore.html.erb template for describing the layout
+  def to_html(template_filename)
+    gameday_info = GamedayUtil.parse_gameday_id('gid_' + gid)
+    template = ERB.new File.new(File.expand_path(File.dirname(__FILE__) + "/" + template_filename)).read, nil, "%"  
+    return template.result(binding)
+  end
+  
+  
+  # Returns a 2 element array of leadoff hitters for this game.
+  #     [0] = visitor's leadoff hitter
+  #     [1] = home's leadoff hitter
+  def get_leadoff_hitters
+    find_hitters("batter")
+  end
+  
+  
+  # Returns a 2 element array of cleanup hitters for this game.
+  #     [0] = visitor's cleanup hitter
+  #     [1] = home's cleanup hitter
+  def get_cleanup_hitters
+    find_hitters("batter[@bo='400']")
+  end
+  
+  
+  def find_hitters(search_string)
+    results = []
+    away = @xml_doc.elements["boxscore/batting[@team_flag='away']/#{search_string}"]
+    away_batter = BattingAppearance.new
+    away_batter.init(away)
+    results << away_batter
+    home = @xml_doc.elements["boxscore/batting[@team_flag='home']/#{search_string}"]
+    home_batter = BattingAppearance.new
+    home_batter.init(home)
+    results << home_batter
+    results
+  end
+  
+  
+  private
+  
+  # Retrieves basic game data from the XML root element and sets in object
+  def set_basic_info
+    @game_id = @xml_doc.root.attributes["game_id"]
+    @game_pk = @xml_doc.root.attributes["game_pk"]
+    @home_sport_code = @xml_doc.root.attributes["home_sport_code"]
+    @away_team_code = @xml_doc.root.attributes["away_team_code"]
+    @home_team_code = @xml_doc.root.attributes["home_team_code"]
+    @away_id = @xml_doc.root.attributes["away_id"]
+    @home_id = @xml_doc.root.attributes["home_id"]
+    @away_fname = @xml_doc.root.attributes["away_fname"]
+    @home_fname = @xml_doc.root.attributes["home_fname"]
+    @away_sname = @xml_doc.root.attributes["away_sname"]
+    @home_sname = @xml_doc.root.attributes["home_sname"]
+    @date = @xml_doc.root.attributes["date"]
+    @away_wins = @xml_doc.root.attributes["away_wins"]
+    @away_loss = @xml_doc.root.attributes["away_loss"]
+    @home_wins = @xml_doc.root.attributes["home_wins"]
+    @home_loss = @xml_doc.root.attributes["home_loss"]
+    @status_ind = @xml_doc.root.attributes["status_ind"]
+  end
+  
+  
+  def set_batting_text
+    if @xml_doc.root.elements["batting[@team_flag='home']/text_data"]
+      @home_batting_text = @xml_doc.root.elements["batting[@team_flag='home']/text_data"].text
+    end
+    if @xml_doc.root.elements["batting[@team_flag='away']/text_data"]
+      @away_batting_text = @xml_doc.root.elements["batting[@team_flag='away']/text_data"].text
+    end
+  end
+  
+  
+  # Sets an array of the city names for the teams playing the game
+  #    [0] = away
+  #    [1] = home
+  def set_cities
+    @cities = []
+    if @xml_doc.root
+      @cities.push @xml_doc.root.attributes["away_sname"]
+      @cities.push @xml_doc.root.attributes["home_sname"]
+    else
+      @cities.push 'unknown'
+      @cities.push 'unknown'
+    end
+  end
+  
+  
+  # Sets an array of hashes where each hash holds data for a pitcher whom appeared
+  # in the game.  Specify either home or away team pitchers.
+  def set_pitchers
+    @pitchers, away_pitchers, home_pitchers = [], [], []
+    count = 1
+    @xml_doc.elements.each("boxscore/pitching[@team_flag='away']/pitcher") { |element| 
+      pitcher = PitchingAppearance.new
+      pitcher.init(@gid, element, count)
+      count += 1
+      away_pitchers.push pitcher
+    }   
+    count = 1
+    @xml_doc.elements.each("boxscore/pitching[@team_flag='home']/pitcher") { |element| 
+      pitcher = PitchingAppearance.new
+      pitcher.init(@gid, element, count)
+      count += 1
+      home_pitchers.push pitcher
+    }   
+    @pitchers << away_pitchers
+    @pitchers << home_pitchers
+  end
+  
+  
+  # Sets an array of hashes where each hash holds data for a batter whom appeared
+  # in the game.  Specify either home or away team batters.
+  def set_batters
+    @batters, away_batters, home_batters = [], [], []
+    @xml_doc.elements.each("boxscore/batting[@team_flag='away']/batter") { |element| 
+      batter = BattingAppearance.new
+      batter.init(element)
+      away_batters.push batter
+    }
+    @xml_doc.elements.each("boxscore/batting[@team_flag='home']/batter") { |element| 
+      batter = BattingAppearance.new
+      batter.init(element)
+      home_batters.push batter
+    }
+    @batters << away_batters
+    @batters << home_batters
+  end
+  
+  
+  def set_weather
+    @game_info =~ /<br\/><b>Weather<\/b>: (\d+) degrees,.*<br\/><b>Wind<\/b>: (\d+) mph, ([\w\s]+).<br\/>/
+    @temp = $1
+    @wind_speed = $2
+    @wind_dir = $3
+  end
+  
+  
+end

data/lib/cache_fetcher.rb

@@ -0,0 +1,31 @@
+require 'net/http'
+require 'md5'
+
+class CacheFetcher
+  
+   def initialize(cache_dir=File.expand_path(File.dirname(__FILE__)) + '/tmp')
+      # this is the dir where we store our cache
+      @cache_dir = cache_dir
+   end
+   
+   
+    def fetch(url)
+      file = MD5.hexdigest(url)
+      file_path = File.join("", @cache_dir, file)
+      # we check if the file -- a MD5 hexdigest of the URL -- exists
+      #  in the dir. If it does we just read data from the file and return
+      if !File.exists? file_path
+        #puts 'Not found in cache'
+        # if the file does not exist (or if the data is not fresh), we
+        #  make an HTTP request and save it to a file
+        #puts 'Fetching file from internet...'
+        File.open(file_path, "w") do |data|
+           data << Net::HTTP.get_response(URI.parse(url)).body
+        end
+      else
+        #puts 'Using cache'
+      end
+      return File.new(file_path)
+   end
+   
+end

data/lib/coach.rb

@@ -0,0 +1,16 @@
+# This class represents a single MLB coach
+class Coach
+  
+  attr_accessor :position, :first, :last, :id, :num
+  
+  
+  def init(element)
+      self.id = element.attributes['id']
+      self.first = element.attributes['first']
+      self.last = element.attributes['last']
+      self.num= element.attributes['num']
+      self.position = element.attributes['position']
+  end
+  
+end
+

data/lib/data_downloader.rb

@@ -0,0 +1,231 @@
+require 'game'
+require 'batter'
+require 'pitcher'
+require 'fileutils'
+
+
+
+# This class is used to download data files from the MLB Gameday site to
+# local storage.  The data that is downloaded will be stored into a path that
+# replicates the MLB Gameday paths, for example here is a sample path for
+# a specified date:
+#   /components/game/mlb/year_2008/month_04/day_07
+#
+class DataDownloader
+  
+  FILE_BASE_PATH = 'components/game/mlb'
+  
+    
+  # Downloads all data files associated with the game specified by the game id passed in.
+  def download_all_for_game(gid)
+    download_xml_for_game(gid)
+    download_batters_for_game(gid)
+    download_inning_for_game(gid)
+    download_media_for_game(gid)
+    download_notification_for_game(gid)
+    download_onbase_for_game(gid)
+    download_pitchers_for_game(gid)
+  end
+  
+  
+  def download_batters_for_game(gid)
+    write_file(get_gid_path(gid) + "/batters.html", GamedayFetcher.fetch_batters_page(gid))
+    batter_path = get_gid_path(gid) + "/batters"
+    ids = Batter.get_all_ids_for_game(gid)
+    ids.each do |id|
+      if !File.exists? "#{batter_path}/#{id}.xml"
+        write_file("#{batter_path}/#{id}.xml", GamedayFetcher.fetch_batter(gid, id)) 
+      end
+    end
+  end
+  
+  
+  def download_pitchers_for_game(gid)
+    write_file(get_gid_path(gid) + "/pitchers.html", GamedayFetcher.fetch_pitchers_page(gid))
+    pitcher_path = get_gid_path(gid) + "/pitchers"
+    ids = Pitcher.get_all_ids_for_game(gid)
+    ids.each do |id|
+      if !File.exists? "#{pitcher_path}/#{id}.xml" 
+        write_file("#{pitcher_path}/#{id}.xml", GamedayFetcher.fetch_pitcher(gid, id)) 
+      end
+    end
+  end
+  
+  
+  def download_inning_for_game(gid)
+    game = Game.new(gid)
+    inn_count = game.get_num_innings
+    inn_path = get_gid_path(gid) + "/inning"
+    (1..inn_count).each do |inn|
+      if !File.exists? "#{inn_path}/inning_#{inn}.xml"
+        write_file("#{inn_path}/inning_#{inn}.xml", GamedayFetcher.fetch_inningx(gid, inn)) 
+      end  
+    end 
+    if !File.exists? "#{inn_path}/inning_Scores.xml"
+      write_file("#{inn_path}/inning_Scores.xml", GamedayFetcher.fetch_inning_scores(gid))
+    end
+    if !File.exists? "#{inn_path}/inning_hit.xml"
+      write_file("#{inn_path}/inning_hit.xml", GamedayFetcher.fetch_inning_hit(gid)) 
+    end
+  end
+  
+  
+  def download_media_for_game(gid)
+    media_path = get_gid_path(gid) + "/media"
+    if !File.exists? "#{media_path}/highlights.xml"
+      write_file("#{media_path}/highlights.xml", GamedayFetcher.fetch_media_highlights(gid))  
+    end
+    if !File.exists? "#{media_path}/mobile.xml"  
+      write_file("#{media_path}/mobile.xml", GamedayFetcher.fetch_media_mobile(gid))  
+    end  
+  end
+  
+  
+  def download_notification_for_game(gid)
+    game = Game.new(gid)
+    inn_count = game.get_num_innings
+    notif_path = get_gid_path(gid) + "/notifications"
+    (1..inn_count).each do |inn|
+      if !File.exists? "#{notif_path}/notifications_#{inn}.xml" 
+        write_file("#{notif_path}/notifications_#{inn}.xml", GamedayFetcher.fetch_notifications_inning(gid, inn)) 
+      end
+    end   
+    if !File.exists? "#{notif_path}/notifications_full.xml"
+      write_file("#{notif_path}/notifications_full.xml", GamedayFetcher.fetch_notifications_full(gid))
+    end
+  end
+  
+  
+  def download_onbase_for_game(gid)
+    onbase_path = get_gid_path(gid) + "/onbase"
+    write_file("#{onbase_path}/linescore.xml", GamedayFetcher.fetch_onbase_linescore(gid))    
+    write_file("#{onbase_path}/plays.xml", GamedayFetcher.fetch_onbase_plays(gid))  
+  end
+  
+  
+  # Downloads the top-level xml directories for the game specified by the passed in game id.
+  # The files include:
+  #    bench.xml
+  #    benchO.xml
+  #    boxscore.xml
+  #    emailSource.xml
+  #    eventLog.xml
+  #    game.xml
+  #    game_events.xml
+  #    gamecenter.xml
+  #    gameday_Syn.xml
+  #    linescore.xml
+  #    miniscoreboard.xml
+  #    players.xml
+  #    plays.xml
+  def download_xml_for_game(gid)
+    gid_path = get_gid_path(gid)
+    write_file("#{gid_path}/bench.xml", GamedayFetcher.fetch_bench(gid))    
+    write_file("#{gid_path}/benchO.xml", GamedayFetcher.fetch_bencho(gid))
+    write_file("#{gid_path}/boxscore.xml", GamedayFetcher.fetch_boxscore(gid))
+    write_file("#{gid_path}/emailSource.xml", GamedayFetcher.fetch_emailsource(gid))
+    write_file("#{gid_path}/eventLog.xml", GamedayFetcher.fetch_eventlog(gid))
+    write_file("#{gid_path}/game.xml", GamedayFetcher.fetch_game_xml(gid))
+    write_file("#{gid_path}/game_events.xml", GamedayFetcher.fetch_game_events(gid))
+    write_file("#{gid_path}/gamecenter.xml", GamedayFetcher.fetch_gamecenter_xml(gid))
+    write_file("#{gid_path}/gameday_Syn.xml", GamedayFetcher.fetch_gamedaysyn(gid))
+    write_file("#{gid_path}/linescore.xml", GamedayFetcher.fetch_linescore(gid))
+    write_file("#{gid_path}/miniscoreboard.xml", GamedayFetcher.fetch_miniscoreboard(gid))
+    write_file("#{gid_path}/players.xml", GamedayFetcher.fetch_players(gid))
+    write_file("#{gid_path}/plays.xml", GamedayFetcher.fetch_plays(gid))
+  end
+  
+  
+  def download_xml_for_date(year, month, day)
+    day_path = get_day_path(year, month, day)
+    write_file("#{day_path}/epg.xml", GamedayFetcher.fetch_epg(year, month, day))
+    write_file("#{day_path}/master_scoreboard.xml", GamedayFetcher.fetch_scoreboard(year, month, day))
+    write_file("#{day_path}/media/highlights.xml", GamedayFetcher.fetch_day_highlights(year, month, day))
+  end
+  
+  
+  def download_all_for_date(year, month, day)
+    day_path = get_day_path(year, month, day)
+    write_file("#{day_path}/games.html", GamedayFetcher.fetch_games_page(year, month, day))
+    download_xml_for_date(year, month, day)
+    games = Game.find_by_date(year, month, day)
+    games.each do |game|
+      download_all_for_game(game.gid)
+    end
+  end
+  
+  
+  def download_all_for_month(year, month)   
+    start_date = Date.new(year.to_i, month.to_i) # first day of month
+    end_date = (start_date >> 1)-1 # last day of month
+    ((start_date)..(end_date)).each do |dt| 
+      puts 'Downloading ' + year.to_s + '/' + month.to_s + '/' + dt.day.to_s
+      download_all_for_date(year, month, dt.day.to_s)
+    end
+  end
+  
+  
+  def download_all_for_range(year, start_month, start_day, end_month, end_day)
+    start_date = Date.new(year.to_i, start_month.to_i, start_day.to_i) 
+    end_date = Date.new(year.to_i, end_month.to_i, end_day.to_i) 
+    ((start_date)..(end_date)).each do |dt| 
+      puts 'Downloading ' + dt.year.to_s + '/' + dt.month.to_s + '/' + dt.day.to_s
+      download_all_for_date(dt.year.to_s, dt.month.to_s, dt.day.to_s)
+    end
+  end
+  
+  
+  def tmp_fetch_pages_for_month(year, month, end_day)
+    start_date = Date.new(year.to_i, month.to_i) # first day of month
+    if end_day
+      end_date = Date.new(year.to_i, month.to_i, end_day.to_i)
+    else
+      end_date = (start_date >> 1)-1 # last day of month
+    end
+    ((start_date)..(end_date)).each do |dt| 
+      day = dt.day.to_s
+      puts day
+      day_path = get_day_path(year, month, day)
+      write_file("#{day_path}/games.html", GamedayFetcher.fetch_games_page(year, month, day))
+      games = Game.find_by_date(year, month, day)
+      games.each do |game|
+        tmp_fetch_pages_for_game(game.gid)
+      end
+    end
+  end
+  
+  def tmp_fetch_pages_for_game(gid)
+    write_file(get_gid_path(gid) + "/batters.html", GamedayFetcher.fetch_batters_page(gid))
+    write_file(get_gid_path(gid) + "/pitchers.html", GamedayFetcher.fetch_pitchers_page(gid))
+  end
+  
+  
+  private
+  
+  
+  def get_day_path(year, month, day)
+    year = GamedayUtil.convert_digit_to_string(year.to_i)
+    month = GamedayUtil.convert_digit_to_string(month.to_i)
+    day = GamedayUtil.convert_digit_to_string(day.to_i)
+    "#{FILE_BASE_PATH}/year_" + year + "/month_" + month + "/day_" + day  
+  end
+  
+  
+  def get_gid_path(gid)
+    gameday_info = GamedayUtil.parse_gameday_id('gid_' + gid)
+    "#{FILE_BASE_PATH}/year_" + gameday_info['year'] + "/month_" + gameday_info['month'] + "/day_" + gameday_info['day'] + "/gid_"+gid 
+  end
+  
+  
+  # Writes the gameday data to the file specified.  
+  # Does not overwrite existing files.
+  def write_file(file_path, gd_data)
+    if gd_data && !File.exists?(file_path)
+      FileUtils.mkdir_p(File.dirname(file_path))
+      File.open(file_path, "w") do |data|
+        data << gd_data
+      end
+    end
+  end
+  
+end