sportdb-formats 1.0.5 → 1.1.3

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

@@ -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

@@ -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]
@@ -169,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/season_utils.rb

@@ -2,21 +2,10 @@
 
 
 module SeasonHelper ## use Helpers why? why not?
-
   ##############################################
   ### deprecated!!! use new Season class!!!
   ##   this code will get removed!!!!
   ###################################################
-
-  def prev( str )   SportDb::Import::Season.new( str ).prev;  end
-  def key( str )    SportDb::Import::Season.new( str ).key;   end
-  def directory( str, format: nil )  SportDb::Import::Season.new( str ).directory( format: format );  end
-
-  ## note: new start_year now returns an integer number (no longer a string)!!!
-  def start_year( str )  SportDb::Import::Season.new( str ).start_year;  end
-  ## note: new end_year now returns an integer number (no longer a string)!!!
-  ##       if now end_year (year? == true) than returns nil (no longer the start_year "as fallback")!!!
-  def end_year( str )   SportDb::Import::Season.new( str ).end_year;  end
 end  # module SeasonHelper
 
 

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/match.rb

@@ -18,9 +18,11 @@ 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
+              :comments,
+              :league      ## (optinal) added as text for now (use struct?)
 
   def initialize( **kwargs )
     update( kwargs )  unless kwargs.empty?
@@ -45,8 +47,12 @@ 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
+
+
     if kwargs.has_key?( :score )   ## check all-in-one score struct for convenience!!!
       score = kwargs[:score]
       if score.nil?   ## reset all score attribs to nil!!

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/season.rb

@@ -1,26 +1,19 @@
 # encoding: utf-8
 
 
-module SportDb
-  module Import
+### note: make Season like Date a "top-level" / "generic" class
+
 
 
 class Season
   ##
   ##  todo: add (optional) start_date and end_date - why? why not?
-  ##        add next
-
-
-  attr_reader :start_year,
-              :end_year
 
-  def year?()  @end_year.nil?; end  ## single-year season e.g. 2011 if no end_year present
-
-
-  def initialize( str )   ## assume only string / line gets passed in for now
-    @start_year, @end_year = parse( str )
-  end
+  ## todo/todo/todo/check/check/check !!!
+  ## todo: add a kernel Seaons e.g. Season('2011/12')
+  ##    forward to Season.convert( *args )  - why? why not?
 
+  ## todo: add unicode - too - why? why not? see wikipedia pages, for example
 
   YYYY_YYYY_RE  = %r{^      ## e.g. 2011-2012 or 2011/2012
                     (\d{4})
@@ -45,79 +38,155 @@ class Season
                    $
                   }x
 
-  def parse( str )
+
+  def self.parse( str )
+    new( *_parse( str ))
+  end
+
+  def self._parse( str )   ## "internal" parse helper
     if str =~ YYYY_YYYY_RE    ## e.g. 2011/2012
       [$1.to_i, $2.to_i]
     elsif str =~ YYYY_YY_RE   ## e.g. 2011/12
       fst = $1.to_i
       snd = $2.to_i
       snd_exp = '%02d' % [(fst+1) % 100]    ## double check: e.g 00 == 00, 01==01 etc.
-      raise ArgumentError.new( "[Season#parse] invalid year in season >>#{str}<<; expected #{snd_exp} but got #{$2}")   if snd_exp != $2
+      raise ArgumentError, "[Season.parse] invalid year in season >>#{str}<<; expected #{snd_exp} but got #{$2}"   if snd_exp != $2
       [fst, fst+1]
     elsif str =~ YYYY_Y_RE    ## e.g. 2011/2
       fst = $1.to_i
       snd = $2.to_i
       snd_exp = '%d' % [(fst+1) % 10]      ## double check: e.g 0 == 0, 1==1 etc.
-      raise ArgumentError.new( "[Season#parse] invalid year in season >>#{str}<<; expected #{snd_exp} but got #{$2}")   if snd_exp != $2
+      raise ArgumentError, "[Season.parse] invalid year in season >>#{str}<<; expected #{snd_exp} but got #{$2}"   if snd_exp != $2
       [fst, fst+1]
     elsif str =~ YYYY_RE      ## e.g. 2011
       [$1.to_i]
     else
-      raise ArgumentError.new( "[Season#parse] unkown season format >>#{str}<<; sorry cannot parse")
+      raise ArgumentError, "[Season.parse] unkown season format >>#{str}<<; sorry cannot parse"
+    end
+  end
+
+
+
+  attr_reader :start_year,
+              :end_year
+
+  def initialize( *args )   ## assume only string / line gets passed in for now
+    if args.size == 1 && args[0].is_a?( String )
+      @start_year, @end_year = self.class._parse( args[0] )
+    elsif args.size == 1 && args[0].is_a?( Integer )
+      @start_year = args[0]
+      @end_year   = nil
+    elsif args.size == 2 && args[0].is_a?( Integer ) &&
+                            args[1].is_a?( Integer )
+      @start_year = args[0]
+      @end_year   = args[1]
+      end_year_exp = @start_year+1
+      raise ArgumentError, "[Season] invalid year in season >>#{to_s}<<; expected #{end_year_exp} but got #{@end_year}"   if end_year_exp != @end_year
+    else
+      pp args
+      raise ArgumentError, "[Season] expected season string or season start year (integer) with opt. end year"
+    end
+  end
+
+
+  ###
+  ## convenience helper
+  def start_date   ## generate "generic / syntetic start date" - keep helper - why? why not?
+    if year?
+      Date.new( start_year, 1, 1 )
+    else
+      Date.new( start_year 1, 7 )
     end
   end
 
 
+  ## single-year season e.g. 2011 if no end_year present - todo - find a better name?
+  def year?()  @end_year.nil?; end
 
   def prev
     if year?
-      Season.new( "#{@start_year-1}" )
+      Season.new( @start_year-1 )
     else
-      Season.new( "#{@start_year-1}/#{@start_year}" )
+      Season.new( @start_year-1, @start_year )
     end
   end
 
-  def key
+  def next
     if year?
-      '%d' % @start_year
+      Season.new( @start_year+1 )
     else
-      '%d/%02d' % [@start_year, @end_year % 100]
+      Season.new( @end_year, @end_year+1 )
     end
   end
-  alias_method :to_key, :key
-  alias_method :to_s,   :key
+  alias_method :succ, :next   ## add support for ranges
+
+  include Comparable
+  def <=>(other)
+    ## todo/fix/fix:  check if other is_a?( Season )!!!
+    ##  what to return if other type/class ??
 
-  alias_method :name,   :key
-  alias_method :title,  :key
+    res =  @start_year <=> other.start_year
 
+    ## check special edge case - year season and other e.g.
+    ##    2010 <=> 2010/2011
+    if res == 0 && @end_year != other.end_year
+      res =  @end_year ? 1 : -1   # the season with an end year is greater / wins for now
+    end
 
-  def path( format: nil )
-    ##  todo: find better names for formats - why? why not?:
-    ##    long | archive | decade(?)   =>   1980s/1988-89, 2010s/2017-18, ...
-    ##    short | std(?)   =>   1988-89, 2017-18, ...
+    res
+  end
 
-    ## convert season name to "standard" season name for directory
 
-    if ['l', 'long', 'archive' ].include?( format.to_s )   ## note: allow passing in of symbol to e.g. 'long' or :long
-      if year?   ## e.g. 2000s/2001
-        "%3d0s/%4d" % [@start_year / 10, @start_year]
-      else       ## e.g. 2000s/2001-02
-        "%3d0s/%4d-%02d" % [@start_year / 10, @start_year, @end_year % 100]
-      end
-    else  ## default 'short' format / fallback
-      if year?   ## e.g. 2001
-        "%4d" % @start_year
-      else       ## e.g. 2001-02
-        "%4d-%02d" % [@start_year, @end_year % 100]
+
+  def to_formatted_s( format=:default, sep: '/' )
+    if year?
+      '%d' % @start_year
+    else
+      case format
+      when :default, :short, :s   ## e.g. 1999/00 or 2019/20
+        "%d#{sep}%02d" % [@start_year, @end_year % 100]
+      when :long, :l              ## e.g. 1999/2000 or 2019/2020
+        "%d#{sep}%d" % [@start_year, @end_year]
+      else
+        raise ArgumentError, "[Season.to_s] unsupported format >#{format}<"
       end
     end
-  end # method path
-  alias_method :directory, :path   ## keep "legacy" directory alias - why? why not?
-  alias_method :to_path,   :path
+  end
+  alias_method :to_s, :to_formatted_s
+
+  def key()  to_s( :short ); end
+  alias_method :to_key,  :key
+  alias_method :name,    :key
+  alias_method :title,   :key
 
+  alias_method :inspect, :key  ## note: add inspect debug support change debug output to string!!
+
+
+
+  def to_path( format=:default )
+    case format
+    when :default, :short, :s    ## e.g. 1999-00 or 2019-20
+      to_s( :short, sep: '-' )
+    when :long, :l                ## e.g. 1999-2000 or 2019-2000
+      to_s( :long, sep: '-' )
+    when :archive, :decade, :d    ## e.g. 1990s/1999-00 or 2010s/2019-20
+      "%3d0s/%s" % [@start_year / 10, to_s( :short, sep: '-' )]
+    when :century, :c             ## e.g. 1900s/1990-00 or 2000s/2019-20
+      "%2d00s/%s" % [@start_year / 100, to_s( :short, sep: '-' )]
+    else
+      raise ArgumentError, "[Season.to_path] unsupported format >#{format}<"
+    end
+  end # method to_path
+  alias_method :directory, :to_path   ## keep "legacy" directory alias - why? why not?
+  alias_method :path,      :to_path
 
 end # class Season
 
 
+
+
+module SportDb
+module Import
+  Season = ::Season   ## add a convenience alias
 end  # module Import
 end  # module SportDb

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