sportdb-quick 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d24c209b9b7c40d0f042062a41edf15ebc99a9d6536b06456eb09b365ddc3d11
-  data.tar.gz: d6d4c961906539774027860d4c29a306186f5fba96b049a3a7b9720a9c87498d
+  metadata.gz: d352420645cf51612b5f1c1185f955ac0766d6bb26d84cae1a9e2adc16b2bd1e
+  data.tar.gz: fa83e99ca9c5b86ad8f9a101513d537e52338d03e181809579ef06ad03788cff
 SHA512:
-  metadata.gz: bde8f1b34c6be7c3c68b5c051dcb21c257d721719ea1e1c648b911c504535832c885395492427ca985de7b2b35e2c2b92590cd5e41b5f5f6c7344dcee8e3904a
-  data.tar.gz: a46daab3b1d77e498badaca558c237ad43e81c129641efa88450eabaa05d4b71499b6f2d7af0101a46b976e1ab6b0a152a9b3a6c3d0183faae53b56648814e51
+  metadata.gz: 3f962bf9735b43bf53aa733c7543679f00daa08582862b4c4624fdc96556d148a2bcb2ea7a16f7a9637bae908cd71591bbc6f0b2fd7b7a0124d3106712a9094b
+  data.tar.gz: 818778f17464a71e2e8f7997661a00d4fd0844a5ebffdb22eb7800590f55bf7a7ccbd49aefe7fdd2d325eef84cb4669cdfb1287b5f819d5e5d6aae438c7ae759

data/CHANGELOG.md

@@ -1,4 +1,4 @@
-### 0.3.1
+### 0.5.0
 ### 0.0.1 / 2024-08-27
 
 * Everything is new. First release.

data/Rakefile

@@ -21,7 +21,7 @@ Hoe.spec 'sportdb-quick' do
   self.licenses = ['Public Domain']
 
   self.extra_deps = [
-       ['sportdb-parser',  '>= 0.4.0'],
+       ['sportdb-parser',  '>= 0.5.0'],
        ['sportdb-structs', '>= 0.5.0'],
        ['logutils',        '>= 0.6.1'],
   ]

data/lib/sportdb/quick/match_parser.rb

@@ -88,8 +88,6 @@ class MatchParser    ## simple match parser for team match schedules
     @last_round   = nil
     @last_group   = nil
 
-    ## last_goals - rename to (longer) @last_team_goals or such - why? why not?
-    @last_goals   = 1    ## toggle between 1|2  - hacky (quick & dirty) support for multi-line goals, fix soon!
 
     @teams   = Hash.new(0)   ## track counts (only) for now for (interal) team stats - why? why not?
     @rounds  = {}
@@ -99,12 +97,12 @@ class MatchParser    ## simple match parser for team match schedules
     @warns        = []    ## track list of warnings (unmatched lines)  too - why? why not?
 
 
-
-    @parser = Parser.new
     @tree   = []
 
     attrib_found = false
 
+
+    lines = []
     @lines.each_with_index do |line,i|
 
          if debug?
@@ -134,6 +132,9 @@ class MatchParser    ## simple match parser for team match schedules
             next
           end
 
+          lines << line
+
+=begin
           t, error_messages  =  @parser.parse_with_errors( line )
 
 
@@ -151,71 +152,47 @@ class MatchParser    ## simple match parser for team match schedules
            pp t   if debug?
 
            @tree << t
+=end
     end  # each lines
 
+     txt = lines.join( "\n") + "\n"     
+     parser = RaccMatchParser.new( txt )   ## use own parser instance (not shared) - why? why not?
+     @tree = parser.parse
+     ## pp @tree
+
     ## pp @tree
 
     ## report parse errors here - why? why not?
 
 
 
-    @tree.each do |nodes|
+    @tree.each do |node|
 
-        node_type = nodes[0][0]  ## get node type of first/head node
-
-       if node_type == :round_def
+       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?
-        parse_round_def( nodes )
-       elsif node_type == :group_def  ## NB: group goes after round (round may contain group marker too)
+          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)
-        parse_group_def( nodes )
-
-       elsif node_type == :player  ||
-             node_type == :none  # e.g  [[:none], [:";"], [:player, "Xhaka"],...]
-        ## note - for now goals line MUST start with player!!
-        parse_goals( nodes )
-       else
-        ## try to be liberal/flexible
-        ##  eat-up nodes as we go
-        ##  assume match with group / round header
-        ##   etc. on its own line or not
-
-        ## preprocess possible before match nodes
-
-        while !nodes.empty? do
-             node_type = nodes[0][0]  ## get node type of first/head node
-             if node_type == :round
-                node = nodes.shift   ## eat-up
-                parse_round_header( node )
-             elsif node_type == :leg
-                 node = nodes.shift   ## eat-up
-                 ## ignore (round) leg for now - add later leg - 1|2|3 etc!!!
-                 ##   needs to get added to db/schema too!!!!
-                 ##    add @last_leg = nil  or 1|2|3 etc.
-            elsif node_type == :group
-                ##  -- lets you set group  e.g. Group A etc.
-                node = nodes.shift   ## eat-up
-                parse_group_header( node )
-            elsif node_type == :date
-                node = nodes.shift   ## eat-up
-                parse_date_header( node )
-            ## add time here too - why? why not?
-            ## add skip comma separator here too - why? why not?
-            ##  "slurp-up" in upstream parser?
-            ##  e.g.   round, group  or group, round ?
-            else
-                break
-            end
-        end
-        next if nodes.empty?
-
-        ## rename to try_parse_match - why? why not?
-        parse_match( nodes )
+          on_group_def( node )
+       elsif node.is_a? RaccMatchParser::GroupHeader
+          on_group_header( node )
+       elsif node.is_a? RaccMatchParser::RoundHeader
+          on_round_header( 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::GoalLine
+          on_goal_line( node )
+      else
+        ## report error
+        puts "!! ERROR - unknown node (parse tree type)"
+        pp node
+        exit 1
       end
-
-      end  # tree.each
+    end  # tree.each
 
     ## note - team keys are names and values are "internal" stats!!
     ##                      and NOT team/club/nat_team structs!!
@@ -224,8 +201,8 @@ class MatchParser    ## simple match parser for team match schedules
 
 
 
-  def parse_group_header( node )
-    logger.debug "parsing group header: >#{node}<"
+  def on_group_header( node )
+    logger.debug "on group header: >#{node}<"
 
     # note: group header resets (last) round  (allows, for example):
     #  e.g.
@@ -235,7 +212,7 @@ class MatchParser    ## simple match parser for team match schedules
     #    team1 team2 - match  (will get new auto-matchday! not last round)
     @last_round     = nil
 
-    name = node[1]
+    name = node.name
 
     group = @groups[ name ]
     if group.nil?
@@ -248,8 +225,8 @@ class MatchParser    ## simple match parser for team match schedules
   end
 
 
-  def parse_group_def( nodes )
-    logger.debug "parsing group def: >#{nodes}<"
+  def on_group_def( node )
+    logger.debug "on group def: >#{node}<"
 
    ## e.g
    ##  [:group_def, "Group A"],
@@ -258,26 +235,15 @@ class MatchParser    ## simple match parser for team match schedules
    ##   [:team, "Hungary"],
    ##   [:team, "Switzerland"]
 
-    node = nodes[0]
-    name = node[1]   ## group name
-
-    teams = nodes[1..-1].map do |node|
-                                  if node[0] == :team
-                                       team = node[1]
-                                       @teams[ team ] += 1
-                                       team
-                                  else
-                                     puts "!! PARSE ERROR - only teams expected in group def; got:"
-                                     pp nodes
-                                     exit 1
-                                  end
-                             end
-
+    node.teams.each do |team|
+          @teams[ team ] += 1
+    end
+ 
     ## todo/check/fix: add back group key - why? why not?
-    group = Import::Group.new( name:  name,
-                               teams: teams )
+    group = Import::Group.new( name:  node.name,
+                               teams: node.teams )
 
-    @groups[ name ] = group
+    @groups[ node.name ] = group
   end
 
 
@@ -307,37 +273,35 @@ class MatchParser    ## simple match parser for team match schedules
       Date.new( y,m,d )  ## y,m,d
   end
 
-  def parse_round_def( nodes )
-    logger.debug "parsing round def: >#{nodes}<"
+
+  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"]]
 
-    node = nodes[0]
-    name  = node[1]
+    name  = node.name
     # NB: use extracted round name for knockout check
     # knockout_flag = is_knockout_round?( name )
 
-    node = nodes[1]
-    node_type = node[0]
-    if node_type == :date
-        start_date = end_date = _build_date( m: node[2][:m],
-                                             d: node[2][:d],
-                                             y: node[2][:y],
+    if node.date
+        start_date = end_date = _build_date( m: node.date[:m],
+                                             d: node.date[:d],
+                                             y: node.date[:y],
                                               start: @start)
-    elsif node_type == :duration
-      start_date  = _build_date( m: node[2][:start][:m],
-                                 d: node[2][:start][:d],
-                                 y: node[2][:start][:y],
+    elsif node.duration
+      start_date  = _build_date( m: node.duration[:start][:m],
+                                 d: node.duration[:start][:d],
+                                 y: node.duration[:start][:y],
                                    start: @start)
-      end_date    = _build_date( m: node[2][:end][:m],
-                                 d: node[2][:end][:d],
-                                 y: node[2][:end][:y],
+      end_date    = _build_date( m: node.duration[:end][:m],
+                                 d: node.duration[:end][:d],
+                                 y: node.duration[:end][:y],
                                    start: @start)
     else
        puts "!! PARSE ERROR - expected date or duration for round def; got:"
-       pp nodes
+       pp node
        exit 1
     end
 
@@ -375,10 +339,11 @@ class MatchParser    ## simple match parser for team match schedules
   end
 
 
-  def parse_round_header( node )
-    logger.debug "parsing round header: >#{node}<"
+  def on_round_header( node )
+    logger.debug "on round header: >#{node}<"
 
-    name = node[1]
+    name = node.names[0]    ## ignore more names for now
+                           ## fix later - fix more names!!!
 
     # name = name.sub( ROUND_EXTRA_WORDS_RE, '' )
     # name = name.strip
@@ -399,12 +364,12 @@ class MatchParser    ## simple match parser for team match schedules
     ##   reset date/time e.g. @last_date = nil !!!!
   end
 
-  def parse_date_header( node )
+  def on_date_header( node )
     logger.debug( "date header: >#{node}<")
 
-    date = _build_date( m: node[2][:m],
-                        d: node[2][:d],
-                        y: node[2][:y],
+    date = _build_date( m: node.date[:m],
+                        d: node.date[:d],
+                        y: node.date[:y],
                         start: @start )
 
     logger.debug( "    date: #{date} with start: #{@start}")
@@ -431,93 +396,17 @@ class MatchParser    ## simple match parser for team match schedules
 =end
   end
 
-  def parse_minutes( nodes )
-    ## parse goals by player
-    ##   may have multiple minutes!!
-    goals = []
-
-    node = nodes.shift  ## get player
-    name = node[1]
-
-    loop do
-      goal = {}
-      goal[:name]  = name
-
-      node_type = nodes[0][0]
-      if node_type != :minute
-        puts "!! PARSE ERROR - minute expected to follow player (in goal); got #{node_type}:"
-        pp nodes
-        exit 1
-      end
-
-      node = nodes.shift
-      goal[:minute] =  node[2][:m]
-      goal[:offset] =  node[2][:offset]  if node[2][:offset]
-
-      ## check for own goal or penalty or such
-      if !nodes.empty?
-        node_type = nodes[0][0]
-        if node_type == :og
-         nodes.shift
-         goal[:og] = true
-        elsif node_type == :pen
-         nodes.shift
-         goal[:pen] = true
-        else
-          # do nothing
-        end
-      end
-
-      goals << goal
-
-      ## check if another minute ahead; otherwise break
-      break  if nodes.empty?
-
-      node_type = nodes[0][0]
 
-      ## Kane 39', 62', 67'
-      ## consume/eat-up (optional?) commas
-      if node_type == :','
-        nodes.shift
-        node_type = nodes[0][0]
-      end
+  def on_goal_line( node )
+    logger.debug "on goal line: >#{node}<"
 
-      break  if node_type != :minute
-    end
-
-
-    goals
-  end
-
-
-  def parse_goals( nodes )
-    logger.debug "parse goals: >#{nodes}<"
-
-    goals1 = []
-    goals2 = []
-
-    while !nodes.empty?
-        node_type = nodes[0][0]
-        if node_type == :player
-           more_goals = parse_minutes( nodes )
-           ## hacky multi-line support for goals
-           ##   using last_goal (1|2)
-           @last_goals == 2 ?  goals2 += more_goals :
-                               goals1 += more_goals
-        elsif node_type == :';'   ## team separator
-            nodes.shift  # eat-up
-            @last_goals = 2
-        elsif node_type == :none
-            nodes.shift  # eat-up
-        else
-          puts "!! PARSE ERROR - unexpected node type in goals;; got #{node_type}:"
-          pp nodes
-          exit 1
-        end
-    end
+    goals1 = node.goals1
+    goals2 = node.goals2
 
+   
     pp [goals1,goals2]     if debug?
 
+
 ## wrap in struct andd add/append to match
 =begin
 class GoalStruct
@@ -532,26 +421,30 @@ class GoalStruct
 
     goals = []
     goals1.each do |rec|
-      goal = Import::Goal.new(
-                  player: rec[:name],
+      rec.minutes.each do |minute|
+        goal = Import::Goal.new(
+                  player: rec.player,
                   team:   1,
-                  minute:  rec[:minute],
-                  offset:  rec[:offset],
-                  penalty: rec[:pen] || false, #  note: pass along/use false NOT nil
-                  owngoal: rec[:og] || false
+                  minute:  minute.m,
+                  offset:  minute.offset,
+                  penalty: minute.pen || false, #  note: pass along/use false NOT nil
+                  owngoal: minute.og || false
                 )
-      goals << goal
+        goals << goal
+      end
     end
     goals2.each do |rec|
-      goal = Import::Goal.new(
-                  player: rec[:name],
+      rec.minutes.each do |minute|
+        goal = Import::Goal.new(
+                  player: rec.player,
                   team:   2,
-                  minute:  rec[:minute],
-                  offset:  rec[:offset],
-                  penalty: rec[:pen] || false, #  note: pass along/use false NOT nil
-                  owngoal: rec[:og] || false
+                  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?
@@ -569,90 +462,65 @@ class GoalStruct
   end
 
 
-  def parse_match( nodes )
-    logger.debug( "parse match: >#{nodes}<" )
+  def on_match_line( node )
+    logger.debug( "on match: >#{node}<" )
 
     ## collect (possible) nodes by type
     num    = nil
+    num = node.ord   if node.ord
+        
     date   = nil
-    time   = nil
-    teams  = []
+    date =  _build_date( m: node.date[:m],
+                         d: node.date[:d],
+                         y: node.date[:y],
+                         start: @start )   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   =  ('%d:%02d' % [node.time[:h], node.time[:m]])  if node.time
+ 
+
+    ### 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
+    if node.score
+      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
+      score = Score.new( *values )
+    end
+ 
     more   = []
+
     status = nil
+    ## if node_type == :status  # e.g. awarded, canceled, postponed, etc.
+    ##  status = node[1]
+
 
-    while !nodes.empty?
-        node = nodes.shift
-        node_type = node[0]
-
-        if node_type == :num
-            num = node[1]
-        elsif node_type == :date
-            ## note: date wipes out/clear time
-            ##   time MUST always come after date
-            time = nil
-            date = _build_date( m: node[2][:m],
-                                d: node[2][:d],
-                                y: node[2][:y],
-                                start: @start )
-        elsif node_type == :time
-            ## 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 = '%d:%02d' % [node[2][:h], node[2][:m]]
-        elsif node_type == :team
-            teams << node[1]
-        elsif node_type == :score
-            ### 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?
-             ht = node[2][:ht] || [nil,nil]
-             ft = node[2][:ft] || [nil,nil]
-             et = node[2][:et] || [nil,nil]
-             p  = node[2][:p]  || [nil,nil]
-             values = [*ht, *ft, *et, *p]
-             ## pp values
-
-             score = Score.new( *values )
-             ## pp score
-        elsif node_type == :status  # e.g. awarded, canceled, postponed, etc.
-             status = node[1]
-        elsif node_type == :vs
-           ## skip; do nothing
-##
+ #
 ## 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?
-
-        elsif node_type == :'@' ||
-              node_type == :',' ||
-              node_type == :geo ||
-              node_type == :timezone
+#
+#        elsif node_type == :'@' ||
+#              node_type == :',' ||
+#              node_type == :geo ||
+#              node_type == :timezone
          ## e.g.
          ## [:"@"], [:geo, "Stade de France"], [:","], [:geo, "Saint-Denis"]]
          ## [:"@"], [:geo, "Arena de São Paulo"], [:","], [:geo, "São Paulo"], [:timezone, "(UTC-3)"]
-            more << node[1]  if node_type == :geo
-        else
-            puts "!! PARSE ERROR - unexpected node type #{node_type} in match line; got:"
-            pp node
-            ## exit 1
-            @errors << ["PARSE ERROR - unexpected node type #{node_type} in match line; got: #{node.inspect}"]
-            return
-        end
-    end
-
+#            more << node[1]  if node_type == :geo
+  
 
-    if teams.size != 2
-      puts "!! PARSE ERROR - expected two teams; got #{teams.size}:"
-      pp teams
-      ## exit 1
-      @errors << ["PARSE ERROR - expected two teams; got #{teams.size}: #{teams.inspect}"]
-      return
-    end
-
-    team1 = teams[0]
-    team2 = teams[1]
+    team1 = node.team1
+    team2 = node.team2
 
     @teams[ team1 ] += 1
     @teams[ team2 ] += 1
@@ -738,10 +606,6 @@ class GoalStruct
                                    status:  status,
                                    ground:  ground )
     ### todo: cache team lookups in hash?
-
-    ## hacky goals support
-    ### reset/toggle 1/2
-    @last_goals = 1
   end
 end # class MatchParser
 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 = 3
-  PATCH = 1
+  MINOR = 5
+  PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sportdb-quick
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-02 00:00:00.000000000 Z
+date: 2025-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sportdb-parser
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: sportdb-structs
   requirement: !ruby/object:Gem::Requirement