sportdb-formats 1.0.2 → 1.1.0

data/lib/sportdb/formats/match/mapper_teams.rb

@@ -16,7 +16,7 @@ class TeamMapper
   end
 
   def map_teams!( line )
-    @mapper.map_titles!( line )
+    @mapper.map_names!( line )
   end
 end # class TeamMapper
 

data/lib/sportdb/formats/match/match_parser.rb

@@ -82,15 +82,14 @@ class MatchParser   ## simple match parser for team match schedules
     #    team1 team2 - match  (will get new auto-matchday! not last round)
     @last_round     = nil
 
-    title, pos = find_group_title_and_pos!( line )
+    name = find_group_name!( line )
 
-    logger.debug "    title: >#{title}<"
-    logger.debug "    pos: >#{pos}<"
+    logger.debug "    name: >#{name}<"
     logger.debug "  line: >#{line}<"
 
-    group = @groups[ title ]
+    group = @groups[ name ]
     if group.nil?
-      puts "!! ERROR - no group def found for >#{title}<"
+      puts "!! ERROR - no group def found for >#{name}<"
       exit 1
     end
 
@@ -104,19 +103,19 @@ class MatchParser   ## simple match parser for team match schedules
     @mapper_teams.map_teams!( line )
     teams = @mapper_teams.find_teams!( line )
 
-    title, pos = find_group_title_and_pos!( line )
+    name = find_group_name!( line )
 
     logger.debug "  line: >#{line}<"
 
-    group = Import::Group.new( pos: pos,
-                               title: title,
-                               teams: teams.map {|team| team.title } )
+    ## todo/check/fix: add back group key - why? why not?
+    group = Import::Group.new( name:  name,
+                               teams: teams.map {|team| team.name } )
 
-    @groups[ title ] = group
+    @groups[ name ] = group
   end
 
 
-  def find_group_title_and_pos!( line )
+  def find_group_name!( line )
     ## group pos - for now support single digit e.g 1,2,3 or letter e.g. A,B,C or HEX
     ## nb:  (?:)  = is for non-capturing group(ing)
 
@@ -125,37 +124,25 @@ class MatchParser   ## simple match parser for team match schedules
 
     ## todo:
     ##   check if Group A:  or [Group A]  works e.g. : or ] get matched by \b ???
-    regex = /(?:Group|Gruppe|Grupo)\s+((?:\d{1}|[A-Z]{1,3}))\b/
+    regex = /\b
+              (?:
+                (Group | Gruppe | Grupo)
+                   [ ]+
+                (\d+ | [A-Z]+)
+              )
+            \b/x
 
     m = regex.match( line )
 
-    return [nil,nil] if m.nil?
-
-    pos = case m[1]
-          when 'A' then 1
-          when 'B' then 2
-          when 'C' then 3
-          when 'D' then 4
-          when 'E' then 5
-          when 'F' then 6
-          when 'G' then 7
-          when 'H' then 8
-          when 'I' then 9
-          when 'J' then 10
-          when 'K' then 11
-          when 'L' then 12
-          when 'HEX' then 666    # HEX for Hexagonal - todo/check: map to something else ??
-          else  m[1].to_i
-          end
-
-    title = m[0]
-
-    logger.debug "   title: >#{title}<"
-    logger.debug "   pos: >#{pos}<"
-
-    line.sub!( regex, '[GROUP.TITLE+POS]' )
-
-    [title,pos]
+    return nil    if m.nil?
+
+    name = m[0]
+
+    logger.debug "   name: >#{name}<"
+
+    line.sub!( name, '[GROUP.NAME]' )
+
+    name
   end
 
 
@@ -180,198 +167,130 @@ class MatchParser   ## simple match parser for team match schedules
     end_date   = end_date.to_date
 
 
-    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 )
+    name  = find_round_def_name!( line )
+    # NB: use extracted round name for knockout check
+    knockout_flag = is_knockout_round?( name )
 
 
     logger.debug "    start_date: #{start_date}"
     logger.debug "    end_date:   #{end_date}"
-    logger.debug "    pos:      #{pos}"
-    logger.debug "    title:    >#{title}<"
+    logger.debug "    name:    >#{name}<"
     logger.debug "    knockout_flag:   #{knockout_flag}"
 
     logger.debug "  line: >#{line}<"
 
-    #######################################
-    # todo/fix: add auto flag is false !!!! - why? why not?
-    round = Import::Round.new( pos:        pos,
-                               title:      title,
+    round = Import::Round.new( name:       name,
                                start_date: start_date,
                                end_date:   end_date,
                                knockout:   knockout_flag,
                                auto:       false )
 
-    @rounds[ title ] = round
+    @rounds[ name ] = round
   end
 
 
 
-  def find_round_pos!( line )
-    # pass #1) extract optional round pos from line
-    # e.g.  (1)   - must start line
-    regex_pos = /^[ \t]*\((\d{1,3})\)[ \t]+/
-
-    # pass #2) find free standing number  e.g. Matchday 3 or Round 5 or 3. Spieltag etc.
-    # note: /\b(\d{1,3})\b/
-    #   will match -12
-    #  thus, use space required - will NOT match  -2 e.g. Group-2 Play-off
-    #  note:  allow  1. Runde  n
-    #                1^ Giornata
-    regex_num = /(?:^|\s)(\d{1,3})(?:[.\^\s]|$)/
-
-    if line =~ regex_pos
-      logger.debug "   pos: >#{$1}<"
-
-      line.sub!( regex_pos, '[ROUND.POS] ' )  ## NB: add back trailing space that got swallowed w/ regex -> [ \t]+
-      return $1.to_i
-    elsif line =~ regex_num
-      ## assume number in title is pos (e.g. Jornada 3, 3 Runde etc.)
-      ## NB: do NOT remove pos from string (will get removed by round title)
-
-      num = $1.to_i  # note: clone capture; keep a copy (another regex follows; will redefine $1)
-
-      #### fix:
-      #  use/make keywords required
-      #  e.g. Round of 16  -> should NOT match 16!
-      #    Spiel um Platz 3  (or 5) etc -> should NOT match 3!
-      #  Round 16 - ok
-      #  thus, check for required keywords
+  def find_round_def_name!( line )
+    # assume everything before pipe (\) is the round name
+    #  strip [ROUND.POS],  todo:?? [ROUND.NAME2]
 
-      ## quick hack for round of 16
-      # todo: mask match e.g. Round of xxx ... and try again - might include something
-      #  reuse pattern for Group XX Replays for example
-      if line =~ /^\s*Round of \d{1,3}\b/
-         return nil
-      end
-
-      logger.debug "   pos: >#{num}<"
-      return num
-    else
-      ## fix: add logger.warn no round pos found in line
-      return nil
-    end
-  end # method find_round_pos!
-
-  def find_round_def_title!( line )
-    # assume everything before pipe (\) is the round title
-    #  strip [ROUND.POS],  todo:?? [ROUND.TITLE2]
-
-    # todo/fix: add title2 w/  // or /  why? why not?
+    # todo/fix: add name2 w/  // or /  why? why not?
     #  -- strip / or / chars
 
     buf = line.dup
-    logger.debug "  find_round_def_title! line-before: >>#{buf}<<"
+    logger.debug "  find_round_def_name! line-before: >>#{buf}<<"
 
     ## cut-off everything after (including) pipe (|)
     buf = buf[ 0...buf.index('|') ]
-
-    # e.g. remove [ROUND.POS], [ROUND.TITLE2], [GROUP.TITLE+POS] etc.
-    buf.gsub!( /\[[^\]]+\]/, '' )    ## fix: use helper for (re)use e.g. remove_match_placeholder/marker or similar?
-    # remove leading and trailing whitespace
     buf.strip!
 
-    logger.debug "  find_round_def_title! line-after: >>#{buf}<<"
+    logger.debug "  find_round_def_name! line-after: >>#{buf}<<"
 
-    logger.debug "   title: >>#{buf}<<"
-    line.sub!( buf, '[ROUND.TITLE]' )
+    logger.debug "   name: >>#{buf}<<"
+    line.sub!( buf, '[ROUND.NAME]' )
 
     buf
   end
 
-  def find_round_header_title!( line )
-    # assume everything left is the round title
-    #  extract all other items first (round title2, round pos, group title n pos, etc.)
 
-    ## todo/fix:
-    ##  cleanup method
-    ##   use  buf.index( '//' ) to split string (see found_round_def)
-    ##     why? simpler why not?
-    ##  - do we currently allow groups if title2 present? add example if it works?
+    ##  split by or || or |||
+    ##           or ++ or +++
+    ##           or -- or ---
+    ##           or // or ///
+    ##  note: allow Final | First Leg  as ONE name same as
+    ##              Final - First Leg or
+    ##              Final, First Leg
+    ##   for cut-off always MUST be more than two chars
+    ##
+    ##  todo/check: find a better name than HEADER_SEP(ARATOR) - why? why not?
+    ##   todo/fix: move to parser utils and add a method split_name or such?
+    HEADER_SEP_RE = /  [ ]*      ## allow (strip) leading spaces
+                      (?:\|{2,} |
+                          \+{2,} |
+                           -{2,} |
+                          \/{2,}
+                      )
+                      [ ]*       ## allow (strip) trailing spaces
+                  /x
+
+  def find_round_header_name!( line )
+    # assume everything left is the round name
+    #  extract all other items first (round name2, round pos, group name n pos, etc.)
 
     buf = line.dup
-    logger.debug "  find_round_header_title! line-before: >>#{buf}<<"
+    logger.debug "  find_round_header_name! line-before: >>#{buf}<<"
+
+
+    parts = buf.split( HEADER_SEP_RE )
+    buf = parts[0]
 
-    buf.gsub!( /\[[^\]]+\]/, '' )   # e.g. remove [ROUND.POS], [ROUND.TITLE2], [GROUP.TITLE+POS] etc.
     buf.strip!    # remove leading and trailing whitespace
 
-    logger.debug "  find_round_title! line-after: >>#{buf}<<"
+    logger.debug "  find_round_name! line-after: >>#{buf}<<"
 
-    ### bingo - assume what's left is the round title
+    ### bingo - assume what's left is the round name
 
-    logger.debug "   title: >>#{buf}<<"
-    line.sub!( buf, '[ROUND.TITLE]' )
+    logger.debug "   name: >>#{buf}<<"
+    line.sub!( buf, '[ROUND.NAME]' )
 
     buf
   end
 
+    ## quick hack- collect all "fillwords" by language!!!!
+    ##    change later  and add to sportdb-langs!!!!
+    ##
+    ##    strip all "fillwords" e.g.:
+    ##      Nachtrag/Postponed/Addition/Supplemento names
+    ##
+    ##  todo/change: find a better name for ROUND_EXTRA_WORDS - why? why not?
+    ROUND_EXTRA_WORDS_RE = /\b(?:
+                               Nachtrag |     ## de
+                               Postponed |    ## en
+                               Addition  |    ## en
+                               Supplemento    ## es
+                              )
+                             \b/ix
 
   def parse_round_header( line )
     logger.debug "parsing round header line: >#{line}<"
 
-    ## todo/check/fix:
-    #   make sure  Round of 16  will not return pos 16 -- how? possible?
-    #   add unit test too to verify
-    pos = find_round_pos!( line )
-
-    title = find_round_header_title!( line )
+    name = find_round_header_name!( line )
 
     logger.debug "  line: >#{line}<"
 
+    name = name.sub( ROUND_EXTRA_WORDS_RE, '' )
+    name = name.strip
 
-    round = @rounds[ title ]
+    round = @rounds[ name ]
     if round.nil?    ## auto-add / create if missing
-      round = Import::Round.new( pos:   pos,
-                                 title: title )
-      @rounds[ title ] = round
+      ## todo/check: add num (was pos) if present - why? why not?
+      round = Import::Round.new( name: name )
+      @rounds[ name ] = round
     end
 
     ## todo/check: if pos match (MUST always match for now)
     @last_round = round
     @last_group = nil   # note: reset group to no group - why? why not?
-
-
-    ## NB: dummy/placeholder start_at, end_at date
-    ##  replace/patch after adding all games for round
-
-=begin
-    round_attribs = {
-      title:  title,
-      title2: title2,
-      knockout: knockout_flag
-    }
-
-    if pos > 999000
-      # no pos (e.g. will get autonumbered later) - try match by title for now
-      #  e.g. lets us use title 'Group Replays', for example, multiple times
-      @round = Round.find_by_event_id_and_title( @event.id, title )
-    else
-      @round = Round.find_by_event_id_and_pos( @event.id, pos )
-    end
-
-    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: Date.parse('1911-11-11'),
-        end_at:   Date.parse('1911-11-11')
-      })
-    end
-
-    logger.debug round_attribs.to_json
-
-    @round.update_attributes!( round_attribs )
-
-    @patch_round_ids_pos   << @round.id    if pos > 999000
-    ### store list of round ids for patching start_at/end_at at the end
-    @patch_round_ids_dates << @round.id   # todo/fix/check: check if round has definition (do NOT patch if definition (not auto-added) present)
-=end
   end
 
 
@@ -457,11 +376,11 @@ class MatchParser   ## simple match parser for team match schedules
     ## todo/check: pass along round and group refs or just string (canonical names) - why? why not?
 
     @matches << Import::Match.new( date:    date,
-                                   team1:   team1,  ## note: for now always use mapping value e.g. rec (NOT string e.g. team1.title)
-                                   team2:   team2,  ## note: for now always use mapping value e.g. rec (NOT string e.g. team2.title)
+                                   team1:   team1,  ## note: for now always use mapping value e.g. rec (NOT string e.g. team1.name)
+                                   team2:   team2,  ## note: for now always use mapping value e.g. rec (NOT string e.g. team2.name)
                                    score:   score,
-                                   round:   round       ? round.title       : nil,   ## note: for now always use string (assume unique canonical name for event)
-                                   group:   @last_group ? @last_group.title : nil )  ## note: for now always use string (assume unique canonical name for event)
+                                   round:   round       ? round.name       : nil,   ## note: for now always use string (assume unique canonical name for event)
+                                   group:   @last_group ? @last_group.name : nil )  ## note: for now always use string (assume unique canonical name for event)
 
     ### todo: cache team lookups in hash?
 
@@ -517,7 +436,7 @@ class MatchParser   ## simple match parser for team match schedules
 
         round_attribs = {
           event_id: @event.id,
-          title: "Matchday #{date.to_date}",
+          name: "Matchday #{date.to_date}",
           pos: 999001+@patch_round_ids_pos.length,   # e.g. 999<count> - 999001,999002,etc.
           start_at:  date.to_date,
           end_at:    date.to_date
@@ -541,7 +460,7 @@ class MatchParser   ## simple match parser for team match schedules
       end
 
       ## note: will crash (round.pos) if round is nil
-      logger.debug( "  using round #{round.pos} >#{round.title}< start_at: #{round.start_at}, end_at: #{round.end_at}" )
+      logger.debug( "  using round #{round.pos} >#{round.name}< start_at: #{round.start_at}, end_at: #{round.end_at}" )
     else
       ## use round from last round header
       round = @round

data/lib/sportdb/formats/match/match_parser_csv.rb

@@ -0,0 +1,321 @@
+# encoding: utf-8
+
+
+module SportDb
+  class CsvMatchParser
+
+  #############
+  # helpers
+  def self.find_seasons( path, col: 'Season', sep: nil, headers: nil )
+
+    ## check if headers incl. season if yes,has priority over col mapping
+    ##  e.g. no need to specify twice (if using headers)
+    col = headers[:season]    if headers && headers[:season]
+
+    seasons = Hash.new( 0 )   ## default value is 0
+
+    ## todo/fix: yes, use CsvHash.foreach  - why? why not?
+    ##                    use read_csv with block  to switch to foreach!!!!
+    rows = read_csv( path, sep: sep )
+
+    rows.each_with_index do |row,i|
+      puts "[#{i}] " + row.inspect  if i < 2
+
+      season = row[ col ]   ## column name defaults to 'Season'
+      seasons[ season ] += 1
+    end
+
+    pp seasons
+
+    ## note: only return season keys/names (not hash with usage counter)
+    seasons.keys
+  end
+
+
+  ##########
+  # main machinery
+
+  ##  todo/fix: use a generic "global" parse_csv method - why? why not?
+  ## def self.parse_csv( text, sep: ',' )    ## helper -lets you change the csv library in one place if needed/desired
+  ##   ## note:  do NOT symbolize keys - keep them as is!!!!!!
+  ##  ##   todo/fix: move "upstream" and remove symbolize keys too!!! - why? why not?
+  ##   CsvHash.parse( text, sep: sep )
+  ## end
+
+  def self.read( path, headers: nil, filters: nil, converters: nil, sep: nil )
+     txt = File.open( path, 'r:utf-8' ) {|f| f.read }   ## note: make sure to use (assume) utf-8
+     parse( txt, headers: headers,
+                 filters: filters,
+                 converters: converters,
+                 sep: sep )
+  end
+
+  def self.parse( txt, headers: nil, filters: nil, converters: nil, sep: nil )
+     new( txt ).parse( headers: headers,
+                        filters: filters,
+                        converters: converters,
+                        sep: sep )
+  end
+
+
+  def initialize( txt )
+    @txt = txt
+  end
+
+  def parse( headers: nil, filters: nil, converters: nil, sep: nil )
+
+    headers_mapping = {}
+
+    rows = parse_csv( @txt, sep: sep )
+
+    return []   if rows.empty?      ## no rows / empty?
+
+
+    ## fix/todo: use logger!!!!
+    ## pp csv
+
+    if headers   ## use user supplied headers if present
+      headers_mapping = headers_mapping.merge( headers )
+    else
+
+      ## note: returns an array of strings (header names)  - assume all rows have the same columns/fields!!!
+      headers = rows[0].keys
+      pp headers
+
+      # note: greece 2001-02 etc. use HT  -  check CVS reader  row['HomeTeam'] may not be nil but an empty string?
+      #   e.g. row['HomeTeam'] || row['HT'] will NOT work for now
+
+      if find_header( headers, ['Team 1']) && find_header( headers, ['Team 2'])
+         ## assume our own football.csv format, see github.com/footballcsv
+         headers_mapping[:team1]  = find_header( headers, ['Team 1'] )
+         headers_mapping[:team2]  = find_header( headers, ['Team 2'] )
+         headers_mapping[:date]   = find_header( headers, ['Date'] )
+
+         ## check for all-in-one full time (ft) and half time (ht9 scores?
+         headers_mapping[:score]  = find_header( headers, ['FT'] )
+         headers_mapping[:scorei] = find_header( headers, ['HT'] )
+
+         headers_mapping[:round]  = find_header( headers, ['Round'] )
+
+         ## optional headers - note: find_header returns nil if header NOT found
+         header_stage = find_header( headers, ['Stage'] )
+         headers_mapping[:stage]  =  header_stage   if header_stage
+      else
+         ## else try footballdata.uk and others
+         headers_mapping[:team1]  = find_header( headers, ['HomeTeam', 'HT', 'Home'] )
+         headers_mapping[:team2]  = find_header( headers, ['AwayTeam', 'AT', 'Away'] )
+         headers_mapping[:date]   = find_header( headers, ['Date'] )
+
+         ## note: FT = Full Time, HG = Home Goal, AG = Away Goal
+         headers_mapping[:score1] = find_header( headers, ['FTHG', 'HG'] )
+         headers_mapping[:score2] = find_header( headers, ['FTAG', 'AG'] )
+
+         ## check for half time scores ?
+         ##  note: HT = Half Time
+         headers_mapping[:score1i] = find_header( headers, ['HTHG'] )
+         headers_mapping[:score2i] = find_header( headers, ['HTAG'] )
+      end
+    end
+
+    pp headers_mapping
+
+    ### todo/fix: check headers - how?
+    ##  if present HomeTeam or HT required etc.
+    ##   issue error/warn is not present
+    ##
+    ## puts "*** !!! wrong (unknown) headers format; cannot continue; fix it; sorry"
+    ##    exit 1
+    ##
+
+    matches = []
+
+    rows.each_with_index do |row,i|
+
+      ## fix/todo: use logger!!!!
+      ## puts "[#{i}] " + row.inspect  if i < 2
+
+
+      ## todo/fix: move to its own (helper) method - filter or such!!!!
+       if filters    ## filter MUST match if present e.g. row['Season'] == '2017/2018'
+         skip = false
+         filters.each do |header, value|
+           if row[ header ] != value   ## e.g. row['Season']
+             skip = true
+             break
+           end
+         end
+         next if skip   ## if header values NOT matching
+       end
+
+
+      ## note:
+      ##   add converters after filters for now (why not before filters?)
+      if converters   ## any converters defined?
+        ## convert single proc shortcut to array with single converter
+        converters = [converters]    if converters.is_a?( Proc )
+
+        ## assumes array of procs
+        converters.each do |converter|
+          row = converter.call( row )
+        end
+      end
+
+
+
+      team1 = row[ headers_mapping[ :team1 ]]
+      team2 = row[ headers_mapping[ :team2 ]]
+
+
+      ## check if data present - if not skip (might be empty row)
+      ##  note:  (old classic) csv reader returns nil for empty fields
+      ##         new modern csv reader ALWAYS returns strings (and empty strings for data not available (n/a))
+      if (team1.nil? || team1.empty?) &&
+         (team2.nil? || team2.empty?)
+        puts "*** WARN: skipping empty? row[#{i}] - no teams found:"
+        pp row
+        next
+      end
+
+      ## remove possible match played counters e.g. (4) (11) etc.
+      team1 = team1.sub( /\(\d+\)/, '' ).strip
+      team2 = team2.sub( /\(\d+\)/, '' ).strip
+
+
+
+      col = row[ headers_mapping[ :date ]]
+      col = col.strip   # make sure not leading or trailing spaces left over
+
+      if col.empty? ||
+         col =~ /^-{1,}$/ ||      # e.g.  - or ---
+         col =~ /^\?{1,}$/        # e.g. ? or ???
+          ## note: allow missing / unknown date for match
+          date = nil
+      else
+        ## remove possible weekday or weeknumber  e.g. (Fri) (4) etc.
+        col = col.sub( /\(W?\d{1,2}\)/, '' )  ## e.g. (W11), (4), (21) etc.
+        col = col.sub( /\(\w+\)/, '' )  ## e.g. (Fri), (Fr) etc.
+        col = col.strip   # make sure not leading or trailing spaces left over
+
+        if col =~ /^\d{2}\/\d{2}\/\d{4}$/
+          date_fmt = '%d/%m/%Y'   # e.g. 17/08/2002
+        elsif col =~ /^\d{2}\/\d{2}\/\d{2}$/
+          date_fmt = '%d/%m/%y'   # e.g. 17/08/02
+        elsif col =~ /^\d{4}-\d{2}-\d{2}$/      ## "standard" / default date format
+          date_fmt = '%Y-%m-%d'   # e.g. 1995-08-04
+        elsif col =~ /^\d{1,2} \w{3} \d{4}$/
+          date_fmt = '%d %b %Y'   # e.g. 8 Jul 2017
+        elsif col =~ /^\w{3} \w{3} \d{1,2} \d{4}$/
+          date_fmt = '%a %b %d %Y'   # e.g. Sat Aug 7 1993
+        else
+          puts "*** !!! wrong (unknown) date format >>#{col}<<; cannot continue; fix it; sorry"
+          ## todo/fix: add to errors/warns list - why? why not?
+          exit 1
+        end
+
+        ## todo/check: use date object (keep string?) - why? why not?
+        ##  todo/fix: yes!! use date object!!!! do NOT use string
+        date = Date.strptime( col, date_fmt ).strftime( '%Y-%m-%d' )
+      end
+
+
+      round   = nil
+      ## check for (optional) round / matchday
+      if headers_mapping[ :round ]
+        col = row[ headers_mapping[ :round ]]
+        ## todo: issue warning if not ? or - (and just empty string) why? why not
+        round = col.to_i  if col =~ /^\d{1,2}$/     # check format - e.g. ignore ? or - or such non-numbers for now
+      end
+
+
+      score1  = nil
+      score2  = nil
+      score1i = nil
+      score2i = nil
+
+      ## check for full time scores ?
+      if headers_mapping[ :score1 ] && headers_mapping[ :score2 ]
+        ft = [ row[ headers_mapping[ :score1 ]],
+               row[ headers_mapping[ :score2 ]] ]
+
+        ## todo/fix: issue warning if not ? or - (and just empty string) why? why not
+        score1 = ft[0].to_i  if ft[0] =~ /^\d{1,2}$/
+        score2 = ft[1].to_i  if ft[1] =~ /^\d{1,2}$/
+      end
+
+      ## check for half time scores ?
+      if headers_mapping[ :score1i ] && headers_mapping[ :score2i ]
+        ht = [ row[ headers_mapping[ :score1i ]],
+               row[ headers_mapping[ :score2i ]] ]
+
+        ## todo/fix: issue warning if not ? or - (and just empty string) why? why not
+        score1i = ht[0].to_i  if ht[0] =~ /^\d{1,2}$/
+        score2i = ht[1].to_i  if ht[1] =~ /^\d{1,2}$/
+      end
+
+      ## check for all-in-one full time scores?
+      if headers_mapping[ :score ]
+        ft = row[ headers_mapping[ :score ] ]
+        if ft =~ /^\d{1,2}[\-:]\d{1,2}$/   ## sanity check scores format
+          scores = ft.split( /[\-:]/ )
+          score1 = scores[0].to_i
+          score2 = scores[1].to_i
+        end
+        ## todo/fix: issue warning if non-empty!!! and not matching format!!!!
+      end
+
+      if headers_mapping[ :scorei ]
+        ht = row[ headers_mapping[ :scorei ] ]
+        if ht =~ /^\d{1,2}[\-:]\d{1,2}$/   ## sanity check scores format
+          scores = ht.split( /[\-:]/)   ## allow 1-1 and 1:1
+          score1i = scores[0].to_i
+          score2i = scores[1].to_i
+        end
+        ## todo/fix: issue warning if non-empty!!! and not matching format!!!!
+      end
+
+
+      ## try some optional headings / columns
+      stage = nil
+      if headers_mapping[ :stage ]
+        col = row[ headers_mapping[ :stage ]]
+        ## todo/fix: check can col be nil e.g. col.nil? possible?
+        stage =  if col.nil? || col.empty? || col == '-' || col == 'n/a'
+                    ## note: allow missing stage for match / defaults to "regular"
+                    nil
+                 elsif col == '?'
+                     ## note: default explicit unknown to unknown for now AND not regular - why? why not?
+                    '?'   ## todo/check: use unkown and NOT ?  - why? why not?
+                 else
+                    col
+                 end
+      end
+
+
+      match = Import::Match.new( date:    date,
+                                 team1:   team1,   team2:   team2,
+                                 score1:  score1,  score2:  score2,
+                                 score1i: score1i, score2i: score2i,
+                                 round:   round,
+                                 stage:   stage )
+      matches << match
+    end
+
+    ## pp matches
+    matches
+  end
+
+
+  private
+
+  def find_header( headers, candidates )
+     ## todo/fix: use find_first from enumare of similar ?! - why? more idiomatic code?
+
+    candidates.each do |candidate|
+       return candidate   if headers.include?( candidate ) ## bingo!!!
+    end
+    nil  ## no matching header  found!!!
+  end
+
+  end # class CsvMatchParser
+  end # module SportDb
+