sportdb-formats 1.0.6 → 1.1.4

data/lib/sportdb/formats/league/league_index.rb

@@ -95,36 +95,40 @@ class LeagueIndex
   end # method add
 
 
+  ## helper to always convert (possible) country key to existing country record
+  ##  todo: make private - why? why not?
+  def country( country )
+    if country.is_a?( String ) || country.is_a?( Symbol )
+      ## note:  use own "global" countries index setting for ClubIndex - why? why not?
+      rec = catalog.countries.find( country.to_s )
+      if rec.nil?
+        puts "** !!! ERROR !!! - unknown country >#{country}< - no match found, sorry - add to world/countries.txt in config"
+        exit 1
+      end
+      rec
+    else
+      country  ## (re)use country struct - no need to run lookup again
+    end
+  end
+
+
   def match( name )
-    ## todo/check: return empty array if no match!!! and NOT nil (add || []) - why? why not?
+    ## note: returns empty array if no match and NOT nil
     name = normalize( name )
-    @leagues_by_name[ name ]
+    @leagues_by_name[ name ] || []
   end
 
-
   def match_by( name:, country: )
     ## note: match must for now always include name
     m = match( name )
-    if m    ## filter by country
+    if country    ## filter by country
       ## note: country assumes / allows the country key or fifa code for now
-
       ## note: allow passing in of country struct too
-      country_rec = if country.is_a?( Country )
-                       country   ## (re)use country struct - no need to run lookup again
-                    else
-                       ## note:  use own "global" countries index setting for ClubIndex - why? why not?
-                       rec = catalog.countries.find( country )
-                       if rec.nil?
-                         puts "** !!! ERROR !!! - unknown country >#{country}< - no match found, sorry - add to world/countries.txt in config"
-                         exit 1
-                       end
-                       rec
-                    end
+      country_rec = country( country )
 
       ## note: also skip international leagues & cups (e.g. champions league etc.) for now - why? why not?
       m = m.select { |league| league.country &&
                               league.country.key == country_rec.key }
-      m = nil   if m.empty?     ## note: reset to nil if no more matches
     end
     m
   end
@@ -144,7 +148,7 @@ class LeagueIndex
     m = match( name )
     # pp m
 
-    if m.nil?
+    if m.empty?
       ## fall through/do nothing
     elsif m.size > 1
       puts "** !!! ERROR - ambigious league name; too many leagues (#{m.size}) found:"

data/lib/sportdb/formats/league/league_outline_reader.rb

@@ -65,7 +65,7 @@ class LeagueOutlineReader   ## todo/check - rename to LeaguePageReader / LeagueP
        filtered_secs = []
        filter = norm_seasons( season )
        secs.each do |sec|
-         if filter.include?( Import::Season.new( sec[:season] ).key )
+         if filter.include?( Season.parse( sec[:season] ).key )
            filtered_secs << sec
          else
            puts "  skipping season >#{sec[:season]}< NOT matched by filter"
@@ -76,7 +76,7 @@ class LeagueOutlineReader   ## todo/check - rename to LeaguePageReader / LeagueP
 
     ## pass 3 - check & map; replace inline (string with data struct record)
     secs.each do |sec|
-      sec[:season] = Import::Season.new( sec[:season ] )
+      sec[:season] = Season.parse( sec[:season ] )
       sec[:league] = catalog.leagues.find!( sec[:league] )
 
       check_stage( sec[:stage] )   if sec[:stage]   ## note: only check for now (no remapping etc.)
@@ -100,14 +100,18 @@ class LeagueOutlineReader   ## todo/check - rename to LeaguePageReader / LeagueP
          )
             $}x
 
+
   def norm_seasons( season_or_seasons )     ## todo/check: add alias norm_seasons - why? why not?
-      seasons = if season_or_seasons.is_a?( String )   ## wrap in array
+
+      seasons = if season_or_seasons.is_a?( Array )  # is it an array already
+                  season_or_seasons
+                elsif season_or_seasons.is_a?( Range )  # e.g. Season(1999)..Season(2001) or such
+                  season_or_seasons.to_a
+                else  ## assume - single entry - wrap in array
                   [season_or_seasons]
-                else  ## assume it's an array already
-                   season_or_seasons
                 end
 
-      seasons.map { |season| Import::Season.new( season ).key }
+      seasons.map { |season| Season( season ).key }
   end
 
 
@@ -121,14 +125,42 @@ class LeagueOutlineReader   ## todo/check - rename to LeaguePageReader / LeagueP
     values
   end
 
-  def check_stage( name )
-    known_stages = ['regular season',
-                    'championship round',
-                    'relegation round',
-                    'play-offs'
-                   ]
 
-    if known_stages.include?( name.downcase )
+  # note: normalize names e.g. downcase and remove all non a-z chars (e.g. space, dash, etc.)
+  KNOWN_STAGES = [
+    'Regular Season',
+    'Regular Stage',
+    'Championship Round',
+    'Championship Playoff',  # or Championship play-off
+    'Relegation Round',
+    'Relegation Playoff',
+    'Play-offs',
+    'Playoff Stage',
+    'Grunddurchgang',
+    'Finaldurchgang - Qualifikationsgruppe',
+    'Finaldurchgang - Qualifikation',
+    'Finaldurchgang - Meistergruppe',
+    'Finaldurchgang - Meister',
+    'EL Play-off',
+    'Europa League Play-off',
+    'Europa-League-Play-offs',
+    'Playoffs - Championship',
+    'Playoffs - Europa League',
+    'Playoffs - Europa League - Finals',
+    'Playoffs - Relegation',
+    'Finals',
+
+    'Apertura',
+    'Apertura - Liguilla',
+    'Clausura',
+    'Clausura - Liguilla',
+
+  ].map {|name| name.downcase.gsub( /[^a-z]/, '' ) }
+
+
+  def check_stage( name )
+    # note: normalize names e.g. downcase and remove all non a-z chars (e.g. space, dash, etc.)
+    if KNOWN_STAGES.include?( name.downcase.gsub( /[^a-z]/, '' ) )
        ## everything ok
     else
       puts "** !!! ERROR - no (league) stage match found for >#{name}<, add to (builtin) stages table; sorry"

data/lib/sportdb/formats/league/league_reader.rb

@@ -118,12 +118,18 @@ def parse
               alt_names_auto << "#{country.code}"    if league_key == '1'   ## add shortcut for top level 1 (just country key)
             end
             alt_names_auto << "#{country.name} #{league_key}"  if league_key =~ /^[0-9]+$/   ## if all numeric e.g. add Austria 1 etc.
+
+            ## auto-add with country prepended
+            ##   e.g. England Premier League, Austria Bundesliga etc.
+            ##  todo/check: also add variants with country alt name if present!!!
+            ##  todo/check: exclude cups or such from country + league name auto-add - why? why not?
+            alt_names_auto << "#{country.name} #{league_name}"
           else   ## assume int'l (no country) e.g. champions league, etc.
             ## only auto-add key (e.g. CL, EL, etc.)
             alt_names_auto << league_key.upcase.gsub('.', ' ')   ## note: no country code (prefix/leading) used
           end
 
-          pp alt_names_auto
+          ## pp alt_names_auto
 
           ## prepend country key/code if country present
           ##   todo/fix: only auto-prepend country if key/code start with a number (level) or incl. cup

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

@@ -82,10 +82,9 @@ class MatchParser   ## simple match parser for team match schedules
     #    team1 team2 - match  (will get new auto-matchday! not last round)
     @last_round     = nil
 
-    name, pos = find_group_name_and_pos!( line )
+    name = find_group_name!( line )
 
     logger.debug "    name: >#{name}<"
-    logger.debug "    pos: >#{pos}<"
     logger.debug "  line: >#{line}<"
 
     group = @groups[ name ]
@@ -104,7 +103,7 @@ class MatchParser   ## simple match parser for team match schedules
     @mapper_teams.map_teams!( line )
     teams = @mapper_teams.find_teams!( line )
 
-    name, pos = find_group_name_and_pos!( line )
+    name = find_group_name!( line )
 
     logger.debug "  line: >#{line}<"
 
@@ -116,7 +115,7 @@ class MatchParser   ## simple match parser for team match schedules
   end
 
 
-  def find_group_name_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
+    return nil    if m.nil?
 
     name = m[0]
 
     logger.debug "   name: >#{name}<"
-    logger.debug "   pos: >#{pos}<"
 
-    line.sub!( regex, '[GROUP.NAME+POS]' )
+    line.sub!( name, '[GROUP.NAME]' )
 
-    [name,pos]
+    name
   end
 
 
@@ -180,7 +167,6 @@ class MatchParser   ## simple match parser for team match schedules
     end_date   = end_date.to_date
 
 
-    pos   = find_round_pos!( line )
     name  = find_round_def_name!( line )
     # NB: use extracted round name for knockout check
     knockout_flag = is_knockout_round?( name )
@@ -188,15 +174,11 @@ class MatchParser   ## simple match parser for team match schedules
 
     logger.debug "    start_date: #{start_date}"
     logger.debug "    end_date:   #{end_date}"
-    logger.debug "    pos:      #{pos}"
     logger.debug "    name:    >#{name}<"
     logger.debug "    knockout_flag:   #{knockout_flag}"
 
     logger.debug "  line: >#{line}<"
 
-    #######################################
-    # todo/fix: add auto flag is false !!!! - why? why not?
-    #   todo/fix/check: add num if present!!!!
     round = Import::Round.new( name:       name,
                                start_date: start_date,
                                end_date:   end_date,
@@ -208,52 +190,6 @@ class MatchParser   ## simple match parser for team match schedules
 
 
 
-  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 name is pos (e.g. Jornada 3, 3 Runde etc.)
-      ## NB: do NOT remove pos from string (will get removed by round name)
-
-      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
-
-      ## 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_name!( line )
     # assume everything before pipe (\) is the round name
     #  strip [ROUND.POS],  todo:?? [ROUND.NAME2]
@@ -266,10 +202,6 @@ class MatchParser   ## simple match parser for team match schedules
 
     ## cut-off everything after (including) pipe (|)
     buf = buf[ 0...buf.index('|') ]
-
-    # e.g. remove [ROUND.POS], [ROUND.NAME2], [GROUP.NAME+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_name! line-after: >>#{buf}<<"
@@ -280,20 +212,38 @@ class MatchParser   ## simple match parser for team match schedules
     buf
   end
 
+
+    ##  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.)
 
-    ## todo/fix:
-    ##  cleanup method
-    ##   use  buf.index( '//' ) to split string (see found_round_def)
-    ##     why? simpler why not?
-    ##  - do we currently allow groups if name2 present? add example if it works?
-
     buf = line.dup
     logger.debug "  find_round_header_name! line-before: >>#{buf}<<"
 
-    buf.gsub!( /\[[^\]]+\]/, '' )   # e.g. remove [ROUND.POS], [ROUND.NAME2], [GROUP.NAME+POS] etc.
+
+    parts = buf.split( HEADER_SEP_RE )
+    buf = parts[0]
+
     buf.strip!    # remove leading and trailing whitespace
 
     logger.debug "  find_round_name! line-after: >>#{buf}<<"
@@ -306,19 +256,30 @@ class MatchParser   ## simple match parser for team match schedules
     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 )
-
     name = find_round_header_name!( line )
 
     logger.debug "  line: >#{line}<"
 
+    name = name.sub( ROUND_EXTRA_WORDS_RE, '' )
+    name = name.strip
 
     round = @rounds[ name ]
     if round.nil?    ## auto-add / create if missing
@@ -341,6 +302,11 @@ class MatchParser   ## simple match parser for team match schedules
     ScoreFormats.find!( line )
   end
 
+  def find_status!( line )
+    StatusParser.find!( line )
+  end
+
+
   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
@@ -368,6 +334,10 @@ class MatchParser   ## simple match parser for team match schedules
       return false
     end
 
+    ## find (optional) match status e.g. [abandoned] or [replay] or [awarded]
+    ##                                   or [cancelled] or [postponed] etc.
+    status = find_status!( line )   ## todo/check: allow match status also in geo part (e.g. after @) - why? why not?
+
     ## pos = find_game_pos!( line )
 
       date      = find_date!( line, start: @start )
@@ -392,20 +362,23 @@ class MatchParser   ## simple match parser for team match schedules
     if @last_round
       round = @last_round
     else
-      ## find (first) matching round by date
-      @rounds.values.each do |round_rec|
-        ## note: convert date to date only (no time) with to_date!!!
-        if (round_rec.start_date && round_rec.end_date) &&
-           (date.to_date >= round_rec.start_date &&
-            date.to_date <= round_rec.end_date)
-          round = round_rec
-          break
+      ## find (first) matching round by date if rounds / matchdays defined
+      ##   if not rounds / matchdays defined - YES, allow matches WITHOUT rounds!!!
+      if @rounds.size > 0
+        @rounds.values.each do |round_rec|
+          ## note: convert date to date only (no time) with to_date!!!
+          if (round_rec.start_date && round_rec.end_date) &&
+             (date.to_date >= round_rec.start_date &&
+             date.to_date <= round_rec.end_date)
+            round = round_rec
+            break
+          end
+        end
+        if round.nil?
+          puts "!! ERROR - no matching round found for match date:"
+          pp date
+          exit 1
         end
-      end
-      if round.nil?
-        puts "!! ERROR - no matching round found for match date:"
-        pp date
-        exit 1
       end
     end
 
@@ -419,8 +392,8 @@ class MatchParser   ## simple match parser for team match schedules
                                    team2:   team2,  ## note: for now always use mapping value e.g. rec (NOT string e.g. team2.name)
                                    score:   score,
                                    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)
-
+                                   group:   @last_group ? @last_group.name : nil,   ## note: for now always use string (assume unique canonical name for event)
+                                   status:  status )
     ### todo: cache team lookups in hash?
 
 =begin
@@ -602,12 +575,29 @@ class MatchParser   ## simple match parser for team match schedules
 
     if date && team1.nil? && team2.nil?
       logger.debug( "date header line found: >#{line}<")
-      logger.debug( "    date: #{date}")
+      logger.debug( "    date: #{date} with start: #{@start}")
 
       @last_date = date   # keep a reference for later use
-      return true
+
+      ###  quick "corona" hack - support seasons going beyond 12 month (see swiss league 2019/20 and others!!)
+      ##    find a better way??
+      ##  set @start date to full year (e.g. 1.1.) if date.year  is @start.year+1
+      ##   todo/fix: add to linter to check for chronological dates!! - warn if NOT chronological
+      ###  todo/check: just turn on for 2019/20 season or always? why? why not?
+
+      ## todo/fix: add switch back to old @start_org
+      ##   if year is date.year == @start.year-1    -- possible when full date with year set!!!
+      if @start.month != 1
+         if date.year == @start.year+1
+           logger.debug( "!! hack - extending start date to full (next/end) year; assumes all dates are chronologigal - always moving forward" )
+           @start_org = @start   ## keep a copy of the original (old) start date - why? why not? - not used for now
+           @start = Date.new( @start.year+1, 1, 1 )
+         end
+      end
+
+      true
     else
-      return false
+      false
     end
   end