sportdb-quick 0.5.3 → 0.8.0

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

@@ -0,0 +1,45 @@
+module SportDb
+class MatchTree
+
+
+
+
+  def on_date_header( node )
+    _trace( "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 )
+
+    _trace( "    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
+           _trace( "!! 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

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

@@ -0,0 +1,95 @@
+module SportDb
+class MatchTree
+
+
+  def on_goal_line( node )
+    _trace( "on goal line: >#{node}<" )
+
+
+     if node.goals[0].is_a?( Array )
+       goals1, goals2 = node.goals[0], node.goals[1]
+     else
+       goals1 = node.goals
+       goals2 = []
+     end
+
+
+    pp [goals1,goals2]     if debug?
+
+
+## special rule
+##    if goals 2 empty check if score for team 1 is zero
+##                           and team 2 is NOT zero than
+##                                make goals1 goald2!!
+##   e.g. Norway 0-1  Austria
+##                   (Hof 32)
+
+   if goals2.empty? && !goals1.empty?
+
+     match = @matches[-1]
+
+     ##
+     ## todo/fix
+     ##   move upstream
+     ##    use score1_zero? or such - why? why not?
+     if (match.score.is_a?(Array) && match.score[0] == 0 ) ||
+        (match.score.is_a?(Hash)  && match.score[:et] && match.score[:et][0] == 0) ||
+        (match.score.is_a?(Hash)  && match.score[:et].nil? &&
+                                     match.score[:ft] && match.score[:ft][0] == 0)
+        ## "parallel assignment (or multiple assignment") - swap values in single line
+        goals2, goals1 = goals1, goals2
+     end
+   end
+
+
+
+   ##
+   ## todo/fix - sort goals by minute (+offset) !!!
+
+    goals = []
+
+    goals1.each do |rec|
+      rec.minutes.each do |minute|
+        goal = Goal.new(
+                  player: rec.player,
+                  team:   1,
+                  minute:  minute.m,
+                  offset:  minute.offset,
+                  penalty: minute.pen || false, #  note: pass along/use false NOT nil
+                  owngoal: minute.og || false
+                )
+        goals << goal
+      end
+    end
+
+    goals2.each do |rec|
+      rec.minutes.each do |minute|
+        goal = Goal.new(
+                  player: rec.player,
+                  team:   2,
+                  minute:  minute.m,
+                  offset:  minute.offset,
+                  penalty: minute.pen || false, #  note: pass along/use false NOT nil
+                  owngoal: minute.og || false
+                )
+      goals << goal
+      end
+    end
+
+    pp goals   if debug?
+
+    ## quick & dirty - auto add goals to last match
+    ##   note - for hacky (quick& dirty) multi-line support
+    ##     always append for now
+    match = @matches[-1]
+    match.goals ||= []
+    match.goals += goals
+
+    ## todo/fix
+    ##   sort by minute
+    ##    PLUS auto-fill score1,score2 - why? why not?
+  end
+
+
+end ## class MatchTree
+end ##  module SportDb

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

@@ -0,0 +1,27 @@
+module SportDb
+class MatchTree
+
+
+  def on_group_def( node )
+    _trace( "on group def: >#{node}<" )
+
+   ## e.g
+   ##  [:group_def, "Group A"],
+   ##   [:team, "Germany"],
+   ##   [:team, "Scotland"],
+   ##   [:team, "Hungary"],
+   ##   [:team, "Switzerland"]
+
+    node.teams.each do |team|
+          @teams[ team ] += 1
+    end
+
+    group = Group.new( name:  node.name,
+                       teams: node.teams )
+
+    @groups[ node.name ] = group
+  end
+
+
+end ## class MatchTree
+end ##  module SportDb

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

@@ -0,0 +1,195 @@
+module SportDb
+class MatchTree
+
+
+
+  def on_match_line( node )
+    _trace( "on match: >#{node}<" )
+
+    ## collect (possible) nodes by type
+    num    = nil
+    num = node.num   if node.num
+
+    date   = nil
+    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 )   if node.date
+
+    ## note - there's no time (-only) type in ruby
+    ##  use string (e.g. '14:56', '1:44')
+    ##   use   01:44 or 1:44 ?
+    ##  check for 0:00 or 24:00  possible?
+    time   = nil
+    if node.time
+       time   =  ('%d:%02d' % [node.time[:h], node.time[:m]])
+       ## check for timezone
+       time += " #{node.time[:timezone]}"   if node.time[:timezone]
+    end
+
+
+
+    ## todo/fix -
+    ##   keep  time & time_local as pairs for @last_time/@last_time_local
+    ##    - check for timezone
+    ##      incl. timezone in time (string) - why? why not?
+    time_local = nil
+    if node.time_local
+      time_local  =  ('%d:%02d' % [node.time_local[:h], node.time_local[:m]])
+      time_local +=  " #{node.time_local[:timezone]}"   if node.time_local[:timezone]
+    end
+
+
+    ### todo/fix
+    ##    add keywords (e.g. ht, ft or such) to Score.new - why? why not?
+    ##     or use new Score.build( ht:, ft:, ) or such - why? why not?
+    ## pp score
+    score  = nil
+    score = node.score   if node.score
+
+    ## if node.score.is_a?(Array)
+    ##    ## assume "undefined" score
+    ##    score = node.score
+    ##  else  ## (default) assume Hash
+    ##     # ht = node.score[:ht] || [nil,nil]
+    ##     # ft = node.score[:ft] || [nil,nil]
+    ##     # et = node.score[:et] || [nil,nil]
+    ##     # p  = node.score[:p]  || [nil,nil]
+    ##     # values = [*ht, *ft, *et, *p]
+    ##     # pp values
+    ##     ## pp node.score
+    ##    score = node.score
+    ##  end
+    ## end
+
+
+    status = nil
+    status =  node.status   if node.status   ### assume text for now
+    ## if node_type == :status  # e.g. awarded, canceled, postponed, etc.
+    ##  status = node[1]
+    #
+    ## todo - add    ## 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?
+
+
+
+    team1 = node.team1
+    team2 = node.team2
+
+    @teams[ team1 ] += 1
+    @teams[ team2 ] += 1
+
+
+    if node.header ## note - date/time for matches (w/ header) CANNOT get inherited!!
+       @last_date = nil
+       @last_time = nil
+    else  ## no (match header), use date/time inheritance rules
+      ###
+      # check if date found?
+      #   note: ruby falsey is nil & false only (not 0 or empty array etc.)
+      if date
+        ### check: use date_v2 if present? why? why not?
+        @last_date = date    # keep a reference for later use
+        @last_time = nil
+        # @last_time = nil
+      else
+        date = @last_date    # no date found; (re)use last seen date
+      end
+
+      if time
+        @last_time = time
+      else
+        time = @last_time
+      end
+    end
+
+
+
+    group =  nil
+    group =  @last_group  if @last_group
+
+    round = nil
+    round =  @last_round  if @last_round
+
+
+    ### try auto-fill round
+    ##    find (first) matching round by date if rounds / matchdays defined
+    ##   if not rounds / matchdays defined - YES, allow matches WITHOUT rounds!!!
+    if date && round.nil?
+        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?
+            ## todo/fix - issue a warning (do NOT stop)
+            puts "!! PARSE ERROR - no matching round found for match date:"
+            pp date
+            exit 1
+          end
+        end
+    end
+
+
+    ## todo/check: scores are integers or strings?
+
+    ## todo/check: pass along round and group refs or just string (canonical names) - why? why not?
+
+    ## split date in date & time if DateTime
+=begin
+    time_str = nil
+    date_str = nil
+    if date.is_a?( DateTime )
+        date_str = date.strftime('%Y-%m-%d')
+        time_str = date.strftime('%H:%M')
+    elsif date.is_a?( Date )
+        date_str = date.strftime('%Y-%m-%d')
+    else  # assume date is nil
+    end
+=end
+
+    time_str       = nil
+    time_local_str = nil
+    date_str       = nil
+
+    date_str       = date.strftime('%Y-%m-%d')  if date
+    time_str       = time           if date && time
+    time_local_str = time_local     if date && time_local
+
+
+
+    ground   = nil
+    ground = node.geo  if node.geo
+
+    ## attendance
+    att = nil
+    att =  node.att   if node.att
+
+
+    @matches << Match.new( num:        num,
+                           date:       date_str,
+                           time:       time_str,
+                           time_local: time_local_str,
+                           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)
+                           score:    score,
+                           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,
+                           ground:   ground,
+                           att:      att )
+    ### todo: cache team lookups in hash?
+  end
+
+
+end ## class MatchTree
+end ##  module SportDb

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

@@ -0,0 +1,85 @@
+module SportDb
+class MatchTree
+
+
+  def on_round_def( node )
+    _trace( "on round def: >#{node}<" )
+
+    ## e.g. [[:round_def, "Matchday 1"], [:duration, "Fri Jun 14 - Tue Jun 18"]]
+    ##      [[:round_def, "Matchday 2"], [:duration, "Wed Jun 19 - Sat Jun 22"]]
+    ##      [[:round_def, "Matchday 3"], [:duration, "Sun Jun 23 - Wed Jun 26"]]
+
+    name  = node.name
+    # NB: use extracted round name for knockout check
+    # knockout_flag = is_knockout_round?( name )
+
+
+    ##
+    ##  note - do NOT update @last_year on round def dates!!
+    ##              only update for running dates in matches!!
+
+    if node.date
+        start_date = end_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: false )
+    elsif node.duration
+      ## reuse year in start date e.g. July 26-27 1930
+      ##                               July 26 [1930], [July] 27 1930
+      start_date  = _build_date( m: node.duration[:start][:m],
+                                 d: node.duration[:start][:d],
+                                 y: node.duration[:start][:y]   || node.duration[:end][:y],
+                                 yy: node.duration[:start][:yy] || node.duration[:end][:yy],
+                                 wday: node.duration[:start][:wday],
+                                   start: @start,
+                                   last_year: false )
+
+      ## reuse month in end date e.g.  July 26-27
+      ##                               July 26, [July] 27
+      end_date    = _build_date( m: node.duration[:end][:m] || node.duration[:start][:m],
+                                 d: node.duration[:end][:d],
+                                 y: node.duration[:end][:y],
+                                 yy: node.duration[:end][:yy],
+                                 wday: node.duration[:end][:wday],
+                                   start: @start,
+                                   last_year: false )
+    else
+       puts "!! PARSE ERROR - expected date or duration for round def; got:"
+       pp node
+       exit 1
+    end
+
+    # note: - NOT needed; start_at and end_at are saved as date only (NOT datetime)
+    #  set hours,minutes,secs to beginning and end of day (do NOT use default 12.00)
+    #   e.g. use 00.00 and 23.59
+    # start_at = start_at.beginning_of_day
+    # end_at   = end_at.end_of_day
+
+    # note: make sure start_at/end_at is date only (e.g. use start_at.to_date)
+    #   sqlite3 saves datetime in date field as datetime, for example (will break date compares later!)
+
+    # note - _build_date always returns Date for now - no longer needed!!
+    # start_date = start_date.to_date
+    #  end_date   = end_date.to_date
+
+
+
+
+    _trace( "    start_date: #{start_date}" )
+    _trace( "    end_date:   #{end_date}" )
+    _trace( "    name:    >#{name}<" )
+
+    round = Round.new( name:       name,
+                       start_date: start_date,
+                       end_date:   end_date,
+                       auto:       false )
+
+    @rounds[ name ] = round
+  end
+
+
+end ## class MatchTree
+end ##  module SportDb

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

@@ -0,0 +1,104 @@
+module SportDb
+class MatchTree
+
+
+
+  def on_round_outline( node )
+    _trace( "on round outline: >#{node}<" )
+
+    ## always reset dates - why? why not?
+    ##    note - needs last_date for year
+    ##         track last_year with extra variable
+
+    name  = node.outline
+    level = node.level
+
+
+      ####
+      # check for "old" group header in ("automagic") round outline for now
+      ##
+      ##  todo/fix - use only names from group def for lookup/is_group match!!!
+      ##    do NOT use (generic) regex!!
+      if level == 1 && _is_group?( name )
+        _trace( "on group header: >#{node}<" )
+
+        group = @groups[ name ]
+
+        if group
+          # set group for matches
+          @last_group = group
+            # note: group header resets (last) round  (allows, for example):
+            #  e.g.
+            #  Group Playoffs/Replays       -- round header
+            #    team1 team2                -- match
+            #  Group B                      -- group header
+            #    team1 team2 - match  (will get new auto-matchday! not last round)
+          @last_round     = nil
+          return  ## note - return here; do NOT fall through to std round processing!
+        else
+          puts "!! WARN - no group def found for >#{name}<; will use a (plain) round"
+        end
+      end  ## is_group?
+
+
+      ##
+      ## todo/fix - also reset round name levels on heading 1/2/3 etc.
+      ##                why? why not?
+
+      if level == 1
+        @last_round_name1 = name
+        @last_round_name2 = nil
+        @last_round_name3 = nil
+      elsif level == 2
+        @last_round_name2 = name
+        @last_round_name3 = nil
+        name = [@last_round_name1, name].join( ', ' )
+      elsif level == 3
+        @last_round_name3 == name
+        name = [@last_round_name1, @last_round_name2, name].join( ', ')
+      else
+         puts "!! ERROR - unsupported round outline level #{level}; use 1-3 - sorry"
+         exit 1
+      end
+
+
+      round = @rounds[ name ]
+      if round.nil?    ## auto-add / create if missing
+        round = Round.new( name: name )
+        @rounds[ name ] = round
+      end
+
+      @last_round = round
+      @last_group = nil   # note: always reset group to no group - why? why not?
+
+      ## todo/fix/check
+      ##  make round a scope for date(time) - why? why not?
+      ##   reset date/time e.g. @last_date = nil !!!!
+  end
+
+
+
+###
+##  helpers
+
+##
+##  note - do NOT match group phase or group playoff or such
+##            for now only works for group a,b,c or group 1, group 2, etc.
+
+  GROUP_RE = %r{\A
+                    Group [ ] (?:
+                                   [a-z]
+                                 | \d+
+                               )
+              \z}ix
+
+
+  def _is_group?( text )
+    ## use regex for match
+    GROUP_RE.match?( text )
+  end
+
+
+
+end ## class MatchTree
+end ##  module SportDb