sportdb-formats 1.0.2 → 1.1.0

data/lib/sportdb/formats/package.rb

@@ -2,38 +2,79 @@
 module SportDb
   class Package
 
+    ## todo/fix:   make all regexes case-insensitive with /i option - why? why not?
+    ##                e.g. .TXT and .txt
+    ##   yes!! use /i option!!!!!
+
     CONF_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
         \.conf\.txt$
     }x
 
+    ## leagues.txt or leagues_en.txt
+    ##   remove support for en.leagues.txt - why? why not?
     LEAGUES_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
        (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.clubs.wiki.txt
-        leagues\.txt$
+        leagues
+          (?:_[a-z0-9_-]+)?
+        \.txt$
     }x
 
+    ## clubs.txt or clubs_en.txt
+    ##   remove support for en.clubs.txt - why? why not?
     CLUBS_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
        (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.clubs.txt
-        clubs\.txt$
+        clubs
+          (?:_[a-z0-9_-]+)?
+        \.txt$
     }x
 
     CLUBS_WIKI_RE = %r{  (?:^|/)               # beginning (^) or beginning of path (/)
         (?:[a-z]{1,4}\.)?   # optional country code/key e.g. eng.clubs.wiki.txt
-       clubs\.wiki\.txt$
+       clubs
+         (?:_[a-z0-9_-]+)?
+       \.wiki\.txt$
     }x
 
     CLUB_PROPS_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
       (?: [a-z]{1,4}\. )?   # optional country code/key e.g. eng.clubs.props.txt
-        clubs\.props\.txt$
+        clubs
+          (?:_[a-z0-9_-]+)?
+        \.props\.txt$
+    }x
+
+    ##  teams.txt or teams_history.txt
+    TEAMS_RE = %r{  (?: ^|/ )               # beginning (^) or beginning of path (/)
+                      teams
+                        (?:_[a-z0-9_-]+)?
+                      \.txt$
     }x
 
+    ### season folder:
+    ##            e.g. /2019-20   or
+    ##  year-only e.g. /2019      or
+    ##                 /2016--france
+    SEASON_RE = %r{ (?:
+                       \d{4}-\d{2}
+                     | \d{4}(--[a-z0-9_-]+)?
+                    )
+                  }x
+    SEASON = SEASON_RE.source    ## "inline" helper for embedding in other regexes - keep? why? why not?
+
+
     ## note: if pattern includes directory add here
     ##     (otherwise move to more "generic" datafile) - why? why not?
-    MATCH_RE = %r{ /(?: \d{4}-\d{2}        ## season folder e.g. /2019-20
-                      | \d{4}(--[^/]+)?    ## season year-only folder e.g. /2019 or /2016--france
-                    )
-                   /[a-z0-9_-]+\.txt$  ## txt e.g /1-premierleague.txt
+    MATCH_RE = %r{ (?: ^|/ )      # beginning (^) or beginning of path (/)
+                       #{SEASON}
+                     /[a-z0-9_-]+\.txt$  ## txt e.g /1-premierleague.txt
                 }x
 
+    MATCH_CSV_RE = %r{ (?: ^|/ )      # beginning (^) or beginning of path (/)
+                         #{SEASON}
+                       /[a-z0-9_.-]+\.csv$  ## note: allow dot (.) too e.g /eng.1.csv
+                    }x
+
+
+
     ## move class-level "static" finders to DirPackage (do NOT work for now for zip packages) - why? why not?
 
     def self.find( path, pattern )
@@ -41,7 +82,7 @@ module SportDb
 
       ## check all txt files
       ## note: incl. files starting with dot (.)) as candidates (normally excluded with just *)
-      candidates = Dir.glob( "#{path}/**/{*,.*}.txt" )
+      candidates = Dir.glob( "#{path}/**/{*,.*}.*" )
       pp candidates
       candidates.each do |candidate|
         datafiles << candidate    if pattern.match( candidate )
@@ -52,6 +93,8 @@ module SportDb
    end
 
 
+   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
@@ -66,7 +109,19 @@ module SportDb
    def self.find_conf( path, pattern: CONF_RE )  find( path, pattern ); end
    def self.match_conf( path )  CONF_RE.match( path ); end
 
+   def self.find_match( path, format: 'txt' )
+      if format == 'csv'
+        find( path, MATCH_CSV_RE )
+      else  ## otherwise always assume txt for now
+        find( path, MATCH_RE )
+      end
+   end
+   ## add match_match and match_match_csv  - why? why not?
+
    class << self
+     alias_method :match_teams?, :match_teams
+     alias_method :teams?,       :match_teams
+
      alias_method :match_clubs?, :match_clubs
      alias_method :clubs?,       :match_clubs
 
@@ -149,7 +204,14 @@ module SportDb
     end
 
     def each_conf( &blk )       each( pattern: CONF_RE, &blk ); end
-    def each_match( &blk )      each( pattern: MATCH_RE, &blk ); end
+    def each_match( format: 'txt', &blk )
+      if format == 'csv'
+         each( pattern: MATCH_CSV_RE, &blk );
+      else
+         each( pattern: MATCH_RE, &blk );
+      end
+    end
+    def each_match_csv( &blk )  each( pattern: MATCH_CSV_RE, &blk ); end
     def each_club_props( &blk ) each( pattern: CLUB_PROPS_RE, &blk ); end
 
     def each_leagues( &blk )    each( pattern: LEAGUES_RE, &blk ); end
@@ -157,8 +219,100 @@ module SportDb
     def each_clubs_wiki( &blk ) each( pattern: CLUBS_WIKI_RE, &blk ); end
 
     ## return all match datafile entries
-    def match()  ary=[]; each_match {|entry| ary << entry  }; ary; end
+    def match( format: 'txt' )
+      ary=[]; each_match( format: format ) {|entry| ary << entry  }; ary;
+    end
     alias_method :matches, :match
+
+
+    ## todo/check:  rename/change to match_by_dir - why? why not?
+    ##  still in use somewhere? move to attic? use match_by_season and delete by_season_dir? - why? why not?
+    def match_by_season_dir( format: 'txt' )
+      ##
+      ## [["1950s/1956-57",
+      ##    ["1950s/1956-57/1-division1.csv",
+      ##     "1950s/1956-57/2-division2.csv",
+      ##     "1950s/1956-57/3a-division3n.csv",
+      ##     "1950s/1956-57/3b-division3s.csv"]],
+      ##   ...]
+
+      h = {}
+      match( format: format ).each do |entry|
+        season_path = File.dirname( entry.name )
+
+        h[ season_path ] ||= []
+        h[ season_path ] << entry
+      end
+
+      ##  todo/fix:  - add sort entries by name - why? why not?
+      ## note: assume 1-,2- etc. gets us back sorted leagues
+      ##  - use sort. (will not sort by default?)
+
+      h.to_a    ## return as array (or keep hash) - why? why not?
+    end # method match_by_season_dir
+
+    def match_by_season( format: 'txt', start: nil )   ## change/rename to by_season_key - why? why not?
+
+      ## todo/note: in the future - season might be anything (e.g. part of a filename and NOT a directory) - why? why not?
+
+      ##  note: fold all sames seasons (even if in different directories)
+      ##     into same datafile list e.g.
+      ##   ["1957/58",
+      ##     ["1950s/1957-58/1-division1.csv",
+      ##      "1950s/1957-58/2-division2.csv",
+      ##      "1950s/1957-58/3a-division3n.csv",
+      ##      "1950s/1957-58/3b-division3s.csv"]],
+      ## and
+      ##   ["1957/58",
+      ##      ["archives/1950s/1957-58/1-division1.csv",
+      ##       "archives/1950s/1957-58/2-division2.csv",
+      ##       "archives/1950s/1957-58/3a-division3n.csv",
+      ##       "archives/1950s/1957-58/3b-division3s.csv"]],
+      ##  should be together - why? why not?
+
+      ####
+      # Example package:
+      # [["2012/13", ["2012-13/1-proleague.csv"]],
+      #  ["2013/14", ["2013-14/1-proleague.csv"]],
+      #  ["2014/15", ["2014-15/1-proleague.csv"]],
+      #  ["2015/16", ["2015-16/1-proleague.csv"]],
+      #  ["2016/17", ["2016-17/1-proleague.csv"]],
+      #  ["2017/18", ["2017-18/1-proleague.csv"]]]
+
+      ## todo/fix:  (re)use a more generic filter instead of start for start of season only
+
+      ##  todo/fix: use a "generic" filter_season helper for easy reuse
+      ##     filter_season( clause, season_key )
+      ##   or better filter = SeasonFilter.new( clause )
+      ##             filter.skip? filter.include? ( season_sason_key )?
+      ##             fiteer.before?( season_key )  etc.
+      ##              find some good method names!!!!
+      season_start = start ? Import::Season.new( start ) : nil
+
+      h = {}
+      match( format: format ).each do |entry|
+        ## note: assume last directory in datafile path is the season part/key
+        season_q = File.basename( File.dirname( entry.name ))
+        season   = Import::Season.new( season_q )  ## normalize season
+
+        ## skip if start season before this season
+        next if season_start && season_start.start_year > season.start_year
+
+        h[ season.key ] ||= []
+        h[ season.key ] << entry
+      end
+
+      ##  todo/fix:  - add sort entries by name - why? why not?
+      ## note: assume 1-,2- etc. gets us back sorted leagues
+      ##  - use sort. (will not sort by default?)
+
+      ## sort by season
+      ##   latest / newest first (and oldest last)
+
+      h.to_a.sort do |l,r|    ## return as array (or keep hash) - why? why not?
+        r[0] <=> l[0]
+      end
+    end # method match_by_season
   end   # class Package
 
 

data/lib/sportdb/formats/parser_helper.rb

@@ -18,10 +18,19 @@ module SportDb
 
 
   def is_round?( line )
-    ## note: =~ return nil if not match found, and 0,1, etc for match
-    (line =~ SportDb.lang.regex_round) != nil
+    ## note: =~ returns nil if not match found, and 0,1, etc for match
+
+    ##  note: allow "free standing" leg 1 and leg 2 too
+    ##         (e.g. Hinspiel, Rückspiel etc. used for now in Relegation, for example)
+    ##    note ONLY allowed if "free standing", that is, full line with nothing else
+    ##          use "custom" regex for special case for now
+    ##               avoids match HIN in PascHINg, for example (hin in german for leg 1)
+    line =~ SportDb.lang.regex_round    ||
+    line =~ /^(#{SportDb.lang.leg1})$/i ||
+    line =~ /^(#{SportDb.lang.leg2})$/i
   end
 
+
   def is_knockout_round?( line )
 
     ## todo: check for adding ignore case for regex (e.g. 1st leg/1st Leg)

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

@@ -93,12 +93,51 @@ module ScoreFormats
              (?=[ \]]|$)/xi    ## todo/check:  remove loakahead assertion here - why require space?
                                ## note: \b works only after non-alphanum e.g. )
 
+
     #####
     #  deutsch / german helpers (penalty, extra time, ...)
     ## todo add more marker e.g. im Elf. or such!!!
     P_DE  =  '(?: ie | i\.e\.? )'     # e.g. iE, i.E., i.E etc.
     ET_DE =  '(?: nv | n\.v\.? )'     # e.g. nV, n.V., n.V etc.
 
+
+    ## support alternate all-in-one score e.g.
+    ##     i.E. 2:4, n.V. 3:3 (1:1, 1:1)  or
+    ##               n.V. 3:2 (2:2, 1:2)
+    DE__P_ET_FT_HT__RE = /\b
+                     (?:
+                     #{P_DE}
+                      [ ]*
+                     (?<score1p>\d{1,2})
+                      [ ]* : [ ]*
+                     (?<score2p>\d{1,2})
+                      [ ]* (?:, [ ]*)?
+                     )?   # note: make penalty (P) score optional for now
+                      #{ET_DE}
+                      [ ]*
+                     (?<score1et>\d{1,2})
+                      [ ]* : [ ]*
+                     (?<score2et>\d{1,2})
+                      [ ]*
+                    \(
+                 [ ]*
+             (?<score1>\d{1,2})
+                  [ ]* : [ ]*
+             (?<score2>\d{1,2})
+                  [ ]*
+               (?:
+                   , [ ]*
+                   (?:
+                    (?<score1i>\d{1,2})
+                      [ ]* : [ ]*
+                    (?<score2i>\d{1,2})
+                      [ ]*
+                   )?
+               )?    # note: make half time (HT) score optional for now
+             \)
+            (?=[ \]]|$)
+              /xi
+
     ## support all-in-one "literal form e.g.
     #  2:2 (1:1, 1:0) n.V. 5:1 i.E.   or
     #  2-2 (1-1, 1-0) n.V. 5-1 i.E.
@@ -168,7 +207,8 @@ FORMATS_EN = [
 ]
 
 FORMATS_DE = [
-  [ DE__ET_FT_HT_P__RE, '[SCORE.DE__ET_(FT_HT?)_P?]' ], # e.g.  2:2 (1:1, 1:0) n.V. 5:1 i.E.
+  [ DE__ET_FT_HT_P__RE, '[SCORE.DE__ET_(FT_HT?)_P?]' ], # e.g. 2:2 (1:1, 1:0) n.V. 5:1 i.E.
+  [ DE__P_ET_FT_HT__RE, '[SCORE.DE__P?_ET_(FT_HT?)]' ], # e.g. i.E. 2:4, n.V. 3:3 (1:1, 1:1)
   [ DE__FT_HT__RE,      '[SCORE.DE__FT_(HT)?]'       ], # e.g. 1:1 (1:0)
 ]
 

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

@@ -90,6 +90,12 @@ class ScoreParser
 
 
   def parse( line )
+
+     ##########
+     ## todo/fix/check: add unicode to regular dash conversion - why? why not?
+     ##  e.g. – becomes -  (yes, the letters a different!!!)
+     #############
+
     score = nil
     @formats.each do |format|
       re = format[0]

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

@@ -11,11 +11,14 @@ class Country
 
   ## note: is read-only/immutable for now - why? why not?
   ##          add cities (array/list) - why? why not?
-  attr_reader   :key, :name, :fifa, :tags
+  attr_reader   :key, :name, :code, :tags
   attr_accessor :alt_names
 
-  def initialize( key:, name:, fifa:, tags: [] )
-    @key, @name, @fifa = key, name, fifa
+  def initialize( key: nil, name:, code:, tags: [] )
+    ## note: auto-generate key "on-the-fly" if missing for now - why? why not?
+    ## note: quick hack - auto-generate key, that is, remove all non-ascii chars and downcase
+    @key = key || name.downcase.gsub( /[^a-z]/, '' )
+    @name, @code = name, code
     @alt_names      = []
     @tags           = tags
   end

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

@@ -2,20 +2,13 @@ module SportDb
   module Import
 
     class Group
-      attr_reader   :title, :pos, :teams
+      attr_reader :key, :name, :teams
 
-      ##
-      ##  todo:  change db schema
-      ##    make start and end date optional
-      ##    change pos to num - why? why not?
-      ##    make pos/num optional too
-      ##
-      ##    sort round by scheduled/planed start date
-      def initialize( title:,
-                      pos:,
+      def initialize( key: nil,
+                      name:,
                       teams: )
-        @title  = title
-        @pos    = pos
+        @key    = key    ## e.g. A,B,C  or 1,2,3, - note: always a string or nil
+        @name   = name
         @teams  = teams
       end
     end  # class Group

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

@@ -2,24 +2,17 @@ module SportDb
   module Import
 
     class Round
-      attr_reader   :title, :start_date, :end_date, :knockout
-      attr_accessor :pos   # note: make read & writable
+      attr_reader   :name, :start_date, :end_date, :knockout
+      attr_accessor :num   # note: make read & writable - why? why not?
 
-      ##
-      ##  todo:  change db schema
-      ##    make start and end date optional
-      ##    change pos to num - why? why not?
-      ##    make pos/num optional too
-      ##
-      ##    sort round by scheduled/planed start date
-      def initialize( title:,
-                      pos: nil,
+      def initialize( name:,
+                      num: nil,
                       start_date: nil,
                       end_date: nil,
                       knockout: false,
                       auto: true )
-        @title      = title
-        @pos        = pos
+        @name       = name
+        @num        = num
         @start_date = start_date
         @end_date   = end_date
         @knockout   = knockout

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

@@ -12,7 +12,7 @@ module SportDb
 
 class Standings
 
-  class StandingsLine     ## nested class StandinsLine
+  class StandingsLine     ## nested class StandinsLine - todo/fix: change to Line - why? why not?
     attr_accessor  :rank, :team,
                    :played, :won, :lost, :drawn,                      ## -- total
                    :goals_for, :goals_against, :pts,
@@ -21,8 +21,13 @@ class Standings
                    :away_played, :away_won, :away_lost, :away_drawn,  ## -- away
                    :away_goals_for, :away_goals_against, :away_pts
 
+     alias_method :team_name, :team     ## note: team for now always a string
+     alias_method :pos,       :rank     ##  rename back to use pos instead of rank - why? why not?
+
+
     def initialize( team )
       @rank = nil # use 0? why? why not?
+      ## change rank back to pos - why? why not?
       @team = team
       @played = @home_played = @away_played = 0
       @won    = @home_won    = @away_won    = 0
@@ -49,7 +54,12 @@ class Standings
 
   def update( match_or_matches )
     ## convenience - update all matches at once
-    matches = match_or_matches.is_a?(Array) ? match_or_matches : [match_or_matches]
+    ## todo/check:  check for ActiveRecord_Associations_CollectionProxy and than use to_a (to "force" array) - why? why not?
+    matches = if match_or_matches.is_a?(Array)
+                match_or_matches
+              else
+                [match_or_matches]
+              end
 
     matches.each_with_index do |match,i| # note: index(i) starts w/ zero (0)
       update_match( match )
@@ -171,19 +181,30 @@ class Standings
 private
   def update_match( m )   ## add a match
 
-    ##  puts "   #{m.team1} - #{m.team2} #{m.score_str}"
+    ## note: always use team as string for now
+    ##   for now allow passing in of string OR struct - why? why not?
+    ##   todo/fix:  change to m.team1_name and m.team2_name - why? why not?
+    team1 = m.team1.is_a?( String ) ? m.team1 : m.team1.name
+    team2 = m.team2.is_a?( String ) ? m.team2 : m.team2.name
+
+    score = m.score_str
+
+    ##  puts "   #{team1} - #{team2} #{score}"
+
     unless m.over?
-      puts " !!!! skipping match - not yet over (play_at date in the future)"
+      puts " !!!! skipping match - not yet over (date in the future) => #{m.date}"
       return
     end
 
     unless m.complete?
-      puts "!!! [calc_standings] skipping match #{m.team1} - #{m.team2} - scores incomplete #{m.score_str}"
+      puts "!!! [calc_standings] skipping match #{team1} - #{team2} w/ past date #{m.date} - scores incomplete => #{score}"
       return
     end
 
-    line1 = @lines[ m.team1 ] || StandingsLine.new( m.team1 )
-    line2 = @lines[ m.team2 ] || StandingsLine.new( m.team2 )
+
+
+    line1 = @lines[ team1 ] || StandingsLine.new( team1 )
+    line2 = @lines[ team2 ] || StandingsLine.new( team2 )
 
     line1.played      += 1
     line1.home_played += 1
@@ -236,8 +257,8 @@ private
       puts "*** warn: [standings] skipping match with missing scores: #{m.inspect}"
     end
 
-    @lines[ m.team1 ] = line1
-    @lines[ m.team2 ] = line2
+    @lines[ team1 ] = line1
+    @lines[ team2 ] = line2
   end  # method update_match
 
 end  # class Standings