sportdb-quick 0.5.3 → 0.7.0

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

@@ -0,0 +1,87 @@
+module SportDb
+class MatchTree
+
+
+  def on_goal_line( node )
+    logger.debug "on goal line: >#{node}<"
+
+    goals1 = node.goals1
+    goals2 = node.goals2
+
+
+    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
+
+
+
+    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 )
+    logger.debug "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 )
+    logger.debug( "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 )
+    logger.debug "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
+
+
+
+
+    logger.debug "    start_date: #{start_date}"
+    logger.debug "    end_date:   #{end_date}"
+    logger.debug "    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 )
+    logger.debug "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 )
+        logger.debug "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

data/lib/sportdb/quick/quick_match_reader.rb

@@ -24,7 +24,10 @@ class QuickMatchReader
 
   def initialize( txt )
     @errors = []
-    @outline = QuickLeagueOutline.parse( txt )
+    @txt    = txt
+
+    @league_name = ''     
+    @matches     = []
   end
 
   attr_reader :errors
@@ -35,59 +38,82 @@ class QuickMatchReader
   #  helpers get matches & more after parse; all stored in data
   #
   ## change/rename to event - why? why not?
-  def league_name
-     league = @data.keys[0]
-     season = @data[ league ].keys[0]
-
-     "#{league} #{season}"
-  end
-
-  def matches
-    league = @data.keys[0]
-    season = @data[ league ].keys[0]
-    @data[league][season]
-  end
-
+  ##  note - may or may not include season
+  def league_name() @league_name; end
+  def matches() @matches; end
+  
+
+  ##  try to find season in heading
+  ##  e.g. Österr. Bundesliga 2015/16  or 2015-16
+  ##       World Cup 2018 or  2018 World Cup etc.
+  SEASON_IN_HEADING_RE =  %r{
+                \b
+              (?<season>\d{4}
+                 (?:[\/-]\d{1,4})?     ## optional 2nd year in season
+                 )\b
+                   }x
 
 
   def parse
     ## note: every (new) read call - resets errors list to empty
     @errors = []
+    
+    @league_name = ''     
+    @matches     = []
+  
+
+    ## note - source file MUST always start with heading 1 for now
+    tree   = []
+    parser = RaccMatchParser.new( @txt, debug: debug? )   ## use own parser instance (not shared) - why? why not?
+    tree = parser.parse
+
+    
+##
+## !! (QUICK) PARSE ERROR - source MUST start with Heading1; got 34 nodes:
+## [<BlankLine>,
+##  <BlankLine>,
+## <Heading1 World Cup 1930>,
+
+      ## remove leading BlankLines if any!!
+      while tree[0].is_a? RaccMatchParser::BlankLine
+          tree.shift  ## remove (leading) blank line from parse tree 
+      end
 
-    @data = {}   # return data hash with leagues
-                 #    and seasons
-                 #   for now merge stage into matches
 
-    @outline.each_sec do |sec|   ## sec(tion)s
-      ### move season parse into outline upstream - why? why not?
-      season = Season.parse( sec.season )   ## convert (str) to season obj!!!
-      league = sec.league
-      stage  = sec.stage
-      lines  = sec.lines
+    if tree[0].is_a? RaccMatchParser::Heading1
+         ## try to get league and season
+         @league_name = tree[0].text
+    else  
+        ### report error - source MUST start with heading 1
+       puts "!! (QUICK) PARSE ERROR - source MUST start with Heading1; got #{tree.size} nodes:"
+       pp tree
+       exit
+    end
 
+      ## todo/fix
+      ##  make season optional
+      m = SEASON_IN_HEADING_RE.match( @league_name )
+      if m.nil?
+        puts "!! (QUICK) PARSE ERROR - no season found in Heading1 >#{@league_name}; sorry"
+        exit 
+      end
+      season = Season.parse( m[:season] )   ## convert (str) to season obj!!!
       start =  if season.year?
                   Date.new( season.start_year, 1, 1 )
                 else
                   Date.new( season.start_year, 7, 1 )
                 end
 
-     # if debug?
-     #   puts "  (sec) lines:"
-     #   pp lines
-     # end
-
-      ### note - skip section if no lines !!!!!
-      next if lines.empty?     ## or use lines.size == 0
-
 
-      parser = MatchParser.new( lines,
-                                start )   ## note: keep season start_at date for now (no need for more specific stage date need for now)
+    ############
+    ### "walk" tree to get structs (matches/teams/etc.)
+    conv = MatchTree.new( tree, start: start )
+    
+    auto_conf_teams, matches, rounds, groups = conv.convert
 
-      auto_conf_teams,  matches, rounds, groups = parser.parse
 
       ## auto-add "upstream" errors from parser
-      @errors += parser.errors  if parser.errors?
-
+      ## @errors += parser.errors  if parser.errors?
 
       if debug?
         puts ">>> #{auto_conf_teams.size} teams:"
@@ -100,40 +126,11 @@ class QuickMatchReader
         pp groups
       end
 
-      ## note: pass along stage (if present): stage  - optional from heading!!!!
-      if stage
-        matches.each do |match|
-          match = match.update( stage: stage )
-        end
-      end
-
-      @data[ league ] ||= {}
-      @data[ league ][ season.key ] ||= []
 
-      @data[ league ][ season.key ] += matches
+      @matches = matches
       ## note - skip teams, rounds, and groups for now
-    end
-
-## check - only one league and one season
-##             allowed in quick style
-
-
-    leagues = @data.keys
-    if leagues.size != 1
-        puts "!! (QUICK) PARSE ERROR - expected one league only; got #{leagues.size}:"
-        pp leagues
-        exit 1
-    end
-
-    seasons = @data[ leagues[0] ].keys
-    if seasons.size != 1
-        puts "!! (QUICK) PARSE ERROR - expected one #{leagues[0]} season only; got #{seasons.size}:"
-        pp seasons
-        exit 1
-    end
-
-    @data[ leagues[0] ][ seasons[0] ]
-  end # method parse
+      @matches
+end # method parse
 
 end # class QuickMatchReader
 end # module SportDb

data/lib/sportdb/quick/version.rb

@@ -3,8 +3,8 @@ module SportDb
   module Module
     module Quick
   MAJOR = 0    ## todo: namespace inside version or something - why? why not??
-  MINOR = 5
-  PATCH = 3
+  MINOR = 7
+  PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version