sportdb-quick 0.3.1 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d24c209b9b7c40d0f042062a41edf15ebc99a9d6536b06456eb09b365ddc3d11
-  data.tar.gz: d6d4c961906539774027860d4c29a306186f5fba96b049a3a7b9720a9c87498d
+  metadata.gz: 71f76e171de23b5062c30f432d5fece7bcb2cb0e7283d658dcf8ff79aefb6aa3
+  data.tar.gz: 74fc864d5c4b9ca42270abd3fdb941cebdb9857c072c7515e7e422829c018891
 SHA512:
-  metadata.gz: bde8f1b34c6be7c3c68b5c051dcb21c257d721719ea1e1c648b911c504535832c885395492427ca985de7b2b35e2c2b92590cd5e41b5f5f6c7344dcee8e3904a
-  data.tar.gz: a46daab3b1d77e498badaca558c237ad43e81c129641efa88450eabaa05d4b71499b6f2d7af0101a46b976e1ab6b0a152a9b3a6c3d0183faae53b56648814e51
+  metadata.gz: 83fa67d7c4bbd0952ad9e02f93be65c488bd728b52f8a9a1159ab42bd299b6b9b37ff5e75573582ef4a7f20ebef1d97ff7da111334dd5f6b4b71bf4793ea84af
+  data.tar.gz: 9f832375e9d03fe1de7d83d14083428d0f3eda704645cf585449d13cf7929030552075549d68e0d91892be0d66c4bf92fbc41a2403cecee362025ed2b2058513

data/CHANGELOG.md

@@ -1,4 +1,4 @@
-### 0.3.1
+### 0.5.1
 ### 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.4'],
        ['sportdb-structs', '>= 0.5.0'],
        ['logutils',        '>= 0.6.1'],
   ]

data/lib/sportdb/quick/match_parser.rb

@@ -9,7 +9,19 @@ class MatchParser    ## simple match parser for team match schedules
 
   include Logging         ## e.g. logger#debug, logger#info, etc.
 
+  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
+ 
+
+
 
+  
   def self.parse( lines, start: )
     ##  todo/fix: add support for txt and lines
     ##    check if lines_or_txt is an array or just a string
@@ -26,8 +38,8 @@ class MatchParser    ## simple match parser for team match schedules
     lines = []
     txt.each_line do |line|    ## preprocess
        line = line.strip
-
        next if line.empty? || line.start_with?('#')   ###  skip empty lines and comments
+       
        line = line.sub( /#.*/, '' ).strip             ###  cut-off end-of line comments too
        lines << line
     end
@@ -35,29 +47,7 @@ class MatchParser    ## simple match parser for team match schedules
   end
 
 
-  ## note:  colon (:) MUST be followed by one (or more) spaces
-  ##      make sure mon feb 12 18:10 will not match
-  ##        allow 1. FC Köln etc.
-  ##               Mainz 05:
-  ##           limit to 30 chars max
-  ##          only allow  chars incl. intl buut (NOT ()[]/;)
-  ##
-  ##   Group A:
-  ##   Group B:   - remove colon
-  ##    or lookup first
-
-  ATTRIB_RE = %r{^
-                   [ ]*?     # slurp leading spaces
-                (?<key>[^:|\]\[()\/; -]
-                       [^:|\]\[()\/;]{0,30}
-                 )
-                   [ ]*?     # slurp trailing spaces
-                   :[ ]+
-                (?<value>.+)
-                    [ ]*?   # slurp trailing spaces
-                   $
-                }ix
-
+ 
   #
   # todo/fix: change start to start: too!!!
   #       might be optional in the future!! - why? why not?
@@ -88,8 +78,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,41 +87,23 @@ 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.each_with_index do |line,i|
 
+       ## flatten lines
+       txt  = []
+       @lines.each_with_index do |line,i|
+          txt << line
+          txt << "\n"
+       end
+       txt = txt.join
+ 
          if debug?
-           puts
-           puts "line >#{line}<"
+           puts "lines:"
+           pp txt
          end
 
-          ## skip new (experimental attrib syntax)
-          if attrib_found == false &&
-              ATTRIB_RE.match?( line )
-            ## note: check attrib regex AFTER group def e.g.:
-            ##         Group A:
-            ##         Group B:  etc.
-            ##     todo/fix - change Group A: to Group A etc.
-            ##                       Group B: to Group B
-             attrib_found = true
-             ## logger.debug "skipping key/value line - >#{line}<"
-             next
-          end
-
-          if attrib_found
-            ## check if line ends with dot
-            ##  if not slurp up lines to the next do!!!
-            ## logger.debug "skipping key/value line - >#{line}<"
-            attrib_found = false   if line.end_with?( '.' )
-                # logger.debug "skipping key/value line (cont.) - >#{line}<"
-            next
-          end
-
+=begin
           t, error_messages  =  @parser.parse_with_errors( line )
 
 
@@ -151,71 +121,47 @@ class MatchParser    ## simple match parser for team match schedules
            pp t   if debug?
 
            @tree << t
-    end  # each lines
+=end
 
-    ## pp @tree
+     parser = RaccMatchParser.new( txt )   ## use own parser instance (not shared) - why? why not?
+     @tree = parser.parse
+     ## pp @tree
 
     ## report parse errors here - why? why not?
 
 
 
-    @tree.each do |nodes|
-
-        node_type = nodes[0][0]  ## get node type of first/head node
+    @tree.each do |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
+        msg = "!! WARN - unknown node (parse tree type) - #{node.class.name}" 
+        puts msg
+        pp node
+
+        log( msg )
+        log( node.pretty_inspect )
+        ## 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 +170,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 +181,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 +194,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 +204,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 +242,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 +308,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 +333,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 +365,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
-
-      break  if node_type != :minute
-    end
+  def on_goal_line( node )
+    logger.debug "on goal line: >#{node}<"
 
+    goals1 = node.goals1
+    goals2 = node.goals2
 
-    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
-
+   
     pp [goals1,goals2]     if debug?
 
+
 ## wrap in struct andd add/append to match
 =begin
 class GoalStruct
@@ -532,26 +390,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 +431,69 @@ 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   = nil                       
+    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
-    more   = []
-    status = 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
+ 
 
-    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
+    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?
+
+    
+    ###############
+    #  add more for ground (and timezone!!!)
+    more   = []
+#
+#        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 +579,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/quick_match_reader.rb

@@ -73,6 +73,14 @@ class QuickMatchReader
                   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)

data/lib/sportdb/quick/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sportdb-quick
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.1
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-02 00:00:00.000000000 Z
+date: 2025-01-18 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.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.4
 - !ruby/object:Gem::Dependency
   name: sportdb-structs
   requirement: !ruby/object:Gem::Requirement