Class: SportDb::GameReader

Inherits:

Object

• Object
• SportDb::GameReader

Includes:

LogUtils::Logging, FixtureHelpers, Model, TextUtils::ValueHelper

Defined in:

lib/sportdb/readers/game.rb

Constant Summary

Constants included from Model

Model::City, Model::Continent, Model::Country, Model::Prop, Model::Region

Instance Attribute Summary

• #include_path ⇒ Object readonly

  Returns the value of attribute include_path.

Instance Method Summary

• #initialize(include_path, opts = {}) ⇒ GameReader constructor

  A new instance of GameReader.

• #load_fixtures_worker(event_key, reader) ⇒ Object
• #parse_date_header(line) ⇒ Object
• #parse_fixtures(reader) ⇒ Object
• #parse_game(line) ⇒ Object
• #parse_group_def(line) ⇒ Object
• #parse_group_header(line) ⇒ Object
• #parse_round_def(line) ⇒ Object
• #parse_round_header(line) ⇒ Object
• #read(name, more_attribs = {}) ⇒ Object
• #read_fixtures(event_key, name) ⇒ Object

  load from file system.

• #read_fixtures_from_string(event_key, text) ⇒ Object

  load from string (e.g. passed in via web form).

• #try_parse_date_header(line) ⇒ Object
• #try_parse_game(line) ⇒ Object

Methods included from FixtureHelpers

#calculate_year, #cut_off_end_of_line_comment!, #find_date!, #find_game_pos!, #find_ground!, #find_group_title_and_pos!, #find_leading_pos!, #find_person!, #find_record_comment!, #find_record_laps!, #find_record_leading_state!, #find_record_timeline!, #find_round_def_title!, #find_round_header_title!, #find_round_header_title2!, #find_round_pos!, #find_scores!, #find_team!, #find_team1!, #find_team2!, #find_teams!, #find_track!, #is_group?, #is_group_def?, #is_knockout_round?, #is_postponed?, #is_round?, #is_round_def?, #map_ground!, #map_person!, #map_team!, #map_teams!, #map_track!, #match_teams!, #match_track!

Constructor Details

#initialize(include_path, opts = {}) ⇒ GameReader

Returns a new instance of GameReader.

# File 'lib/sportdb/readers/game.rb', line 23

def initialize( include_path, opts = {} )
  @include_path = include_path
end

Instance Attribute Details

#include_path ⇒ Object (readonly)

Returns the value of attribute include_path.

# File 'lib/sportdb/readers/game.rb', line 20

def include_path
  @include_path
end

Instance Method Details

#load_fixtures_worker(event_key, reader) ⇒ Object

# File 'lib/sportdb/readers/game.rb', line 83

def load_fixtures_worker( event_key, reader )
  ## NB: assume active activerecord connection

  ## reset cached values
  @patch_rounds  = {}
  @round         = nil     ## fix: change/rename to @last_round !!!
  @group         = nil     ## fix: change/rename to @last_group !!!
  @last_date     = nil


  @event = Event.find_by_key!( event_key )
  
  logger.debug "Event #{@event.key} >#{@event.title}<"

  ### fix: use build_title_table_for ??? why? why not??
  @known_teams  = @event.known_teams_table

  @known_grounds  = TextUtils.build_title_table_for( @event.grounds )


  parse_fixtures( reader )
  
end

#parse_date_header(line) ⇒ Object

# File 'lib/sportdb/readers/game.rb', line 427

def parse_date_header( line )
  # note: returns true if parsed, false if no match
 
  # line with NO teams  plus include date e.g.
  #   [Fri Jun/17]  or
  #   Jun/17  or
  #   Jun/17:   etc.


  match_teams!( line )
  team1_key = find_team1!( line )
  team2_key = find_team2!( line )

  date  = find_date!( line, start_at: @event.start_at )

  if date && team1_key.nil? && team2_key.nil?
    logger.debug( "date header line found: >#{line}<")
    logger.debug( "    date: #{date}")
    
    @last_date = date   # keep a reference for later use
    return true
  else
    return false
  end
end

#parse_fixtures(reader) ⇒ Object

# File 'lib/sportdb/readers/game.rb', line 455

def parse_fixtures( reader )
    
  reader.each_line do |line|

    if is_round_def?( line ) 
      ## todo/fix:  add round definition (w begin n end date)
      ## todo: do not patch rounds with definition (already assume begin/end date is good)
      ##  -- how to deal with matches that get rescheduled/postponed?
      parse_round_def( line )
    elsif is_round?( line )
      parse_round_header( line )
    elsif is_group_def?( line ) ## NB: group goes after round (round may contain group marker too)
      ### todo: add pipe (|) marker (required)
      parse_group_def( line )
    elsif is_group?( line )
      ##  -- lets you set group  e.g. Group A etc.
      parse_group_header( line )
    elsif try_parse_game( line )
      # do nothing here
    elsif try_parse_date_header( line )
      # do nothing here
    else
      logger.info "skipping line (no match found): >#{line}<"
    end
  end # lines.each


###
#  fix: do NOT patch if auto flag is set to false !!!
#   e.g. rounds got added w/ round def (not w/ round header)

  @patch_rounds.each do |k,v|
    logger.debug "patch start_at/end_at date for round #{k}:"
    round = Round.find( k )
    games = round.games.order( 'play_at asc' ).all
    
    ## skip rounds w/ no games
    
    ## todo/fix: what's the best way for checking assoc w/ 0 recs?
    next if games.size == 0
  
    round_attribs = {}
    
    ## todo: check for no records
    ##  e.g. if game[0].present? or just if game[0]  ??
    
    round_attribs[:start_at] = games[0].play_at
    round_attribs[:end_at  ] = games[-1].play_at

    logger.debug round_attribs.to_json
    round.update_attributes!( round_attribs )
  end
  
end

#parse_game(line) ⇒ Object

# File 'lib/sportdb/readers/game.rb', line 288

def parse_game( line )
  logger.debug "parsing game (fixture) line: >#{line}<"

  match_teams!( line )
  team1_key = find_team1!( line )
  team2_key = find_team2!( line )

  ## note: if we do NOT find two teams; return false - no match found
  if team1_key.nil? || team2_key.nil?
    logger.debug "  no game match (two teams required) found for line: >#{line}<"
    return false
  end

  pos = find_game_pos!( line )

  if is_postponed?( line )
    postponed  = true
    date_v2    = find_date!( line, start_at: @event.start_at )
    date       = find_date!( line, start_at: @event.start_at )
  else
    postponed = false
    date_v2   = nil
    date      = find_date!( line, start_at: @event.start_at )
  end

  ###
  # check if date found?
  #   NB: ruby falsey is nil & false only (not 0 or empty array etc.)
  if date
    ### check: use date_v2 if present? why? why not?
    @last_date = date    # keep a reference for later use
  else
    date = @last_date    # no date found; (re)use last seen date
  end


  scores = find_scores!( line )


  map_ground!( line )
  ground_key = find_ground!( line )
  ground =   ground_key.nil? ? nil : Ground.find_by_key!( ground_key )


  logger.debug "  line: >#{line}<"


  ### todo: cache team lookups in hash?

  team1 = Team.find_by_key!( team1_key )
  team2 = Team.find_by_key!( team2_key )


  if @round.nil?
    ## no round header found; calculate round from date
    
    ###
    ## todo/fix: add some unit tests for round look up
    #  fix: use date_v2 if present!! (old/original date; otherwise use date)
    
    #
    # fix: check - what to do with hours e.g. start_at use 00:00 and for end_at use 23.59 ??
    #  -- for now - remove hours (e.g. use end_of_day and beginnig_of_day)
    
    ## pp Round.all
    
    round = Round.where( 'event_id = ? AND (start_at <= ? AND end_at >= ?)',
                           @event.id, date.end_of_day, date.beginning_of_day).first
    ## pp round
    logger.debug( "  using round #{round.pos} >#{round.title}< start_at: #{round.start_at}, end_at: #{round.end_at}" )
  else
    ## use round from last round header
    round = @round
  end
  


  ### check if games exists
  ##  with this teams in this round if yes only update
  game = Game.find_by_round_id_and_team1_id_and_team2_id(
                       round.id, team1.id, team2.id
  )

  game_attribs = {
    score1:    scores[0],
    score2:    scores[1],
    score1et:  scores[2],
    score2et:  scores[3],
    score1p:   scores[4],
    score2p:   scores[5],
    play_at:    date,
    play_at_v2: date_v2,
    postponed: postponed,
    knockout:  round.knockout,   ## note: for now always use knockout flag from round - why? why not?? 
    ground_id: ground.present? ? ground.id : nil,
    group_id:  @group.present? ? @group.id : nil
  }

  game_attribs[ :pos ] = pos   if pos.present?

  ####
  # note: only update if any changes (or create if new record)
  if game.present? &&
     game.check_for_changes( game_attribs ) == false
        logger.debug "  skip update game #{game.id}; no changes found"
  else
    if game.present?
      logger.debug "update game #{game.id}:"
    else
      logger.debug "create game:"
      game = Game.new

      more_game_attribs = {
        round_id: round.id,
        team1_id: team1.id,
        team2_id: team2.id
      }
        
      ## NB: use round.games.count for pos
      ##  lets us add games out of order if later needed
      more_game_attribs[ :pos ] = round.games.count+1   if pos.nil? 

      game_attribs = game_attribs.merge( more_game_attribs )
    end

    logger.debug game_attribs.to_json
    game.update_attributes!( game_attribs )
  end

  return true   # game match found
end

#parse_group_def(line) ⇒ Object

# File 'lib/sportdb/readers/game.rb', line 123

def parse_group_def( line )
  logger.debug "parsing group def line: >#{line}<"
  
  match_teams!( line )
  team_keys = find_teams!( line )
    
  title, pos = find_group_title_and_pos!( line )

  logger.debug "  line: >#{line}<"

  group_attribs = {
    title: title
  }
      
  group = Group.find_by_event_id_and_pos( @event.id, pos )
  if group.present?
    logger.debug "update group #{group.id}:"
  else
    logger.debug "create group:"
    group = Group.new
    group_attribs = group_attribs.merge( {
      event_id: @event.id,
      pos:   pos
    })
  end
    
  logger.debug group_attribs.to_json
 
  group.update_attributes!( group_attribs )

  group.teams.clear  # remove old teams
  ## add new teams
  team_keys.each do |team_key|
    team = Team.find_by_key!( team_key )
    logger.debug "  adding team #{team.title} (#{team.code})"
    group.teams << team
  end
end

#parse_group_header(line) ⇒ Object

# File 'lib/sportdb/readers/game.rb', line 109

def parse_group_header( line )
  logger.debug "parsing group header line: >#{line}<"

  title, pos = find_group_title_and_pos!( line )

  logger.debug "    title: >#{title}<"
  logger.debug "    pos: >#{pos}<"
  logger.debug "  line: >#{line}<"

  # set group for games
  @group = Group.find_by_event_id_and_pos!( @event.id, pos )
end

#parse_round_def(line) ⇒ Object

# File 'lib/sportdb/readers/game.rb', line 163

def parse_round_def( line )
  logger.debug "parsing round def line: >#{line}<"

  ### todo/fix/check:  move cut off optional comment in reader for all lines? why? why not?
  cut_off_end_of_line_comment!( line )  # cut off optional comment starting w/ #

  start_at = find_date!( line, start_at: @event.start_at )
  end_at   = find_date!( line, start_at: @event.start_at )
  
  # note: if end_at missing -- assume start_at is (==) end_at
  end_at = start_at  if end_at.nil?


  pos   = find_round_pos!( line )
  title = find_round_def_title!( line )
  # NB: use extracted round title for knockout check
  knockout_flag = is_knockout_round?( title )


  logger.debug "    start_at: #{start_at}"
  logger.debug "    end_at:   #{end_at}"
  logger.debug "    pos:      #{pos}"
  logger.debug "    title:    >#{title}<"
  logger.debug "    knockout_flag:   #{knockout_flag}"

  logger.debug "  line: >#{line}<"

  #######################################
  # fix: add auto flag is false !!!!

  round_attribs = {
    title:    title,
    knockout: knockout_flag,
    start_at: start_at,
    end_at:   end_at
  }

  round = Round.find_by_event_id_and_pos( @event.id, pos )
  if round.present?
    logger.debug "update round #{round.id}:"
  else
    logger.debug "create round:"
    round = Round.new
        
    round_attribs = round_attribs.merge( {
      event_id: @event.id,
      pos:   pos
    })
  end

  logger.debug round_attribs.to_json
 
  round.update_attributes!( round_attribs )
end

#parse_round_header(line) ⇒ Object

# File 'lib/sportdb/readers/game.rb', line 219

def parse_round_header( line )
  logger.debug "parsing round header line: >#{line}<"

  ### todo/fix/check:  move cut off optional comment in reader for all lines? why? why not?
  cut_off_end_of_line_comment!( line )  # cut off optional comment starting w/ #

  # NB: cut off optional title2 starting w/  //  first
  title2 = find_round_header_title2!( line )

  # todo/fix: check if it is possible title2 w/ group?
  #  add an example here
  group_title, group_pos = find_group_title_and_pos!( line )

  pos = find_round_pos!( line )

  title = find_round_header_title!( line )

  ## NB: use extracted round title for knockout check
  knockout_flag = is_knockout_round?( title )


  if group_pos.present?
    @group = Group.find_by_event_id_and_pos!( @event.id, group_pos )
  else
    @group = nil   # reset group to no group
  end

  logger.debug "  line: >#{line}<"
      
  ## NB: dummy/placeholder start_at, end_at date
  ##  replace/patch after adding all games for round

  round_attribs = {
    title:  title,
    title2: title2,
    knockout: knockout_flag
  }


  @round = Round.find_by_event_id_and_pos( @event.id, pos )
  if @round.present?
    logger.debug "update round #{@round.id}:"
  else
    logger.debug "create round:"
    @round = Round.new
        
    round_attribs = round_attribs.merge( {
      event_id: @event.id,
      pos:   pos,
      start_at: Time.utc('1912-12-12'),
      end_at:   Time.utc('1912-12-12')
    })
  end

  logger.debug round_attribs.to_json
 
  @round.update_attributes!( round_attribs )

  ### store list of round is for patching start_at/end_at at the end
  @patch_rounds[ @round.id ] = @round.id
end

#read(name, more_attribs = {}) ⇒ Object

# File 'lib/sportdb/readers/game.rb', line 28

def read( name, more_attribs={} )
  reader = EventReader.new( @include_path )
  reader.read( name )

  event    = reader.event      ## was fetch_event( name )
  fixtures = reader.fixtures   ## was fetch_event_fixtures( name )

  fixtures.each do |fixture|
    read_fixtures( event.key, fixture )  ## use read_for or read_for_event - why ??? why not?? 
  end
end

#read_fixtures(event_key, name) ⇒ Object

load from file system

# File 'lib/sportdb/readers/game.rb', line 55

def read_fixtures( event_key, name )  # load from file system

  ## todo: move name_real_path code to LineReaderV2 ????
  pos = name.index( '!/')
  if pos.nil?
    name_real_path = name   # not found; real path is the same as name
  else
    # cut off everything until !/ e.g.
    #   at-austria!/w-wien/beers becomes
    #   w-wien/beers
    name_real_path = name[ (pos+2)..-1 ]
  end


  path = "#{include_path}/#{name_real_path}.txt"

  logger.info "parsing data '#{name}' (#{path})..."
  
  SportDb.lang.lang = SportDb.lang.classify_file( path )

  reader = LineReader.new( path )
  
  load_fixtures_worker( event_key, reader )

  Prop.create_from_fixture!( name, path )
end

#read_fixtures_from_string(event_key, text) ⇒ Object

load from string (e.g. passed in via web form)

# File 'lib/sportdb/readers/game.rb', line 41

def read_fixtures_from_string( event_key, text )  # load from string (e.g. passed in via web form)

  SportDb.lang.lang = SportDb.lang.classify( text )

  ## todo/fix: move code into LineReader e.g. use LineReader.fromString() - why? why not?
  reader = StringLineReader.new( text )
  
  read_fixtures_worker( event_key, reader )

  ## fix add prop 
  ### Prop.create!( key: "db.#{fixture_name_to_prop_key(name)}.version", value: "file.txt.#{File.mtime(path).strftime('%Y.%m.%d')}" )  
end

#try_parse_date_header(line) ⇒ Object

# File 'lib/sportdb/readers/game.rb', line 421

def try_parse_date_header( line )
  # note: clone line; for possible test do NOT modify in place for now
  # note: returns true if parsed, false if no match
  parse_date_header( line.dup )
end

#try_parse_game(line) ⇒ Object

# File 'lib/sportdb/readers/game.rb', line 282

def try_parse_game( line )
  # note: clone line; for possible test do NOT modify in place for now
  # note: returns true if parsed, false if no match
  parse_game( line.dup )
end