sportdb-formats 1.1.2 → 1.1.3

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

@@ -0,0 +1,86 @@
+#####################
+# helpers for parsing & finding match status e.g.
+#    - cancelled / canceled
+#    - awarded
+#    - abandoned
+#    - replay
+#    etc.
+
+
+module SportDb
+
+  class Status
+# note: use a class as an "enum"-like namespace for now - why? why not?
+#   move class into Match e.g. Match::Status  - why? why not?
+    CANCELLED = 'CANCELLED'   # canceled (US spelling), cancelled (UK spelling) - what to use?
+    AWARDED   = 'AWARDED'
+    POSTPONED = 'POSTPONED'
+    ABANDONED = 'ABANDONED'
+    REPLAY    = 'REPLAY'
+  end # class Status
+
+
+
+  class StatusParser
+
+    def self.parse( str )
+      ## note: returns nil if no match found
+      ## note: english usage - cancelled (in UK), canceled (in US)
+      if str =~ /^(cancelled|
+                   canceled|
+                   can\.
+                  )/xi
+        Status::CANCELLED
+      elsif str =~ /^(awarded|
+                       awd\.
+                      )/xi
+        Status::AWARDED
+      elsif str =~ /^(postponed
+                      )/xi
+        Status::POSTPONED
+      elsif str =~ /^(abandoned|
+                       abd\.
+                      )/xi
+        Status::ABANDONED
+      elsif str =~ /^(replay
+                      )/xi
+        Status::REPLAY
+      else
+        # no match
+        nil
+      end
+    end
+
+
+    RUN_RE = /\[
+                 (?<text>[^\]]+)
+               \]
+             /x
+    def self.find!( line )
+      ## for now check all "protected" text run blocks e.g. []
+      ##  puts "line: >#{line}<"
+
+      status = nil
+
+      str = line
+      while m = str.match( RUN_RE )
+        str = m.post_match  ## keep on processing rest of line/str (a.k.a. post match string)
+
+        ## check for status match
+        match_str = m[0]  ## keep a copy of the match string (for later sub)
+        text = m[:text].strip
+        ## puts "  text: >#{text}<"
+
+        status = parse( text )
+
+        if status
+           line.sub!( match_str, "[STATUS.#{status}]" )
+           break
+        end
+      end  # while match
+
+      status
+    end # method find!
+ end # class StatusParser
+
+end # module SportDb

data/lib/sportdb/formats/name_helper.rb

@@ -46,9 +46,12 @@ module SportDb
   ##   Estudiantes (LP) => Estudiantes LP
   ##   Saint Patrick’s Athletic FC => Saint Patricks Athletic FC
   ##   Myllykosken Pallo −47 => Myllykosken Pallo 47
+  ##
+  ##  add & too!!
+  ##   e.g. Brighton & Hove Albion => Brighton Hove Albion  -- and others in England
 
   NORM_RE =  %r{
-                    [.'’º/()_−-]
+                    [.'’º/()&_−-]
                   }x   # note: in [] dash (-) if last doesn't need to get escaped
   ## note: remove all dots (.), dash (-), ', º, /, etc.
   #   .  U+002E (46) - FULL STOP

data/lib/sportdb/formats/package.rb

@@ -45,12 +45,22 @@ module SportDb
        \.wiki\.txt$
     }x
 
-    CLUB_PROPS_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
+    ## todo/fix: rename to CLUBS too e.g. CLUBS_PROPS to reflect filename - why? why not?
+    CLUBS_PROPS_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
       (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.clubs.props.txt
         clubs
           (?:_[a-z0-9_-]+)?
         \.props\.txt$
     }x
+    CLUB_PROPS_RE = CLUBS_PROPS_RE  ## add alias for now (fix later - why? why not?)
+
+
+    CLUBS_HISTORY_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
+      (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.clubs.history.txt
+        clubs
+          (?:_[a-z0-9_-]+)?
+        \.history\.txt$
+    }x
 
     ##  teams.txt or teams_history.txt
     TEAMS_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
@@ -112,12 +122,14 @@ module SportDb
    def self.find_teams( path, pattern: TEAMS_RE )  find( path, pattern ); end
    def self.match_teams( path )  TEAMS_RE.match( path ); end
 
-   def self.find_clubs( path, pattern: CLUBS_RE )            find( path, pattern ); end
-   def self.find_clubs_wiki( path, pattern: CLUBS_WIKI_RE )  find( path, pattern ); end
+   def self.find_clubs( path, pattern: CLUBS_RE )                 find( path, pattern ); end
+   def self.find_clubs_wiki( path, pattern: CLUBS_WIKI_RE )       find( path, pattern ); end
+   def self.find_clubs_history( path, pattern: CLUBS_HISTORY_RE ) find( path, pattern ); end
 
-   def self.match_clubs( path )       CLUBS_RE.match( path ); end
-   def self.match_clubs_wiki( path )  CLUBS_WIKI_RE.match( path ); end
-   def self.match_club_props( path, pattern: CLUB_PROPS_RE ) pattern.match( path ); end
+   def self.match_clubs( path )         CLUBS_RE.match( path ); end
+   def self.match_clubs_wiki( path )    CLUBS_WIKI_RE.match( path ); end
+   def self.match_clubs_history( path ) CLUBS_HISTORY_RE.match( path); end
+   def self.match_clubs_props( path, pattern: CLUBS_PROPS_RE ) pattern.match( path ); end
 
    def self.find_leagues( path, pattern: LEAGUES_RE )  find( path, pattern ); end
    def self.match_leagues( path )  LEAGUES_RE.match( path ); end
@@ -149,8 +161,14 @@ module SportDb
      alias_method :match_clubs_wiki?, :match_clubs_wiki
      alias_method :clubs_wiki?,       :match_clubs_wiki
 
-     alias_method :match_club_props?, :match_club_props
-     alias_method :club_props?,       :match_club_props
+     alias_method :match_clubs_history?, :match_clubs_history
+     alias_method :clubs_history?,       :match_clubs_history
+
+     alias_method :match_club_props,      :match_clubs_props
+     alias_method :match_club_props?,     :match_clubs_props
+     alias_method :club_props?,           :match_clubs_props
+     alias_method :match_clubs_props?,    :match_clubs_props
+     alias_method :clubs_props?,          :match_clubs_props
 
      alias_method :match_leagues?, :match_leagues
      alias_method :leagues?,       :match_leagues
@@ -243,6 +261,10 @@ module SportDb
     def each_leagues( &blk )    each( pattern: LEAGUES_RE, &blk ); end
     def each_clubs( &blk )      each( pattern: CLUBS_RE, &blk ); end
     def each_clubs_wiki( &blk ) each( pattern: CLUBS_WIKI_RE, &blk ); end
+    def each_clubs_history( &blk )  each( pattern: CLUBS_HISTORY_RE, &blk ); end
+
+    def each_seasons( &blk )    each( pattern: SEASONS_RE, &blk ); end
+
 
     ## return all match datafile entries
     def match( format: 'txt' )

data/lib/sportdb/formats/score/score_formats.rb

@@ -9,6 +9,24 @@ module ScoreFormats
     ET_EN =  '(?: aet | a\.e\.t\.? )'     # note: make last . optional (e.g a.e.t) allowed too
 
 
+    ##  note: allow SPECIAL cases WITHOUT full time scores (just a.e.t or pen. + a.e.t.)
+    ##      3-4 pen. 2-2 a.e.t.
+    ##               2-2 a.e.t.
+    EN__P_ET__RE = /\b
+            (?:
+               (?<score1p>\d{1,2})
+                 [ ]* - [ ]*          # note: sep in optional block; CANNOT use a reference
+               (?<score2p>\d{1,2})
+                 [ ]* #{P_EN} [ ]*
+             )?            # note: make penalty (P) score optional for now
+            (?<score1et>\d{1,2})
+               [ ]* - [ ]*
+            (?<score2et>\d{1,2})
+               [ ]* #{ET_EN}
+               (?=[ \]]|$)/xi    ## todo/check:  remove loakahead assertion here - why require space?
+                   ## note: \b works only after non-alphanum e.g. )
+
+
     ## e.g. 3-4 pen. 2-2 a.e.t. (1-1, 1-1)  or
     ##      3-4 pen. 2-2 a.e.t. (1-1, )     or
     ##      3-4 pen. 2-2 a.e.t. (1-1)       or
@@ -203,6 +221,7 @@ module ScoreFormats
 FORMATS_EN = [
   [ EN__P_ET_FT_HT__RE, '[SCORE.EN__P?_ET_(FT_HT?)]' ], # e.g. 5-1 pen. 2-2 a.e.t. (1-1, 1-0)
   [ EN__P_FT_HT__RE,    '[SCORE.EN__P_(FT_HT?)]'     ], # e.g. 5-1 pen. (1-1)
+  [ EN__P_ET__RE,       '[SCORE.EN__P?_ET]'          ], # e.g. 2-2 a.e.t.  or  5-1 pen. 2-2 a.e.t.
   [ EN__FT_HT__RE,      '[SCORE.EN__FT_(HT)?]'       ], # e.g. 1-1 (1-0)
 ]
 

data/lib/sportdb/formats/score/score_parser.rb

@@ -175,8 +175,10 @@ private
       score2i   = h[:score2i].to_i
     end
 
-    score1 = h[:score1].to_i
-    score2 = h[:score2].to_i
+    if h[:score1] && h[:score2]     ## note: full time (FT) score can be optional too!!!
+      score1 = h[:score1].to_i
+      score2 = h[:score2].to_i
+    end
 
     if h[:score1et] && h[:score2et]
       score1et = h[:score1et].to_i

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

@@ -18,6 +18,7 @@ class Match
               :leg,      ## e.g. '1','2','3','replay', etc.   - use leg for marking **replay** too - keep/make leg numeric?! - why? why not?
               :stage,
               :group,
+              :status,    ## e.g. replay, cancelled, awarded, abadoned, postponed, etc.
               :conf1,    :conf2,      ## special case for mls e.g. conference1, conference2 (e.g. west, east, central)
               :country1, :country2,    ## special case for champions league etc. - uses FIFA country code
               :comments,
@@ -46,6 +47,7 @@ class Match
     @stage    = kwargs[:stage]    if kwargs.has_key? :stage
     @leg      = kwargs[:leg]      if kwargs.has_key? :leg
     @group    = kwargs[:group]    if kwargs.has_key? :group
+    @status   = kwargs[:status]   if kwargs.has_key? :status
     @comments = kwargs[:comments] if kwargs.has_key? :comments
 
     @league   = kwargs[:league]   if kwargs.has_key? :league

data/lib/sportdb/formats/structs/team.rb

@@ -65,6 +65,13 @@ class Team
   end
 
 
+  ## add convenience lookup helper / method for name by season for now
+  ##   use clubs history - for now kept separate from struct - why? why not?
+  def name_by_season( season )
+    ## note: returns / fallback to "regular" name if no records found in history
+    SportDb::Import.catalog.clubs_history.find_name_by( name: name, season: season ) || name
+  end
+
   ## helper methods for import only
   ## check for duplicates
   include NameHelper

data/lib/sportdb/formats/team/club_index.rb

@@ -54,6 +54,7 @@ class ClubIndex
   ##       normalize( name )
 
   def strip_wiki( name )     # todo/check: rename to strip_wikipedia_en - why? why not?
+    ##  change/rename to strip_wiki_qualifier or such - why? why not?
     ## note: strip disambiguationn qualifier from wikipedia page name if present
     ##        note: only remove year and foot... for now
     ## e.g. FC Wacker Innsbruck (2002) => FC Wacker Innsbruck
@@ -178,22 +179,24 @@ class ClubIndex
   ## todo/fix/check: use rename to find_canon  or find_canonical() or something??
   ##  remove (getting used?) - why? why not?
   def []( name )    ## lookup by canoncial name only;  todo/fix: add find alias why? why not?
+    puts "WARN!! do not use ClubIndex#[] for lookup >#{name}< - will get removed!!!"
     @clubs[ name ]
   end
 
 
-  ## todo/fix/check: return empty array if no match!!!
-  ##     and NOT nil (add || []) - why? why not?
   def match( name )
+    # note: returns empty array (e.g. []) if no match and NOT nil
     name = normalize( name )
-    m = @clubs_by_name[ name ]
+    m = @clubs_by_name[ name ] || []
 
     ## no match - retry with unaccented variant if different
     ##    e.g. example is Preussen Münster  (with mixed accent and unaccented letters) that would go unmatched for now
     ##      Preussen Münster => preussenmünster (norm) => preussenmunster (norm+unaccent)
-    if m.nil?
+    if m.empty?
       name2 = unaccent( name )
-      m = @clubs_by_name[ name2 ]    if name2 != name
+      if name2 != name
+        m = @clubs_by_name[ name2 ] || []
+      end
     end
     m
   end
@@ -227,10 +230,8 @@ class ClubIndex
       country = country( country )
 
       ## note: match must for now always  include name
-      if m    ## filter by country
-        m = m.select { |club| club.country.key == country.key }
-        m = nil   if m.empty?     ## note: reset to nil if no more matches
-      end
+      ## filter by country
+      m = m.select { |club| club.country.key == country.key }
     end
     m
   end
@@ -263,7 +264,7 @@ class ClubIndex
 
       m = match_by( name: name, country: country )
 
-      if m.nil?
+      if m.empty?
         ## (re)try with second country - quick hacks for known leagues
         ##  todo/fix: add league flag to activate!!!  - why? why not
         m = match_by( name: name, country: 'wal' )  if country.key == 'eng'
@@ -272,6 +273,7 @@ class ClubIndex
         m = match_by( name: name, country: 'mc' )   if country.key == 'fr'
         m = match_by( name: name, country: 'li' )   if country.key == 'ch'
         m = match_by( name: name, country: 'ca' )   if country.key == 'us'
+        m = match_by( name: name, country: 'nz' )   if country.key == 'au'
       end
     else  ## try "global" search - no country passed in
       m = match( name )
@@ -279,7 +281,7 @@ class ClubIndex
 
 
     club = nil
-    if m.nil?
+    if m.empty?
       ## puts "** !!! WARN !!! no match for club >#{name}<"
     elsif m.size > 1
       puts "** !!! ERROR - too many matches (#{m.size}) for club >#{name}<:"

data/lib/sportdb/formats/team/club_index_history.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+
+module SportDb
+  module Import
+
+
+class ClubHistoryIndex
+
+  def self.build( path )
+    pack = Package.new( path )   ## lets us use direcotry or zip archive
+
+    recs = []
+    pack.each_clubs_history do |entry|
+      recs += ClubHistoryReader.parse( entry.read )
+    end
+    recs
+
+    index = new
+    index.add( recs )
+    index
+  end
+
+
+
+  def catalog() Import.catalog; end
+
+  ## note: keep name history for now separate from
+  ##          from club struct - why? why not?
+  ##       later yes, yes, yes, merge name history into club struct!!!!!
+  ##
+  ## for now the name history is experimental
+
+
+  def initialize
+    @clubs          = {}   ## clubs (indexed) by canonical name
+    @errors         = []
+  end
+
+  attr_reader :errors
+  def errors?() @errors.empty? == false; end
+
+  def mappings() @clubs; end   ## todo/check: rename to records or histories or something - why? why not?
+
+
+  def add_history( club_rec, keyword, season, args )
+    ## note use season obj for now (and NOT key) - why? why not?
+    rec = @clubs[ club_rec.name ] ||= []
+
+    rec << [season, [keyword, args]]
+
+    ## note: always keep records sorted by season_key for now
+    ##   check if 2010 and 2010/11 is in order using alpha sort?? (see argentina)
+    rec.sort! { |l,r| r[0] <=> l[0] }
+  end
+
+
+  def add( rec_or_recs )   ## add club record / alt_names
+    recs = rec_or_recs.is_a?( Array ) ? rec_or_recs : [rec_or_recs]      ## wrap (single) rec in array
+
+    recs.each do |rec|
+
+      keyword    = rec[0]
+      season_key = rec[1]
+      args       = rec[2..-1]   ## get rest of args e.g. one, two or more
+
+      ## note: for now only add (re)name history season records,
+      ##          that is, skip MERGE and BANKRUPT for now
+      ##           and incl. only RENAME, REFORM, MOVE for now
+      next if ['MERGE', 'BANKRUPT'].include?( keyword )
+
+
+      name_old = strip_geo( args[0][0] )  ## note: strip optional geo part from name
+      name_new = strip_geo( args[1][0] )
+
+      country_old = args[0][1]
+      country_new = args[1][1]
+
+      club_old = catalog.clubs.find_by!( name: name_old, country: country_old )
+      club_new = catalog.clubs.find_by!( name: name_new, country: country_new )
+
+      ## note use season obj for now (and NOT key) - why? why not?
+      season = Season.new( season_key )
+
+      ## todo/check:
+      ##   check if  club_old and club_new reference different club record!!
+      ##    examples - RB II            -> Liefering ??  or
+      ##               FC Pasching      -> OOE Juniors ??
+      ##               Austria Salzburg -> RB Salburg ??
+      ##   for now always add name history to both - why? why not?
+
+      add_history( club_old, keyword, season, args )
+      ## note: allow for now different club references
+      ##    but maybe warn later - why? why not?
+      ## add history to both for now
+      add_history( club_new, keyword, season, args )  if club_old != club_new
+    end # each rec
+  end # method add
+
+
+  #### todo/check: move as method to club struct later - to always use club reference
+  ##  returns (simply) name as string for now or nil - why? why not?
+  #
+  #  history entry example
+  # Arsenal FC"=>
+  # [[1927/28, ["RENAME", [["The Arsenal FC, London", "eng"], ["Arsenal FC", "eng"]]]],
+  #  [1914/15, ["RENAME", [["Woolwich Arsenal FC, London", "eng"], ["The Arsenal FC", "eng"]]]],
+  #  [1892/93, ["RENAME", [["Royal Arsenal FC, London", "eng"], ["Woolwich Arsenal FC", "eng"]]]]],
+  def find_name_by( name:, season: )
+    recs = @clubs[ name ]
+    if recs
+      season = season( season )   ## make sure season is a season obj (and NOT a string)
+      ## check season records for name; use linear search (assume only few records)
+      recs.each do |rec|
+        if season >= rec[0]
+           return strip_geo( rec[1][1][1][0] )  # use second arg
+        end
+      end
+      ## if we get here use last name
+      strip_geo( recs[-1][1][1][0][0] )   # use first arg
+    else
+      nil
+    end
+  end
+
+  ##################
+  ## helpers
+  def season( season )
+    season.is_a?( Season ) ? season : Season.new( season )
+  end
+
+  def strip_geo( name )
+    ## e.g. Arsenal, London   =>   Arsenal
+    name.split(',')[0].strip
+  end
+end # class ClubHistoryIndex
+
+end   # module Import
+end   # module SportDb