sportdb-quick 0.5.3 → 0.7.0

data/lib/sportdb/quick/match_tree/goal.rb

@@ -0,0 +1,67 @@
+module SportDb
+class MatchTree
+
+
+
+class Goal  ### nested (non-freestanding) inside match (match is parent)
+  attr_reader :team,                ## note - 1|2 expected
+              :player,
+              :minute,
+              :offset,
+              :owngoal,            ## true|false
+              :penalty             ## true|false
+
+  ## add alias for player => name - why? why not?
+  alias_method :name, :player
+
+
+  def owngoal?() @owngoal==true; end
+  def penalty?() @penalty==true; end
+  def team1?()   @team == 1; end
+  def team2?()   @team == 2; end
+
+
+  ## note: make score1,score2 optional for now !!!!
+  def initialize( team:,
+                  player:,
+                  minute:,
+                  offset:  nil,
+                  owngoal: false,
+                  penalty: false
+                )
+    @team    = team     # 1|2
+    @player  = player
+    @minute  = minute
+    @offset  = offset
+    @owngoal = owngoal
+    @penalty = penalty
+  end
+
+  def state
+    [@team,
+     @player, @minute, @offset, @owngoal, @penalty
+     ]
+  end
+
+  def ==(o)
+    o.class == self.class && o.state == state
+  end
+
+  def pretty_print( printer )
+    buf = String.new
+    buf << "<Goal"
+    buf << " #{@player} #{@minute}"
+    buf << "+#{@offset}"    if @offset && @offset > 0
+    buf << "'"
+    buf << " (og)"  if @owngoal
+    buf << " (p)"  if @penalty
+    buf << " for #{@team}"     ### team 1 or 2 - use home/away
+    buf << ">"
+
+    printer.text( buf )
+  end
+end # class Goal
+
+
+end # class MatchTree
+end # module SportDb

data/lib/sportdb/quick/match_tree/group.rb

@@ -0,0 +1,25 @@
+module SportDb
+class MatchTree
+
+class Group
+      attr_reader :name, :teams
+
+      def initialize( name:,
+                      teams: )
+        @name   = name
+        @teams  = teams
+      end
+
+      def pretty_print( printer )
+        buf = String.new
+        buf << "<Group #{@name} "
+        buf << @teams.pretty_print_inspect
+        buf << ">"
+
+        printer.text( buf )
+      end
+end  # class Group
+
+
+end # class MatchTree
+end # module SportDb

data/lib/sportdb/quick/match_tree/match.rb

@@ -0,0 +1,247 @@
+##
+# move (simpler) struct version inline to MatchTree for now
+#
+module SportDb
+class MatchTree
+
+
+
+class Match
+
+### note - use inline Score class Match::Score - why? why not?
+##      note - score might internally be an array [2,3]
+##                 or hash { ft:, } etc.
+
+## note - score for now might be
+##            1) array e.g. [1,0] or []
+##            2)  hash  e.g. { ft: [1,0] } etc.
+
+  attr_reader :num,
+              :date,
+              :time,
+              :time_local,
+              :team1,     :team2,      ## todo/fix: use team1_name, team2_name or similar - for compat with db activerecord version? why? why not?
+              :score,
+              :round,     ## todo/fix:  use round_num or similar - for compat with db activerecord version? why? why not?
+              :group,
+              :status,    ## e.g. replay, cancelled, awarded, abadoned, postponed, etc.
+              :ground,       ## (optional) add as text line for now (incl. city, timezone etc.)
+              :att            ## (optional) attendance as (integer) number
+
+
+  attr_accessor :goals      ## todo/fix: make goals like all other attribs!!
+
+  def initialize( **kwargs )
+    @score = []
+    ## @score1,    @score2    = [nil,nil]  ## full time
+    ## @score1i,   @score2i   = [nil,nil]  ## half time (first (i) part)
+    ## @score1et,  @score2et  = [nil,nil]  ## extra time
+    ## @score1p,   @score2p   = [nil,nil]  ## penalty
+    ## @score1agg, @score2agg = [nil,nil]  ## full time (all legs) aggregated
+
+
+    update( **kwargs )  unless kwargs.empty?
+  end
+
+
+  def update( **kwargs )
+    @num      = kwargs[:num]     if kwargs.has_key?( :num )
+
+    ## note: check with has_key?  because value might be nil!!!
+    @date       = kwargs[:date]        if kwargs.has_key?( :date )
+    @time       = kwargs[:time]        if kwargs.has_key?( :time )
+    @time_local = kwargs[:time_local]  if kwargs.has_key?( :time_local )
+
+    ## todo/fix: use team1_name, team2_name or similar - for compat with db activerecord version? why? why not?
+    @team1    = kwargs[:team1]    if kwargs.has_key?( :team1 )
+    @team2    = kwargs[:team2]    if kwargs.has_key?( :team2 )
+
+    ## note: round is a string!!!  e.g. '1', '2' for matchday or 'Final', 'Semi-final', etc.
+    ##   todo: use to_s - why? why not?
+    @round    = kwargs[:round]    if kwargs.has_key?( :round )
+    @group    = kwargs[:group]    if kwargs.has_key?( :group )
+    @status   = kwargs[:status]   if kwargs.has_key?( :status )
+
+    @ground   = kwargs[:ground]   if kwargs.has_key?( :ground )
+    @att      = kwargs[:att]      if kwargs.has_key?( :att )
+
+
+    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!!
+        @score = []    ##  [nil,nil]
+      else
+        ## check if is array - assume "generic" score e.g. 3-2
+        ##     that is, not known if full-time, after extra-time etc.
+        if score.is_a?( Array )
+           @score = score    ## e.g. [3,2]
+        else  ## assume hash
+           @score = score
+           # @score1,    @score2    =    score[:ft]  || []
+           # @score1i,   @score2i   =    score[:ht]  || []
+           # @score1et,  @score2et  =    score[:et]  || []
+           # @score1p,   @score2p   =    score[:p]   || score[:pen] || []
+           # @score1agg, @score2agg =    score[:agg] || []
+        end
+      end
+    end
+      # @score[:ht]   = kwargs[:score_ht]     if kwargs.has_key?( :score_ht )
+      # @score[:et]   = kwargs[:score_et]     if kwargs.has_key?( :score_et )
+      # @score[:p]    = kwargs[:score_p]      if kwargs.has_key?( :score_p )
+      # @score[:agg]  = kwargs[:score_agg]    if kwargs.has_key?( :score_agg )
+
+      ## note: (always) (auto-)convert scores to integers
+      # @score1     = @score1.to_i(10)      if @score1
+      # @score1i    = @score1i.to_i(10)     if @score1i
+      # @score1et   = @score1et.to_i(10)    if @score1et
+      # @score1p    = @score1p.to_i(10)     if @score1p
+      # @score1agg  = @score1agg.to_i(10)   if @score1agg
+
+      # @score2     = @score2.to_i(10)      if @score2
+      # @score2i    = @score2i.to_i(10)     if @score2i
+      # @score2et   = @score2et.to_i(10)    if @score2et
+      # @score2p    = @score2p.to_i(10)     if @score2p
+      # @score2agg  = @score2agg.to_i(10)   if @score2agg
+
+    ## todo/fix:
+    ##  gr-greece/2014-15/G1.csv:
+    ##     G1,10/05/15,Niki Volos,OFI,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
+    ##
+
+    ##  for now score1 and score2 must be present
+    ## if @score1.nil? || @score2.nil?
+    ##  puts "** WARN: missing scores for match:"
+    ##  pp kwargs
+    ##  ## exit 1
+    ## end
+
+
+    self   ## note - MUST return self for chaining
+  end
+
+
+  ####
+  ##  deprecated - use score.to_s and friends - why? why not?
+  # def score_str    # pretty print (full time) scores; convenience method
+  #  "#{@score1}-#{@score2}"
+  # end
+
+  # def scorei_str    # pretty print (half time) scores; convenience method
+  #  "#{@score1i}-#{@score2i}"
+  # end
+
+
+def as_json
+  #####
+  ##  note - use string keys (NOT symbol for data keys)
+  ##            for easier json compatibility
+  data = {}
+
+  ## check round
+  if @round
+    data['round'] = if round.is_a?( Integer )
+                      "Matchday #{@round}"
+                    else ## assume string
+                      @round
+                    end
+  end
+
+
+  data['num'] = @num    if @num
+  if @date
+    ## assume 2020-09-19 date format!!
+    data['date']  = @date.is_a?( String ) ? @date : @date.strftime('%Y-%m-%d')
+
+    data['time']        = @time           if @time
+    data['time_local']  = @time_local     if @time_local
+  end
+
+
+  data['team1'] =  @team1.is_a?( String ) ? @team1 : @team1.name
+
+  ## note - for match status bye  team2 is nil!!!
+  ##           e.g.     Queen's Park       bye
+  ##                    Wanderers          bye
+  ##   todo/check - keep bye as a match - why? why not?
+  ##                      has no date/time & venue & score etc.
+  if @team2
+    data['team2'] =  @team2.is_a?( String ) ? @team2 : @team2.name
+  end
+
+  ## note - score might be
+  ##           1) array e.g. [0,1]
+  ##           2) hash  e.g. { ft: [0,1] } etc.
+  ##  note - w/o (walkout)  do NOT add empty score
+  if @score.is_a?(Hash)
+      # note: make sure hash keys are always strings
+      data['score'] = @score.transform_keys(&:to_s)
+  elsif @score.is_a?(Array)
+      ## note:
+      ##   for now always assume full-time (ft)
+      ##     in future check for score note or such
+      ##      to  use "plain" array or such - why? why not?
+      ## data['score'] = { 'ft' => @score }   if !@score.empty?
+
+      data['score'] = @score     if !@score.empty?
+  end
+
+
+  ## data['score']['ht'] = [@score1i,   @score2i]     if @score1i && @score2i
+  ## data['score']['ft'] = [@score1,    @score2]      if @score1 && @score2
+  ## data['score']['et'] = [@score1et,  @score2et]    if @score1et && @score2et
+  ## data['score']['p']  = [@score1p,   @score2p]     if @score1p && @score2p
+
+
+
+  ### check for goals
+  if @goals && @goals.size > 0
+    data['goals1'] = []
+    data['goals2'] = []
+
+    @goals.each do |goal|
+          node = {}
+          node['name']    = goal.player
+
+          ## note - use a string for minutes for now
+          ##           allows e.g.  45+2 etc. too
+          minute_str  = "#{goal.minute}"
+          minute_str += "+#{goal.offset}"   if goal.offset
+
+          node['minute']  = minute_str
+
+          node['owngoal'] = true         if goal.owngoal
+          node['penalty'] = true         if goal.penalty
+
+          if goal.team == 1
+            data['goals1']  << node
+          else  ## assume 2
+            data['goals2']  << node
+          end
+     end  # each goal
+  end
+
+
+  data['status'] = @status  if @status
+
+  data['group']  = @group   if @group
+
+  if @ground
+       ## note: might be array of string e.g. ['Wembley', 'London']
+       ##
+       ##  todo/check - auto-join to string - why? why not?
+       ##                   e.g.  ['Wembley', 'London']
+       ##                     to   'Wembley, London'
+       ##   note - auto-join geo tree for now
+       data['ground'] = @ground.join(', ')
+  end
+
+  data['attendance'] = @att   if @att
+  data
+end
+end  # class Match
+
+
+
+end # class MatchTree
+end # module SportDb

data/lib/sportdb/quick/match_tree/round.rb

@@ -0,0 +1,36 @@
+
+module SportDb
+class MatchTree
+
+
+  class Round
+      attr_reader   :name, :start_date, :end_date
+
+      def initialize( name:,
+                      start_date: nil,
+                      end_date:   nil,
+                      auto:       true )
+        @name       = name
+        @start_date = start_date
+        @end_date   = end_date
+        @auto       = auto        # auto-created (inline reference/header without proper definition before)
+      end
+
+      def pretty_print( printer )
+        ## todo/check - how to display/format key - use () or not - why? why not?
+        buf = String.new
+        buf << "<Round"
+        buf << " AUTO"    if @auto
+        buf << ": "
+        buf << "#{@name}, "
+        buf << "#{@start_date}"
+        buf << " - #{@end_date}"  if @start_date != @end_date
+        buf << ">"
+
+        printer.text( buf )
+      end
+end  # class Round
+
+
+end # class MatchTree
+end # module SportDb

data/lib/sportdb/quick/match_tree-helpers.rb

@@ -0,0 +1,81 @@
+
+module SportDb
+class MatchTree
+
+  def log( msg )
+    ## append msg to ./logs.txt
+    ##     use ./errors.txt - why? why not?
+    File.open( './logs.txt', 'a:utf-8' ) do |f|
+      f.write( msg )
+      f.write( "\n" )
+    end
+  end
+
+
+### check - rename last_year to running_last_year to make intent clearer - why? why not?
+  def _build_date( m:, d:, y:, yy:, wday:,
+                    start:,
+                    last_year: )
+
+    if m.nil? || d.nil?
+      puts "[debug] !! ERROR - _build_date required month or day missing:"
+      pp [m,d,y,yy,wday,start]
+      exit 1
+    end
+
+
+   ## quick debug hack
+   if m == 2 && d == 29
+      puts "quick check  feb/29 dates"
+      pp [d,m,y]
+      pp start
+   end
+
+
+    ####
+    ## support two digit shortcut for year
+    if yy
+      ###
+      ## for now assume 00,01 to 30 is 2000,2001 to 2030
+      ##   and          31 to 99   is  1931 to 1999
+      y =   yy <= 30 ?  2000+yy : 1900+yy
+    end
+
+
+    if y.nil?   ## try to calculate year
+      if last_year && @last_year   ## use new formula
+         y = @last_year
+      elsif start.nil?
+         puts "!! ERROR - _build_date - year expected for (first) date; cannot infer/guess; sorry"
+         exit 1
+      else  ## fallback to "old" formula - FIX/FIX remove later
+         ## puts "[deprecated] WARN - do NOT use old year (date) auto-complete; add year to first date"
+         y =  if  m > start.month ||
+                 (m == start.month && d >= start.day)
+                  # assume same year as start_at event (e.g. 2013 for 2013/14 season)
+                  start.year
+              else
+                  # assume year+1 as start_at event (e.g. 2014 for 2013/14 season)
+                  start.year+1
+              end
+      end
+    else
+      ### note - reset @start to new date
+      ##            use @last_year
+      if last_year
+        @last_year = y
+        puts "  [debug] _build_date - set running last_year to #{y}"
+      end
+    end
+
+
+      date = Date.new( y,m,d )  ## y,m,d
+
+      ### todo/fix
+      ###  check/validate  wday here
+
+      date
+  end
+
+end  ## class MatchTree
+end  ## module SportDb

data/lib/sportdb/quick/match_tree.rb

@@ -0,0 +1,162 @@
+module SportDb
+
+
+##############################
+## simple (match) parse tree to structs walker/handler/converter
+class MatchTree
+  def self.debug=(value) @@debug = value; end
+  def self.debug?() @@debug ||= false; end  ## note: default is FALSE
+  def debug?()  self.class.debug?; end
+
+  include Logging         ## e.g. logger#debug, logger#info, etc.
+
+
+
+  ##
+  ##  note: allow start(_date) nil
+  ##          if in use (start: nil) years expected on first date!!!
+
+  def initialize( tree, start: nil )
+    @tree    = tree
+    @start   = start
+
+    @errors = []
+  end
+
+  attr_reader :errors
+  def errors?() @errors.size > 0; end
+
+
+  def convert
+    ## note: every (new) read call - resets errors list to empty
+    @errors = []
+    @warns  = []    ## track list of warnings (unmatched lines)  too - why? why not?
+
+    ### todo/fix - FIX/FIX
+    ##     check start year from first date
+    ##    for now (auto-)update - @start with every date that incl. a year!!!
+    @last_year    = nil
+    @last_date    = nil
+    @last_time    = nil
+
+    ## todo/fix - use stack push/pop in the future - why? why not?
+    @last_round   = nil  ##  merge - "top-level" - Round struct
+    @last_round_name1  = nil  ## level 1 - string
+    @last_round_name2  = nil  ## level 2 - string
+    @last_round_name3  = nil  ## level 3 - string
+
+    @last_group   = nil
+
+
+    @teams   = Hash.new(0)   ## track counts (only) for now for (interal) team stats - why? why not?
+    @rounds  = {}
+    @groups  = {}
+    @matches = []
+
+
+    @tree.each do |node|
+       if node.is_a? RaccMatchParser::RoundDef
+        ## todo/fix:  add round definition (w begin n end date)
+        ## todo: do not patch rounds with definition (already assume begin/end date is good)
+        ##  -- how to deal with matches that get rescheduled/postponed?
+          on_round_def( node )
+        elsif node.is_a? RaccMatchParser::GroupDef  ## NB: group goes after round (round may contain group marker too)
+        ### todo: add pipe (|) marker (required)
+          on_group_def( node )
+      elsif node.is_a? RaccMatchParser::RoundOutline
+          on_round_outline( node )
+      elsif node.is_a? RaccMatchParser::DateHeader
+          on_date_header( node )
+      elsif node.is_a? RaccMatchParser::MatchLine
+          on_match_line( node )
+      elsif node.is_a? RaccMatchParser::MatchLineWalkover
+          on_match_line_walkover( node )
+      elsif node.is_a? RaccMatchParser::MatchLineBye
+          on_match_line_bye( node )
+      elsif node.is_a? RaccMatchParser::GoalLine
+          on_goal_line( node )
+      elsif node.is_a?( RaccMatchParser::LineupLine ) ||
+            node.is_a?( RaccMatchParser::RefereeLine )
+           ## skip lineup, referee props for now
+      elsif node.is_a?( RaccMatchParser::Heading1 ) ||
+            node.is_a?( RaccMatchParser::Heading2 ) ||
+            node.is_a?( RaccMatchParser::Heading3 )
+          ###  skip headings (1/2/3) for now
+      elsif node.is_a?( RaccMatchParser::BlankLine )
+          ### skip for now; do nothing
+      else
+        ## report error
+        msg = "!! WARN - unknown node (parse tree type) - #{node.class.name}"
+        puts msg
+        pp node
+
+        log( msg )
+        log( node.pretty_inspect )
+      end
+    end  # tree.each
+
+    ## note - team keys are names and values are "internal" stats e.g. usage count!!
+    ##                      and NOT team/club/nat_team structs!!
+    [@teams.keys, @matches, @rounds.values, @groups.values]
+  end # method convert
+
+
+
+
+  def on_match_line_walkover( node )
+    logger.debug( "on match (w/o): >#{node}<" )
+
+    ## note - w/o (walkover) records NO date/time or ground (or score etc.)
+    ##                 for now only team1/team2 and match status!!
+    ##                  plus inherited round/group
+
+    status = 'walkover'   ## use w/o - why? why not?
+
+    team1 = node.team1
+    team2 = node.team2
+
+    @teams[ team1 ] += 1
+    @teams[ team2 ] += 1
+
+
+    group =  nil
+    group =  @last_group  if @last_group
+
+    round = nil
+    round =  @last_round  if @last_round
+
+    @matches << Match.new( 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)
+                           round:    round ? round.name : nil,  ## note: for now always use string (assume unique canonical name for event)
+                           group:    group ? group.name : nil,  ## note: for now always use string (assume unique canonical name for event)
+                           status:   status )
+    ### todo: cache team lookups in hash?
+  end
+
+  def on_match_line_bye( node )
+    logger.debug( "on match (bye): >#{node}<" )
+
+    ## note - bye    records NO date/time or ground (or score etc.)
+    ##                 for now only team1/team2 and match status!!
+    ##                  plus inherited round/group
+
+    status = 'bye'
+
+    team = node.team
+
+    @teams[ team ] += 1
+
+    group =  nil
+    group =  @last_group  if @last_group
+
+    round = nil
+    round =  @last_round  if @last_round
+
+    @matches << Match.new( team1:    team,  ## note: for now always use mapping value e.g. rec (NOT string e.g. team1.name)
+                           round:    round ? round.name : nil,  ## note: for now always use string (assume unique canonical name for event)
+                           group:    group ? group.name : nil,  ## note: for now always use string (assume unique canonical name for event)
+                           status:   status )
+    ### todo: cache team lookups in hash?
+  end
+end # class MatchTree
+end # module SportDb

data/lib/sportdb/quick/match_tree_on/on_date_header.rb

@@ -0,0 +1,45 @@
+module SportDb
+class MatchTree
+
+
+
+
+  def on_date_header( node )
+    logger.debug( "date header: >#{node}<")
+
+    date = _build_date( m: node.date[:m],
+                        d: node.date[:d],
+                        y: node.date[:y],
+                        yy: node.date[:yy],
+                        wday: node.date[:wday],
+                        start: @start,
+                        last_year: true )
+
+    logger.debug( "    date: #{date} with start: #{@start}")
+
+      @last_date = date   # keep a reference for later use
+      @last_time = nil
+
+      ###  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!!!
+=begin
+      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
+=end
+  end
+
+
+
+end ## class MatchTree
+end ##  module SportDb