sportdb-parser 0.6.3 → 0.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1dd9f29584bb09508c0fb6ad253a84ff299c7f33650d27195abbc679c1e893f
-  data.tar.gz: 6af07bc6f008e1b6c53cd796253f66bd68f2f28299a750896be83176bae7d085
+  metadata.gz: 7cb697dbecb7802a9701c60527bb67125dc7ac550b6c5c80f67044e51683eb15
+  data.tar.gz: d53cc9c126b93a4702b2c633daf863a3e4d4b63397f7c5ac60bd0646ab1d2da9
 SHA512:
-  metadata.gz: f8adae46063426008e23f01ef3d625a3477c01a827b942edadddfad7e774e8689de3545c1c6ae8e32d0fa43b2bfbf5c9dc9962947c97be79ab325a41a7896c48
-  data.tar.gz: e0b843c9b2eee0ebfec203889ed5ea90f94eb22f80ca0df58d8865f05dd08f4d4bc3547b59f0fbe00e323a09df9c13289954ddea34bf437cad6d196c29a2e436
+  metadata.gz: 341aa9f1b25259db42452f28bd69f5643ecb5a3b45755a88565aac2b7a2842bc34d8d2a53e7d3b7a4b96c15c199c000167f4e94e608486a4ae9fefa9756bc7a0
+  data.tar.gz: d983116b79d9f361e136ef989ac02041ea735cfda42614f0ff08f5fd43899d7deebc135a82c020ff6dc7c9c6cf6ee413bbff7cdc9f65e41a682b3bf5cb5b082f

data/CHANGELOG.md

@@ -1,4 +1,4 @@
-### 0.6.3
+### 0.6.5
 ### 0.0.1 / 2024-07-12
 
 * Everything is new. First release.

data/lib/sportdb/parser/lexer.rb

@@ -246,9 +246,10 @@ def tokenize_with_errors
              nodes << [:TEAM, buf.next[1]]
              nodes << buf.next
              nodes << [:TEAM, buf.next[1]]
-          elsif buf.match?( :TEXT, :MINUTE )
-             nodes << [:PLAYER, buf.next[1]]
-             nodes << buf.next
+   #   note - now handled (upstream) with GOAL_RE mode!!!
+   #       elsif buf.match?( :TEXT, :MINUTE )
+   #          nodes << [:PLAYER, buf.next[1]]
+   #          nodes << buf.next
           elsif buf.match?( :DATE, :TIME )   ## merge DATE TIME into DATETIME
                date = buf.next[1]
                time = buf.next[1]
@@ -315,11 +316,103 @@ def _tokenize_line( line )
   @re  ||= RE     ## note - switch between RE & INSIDE_RE
 
 
+  if @re == RE  ## top-level
+    ### check for modes once (per line) here to speed-up parsing
+    ###   for now goals only possible for start of line!!
+    ###        fix - remove optional [] - why? why not?  
+  
+    ##  start with prop key (match will switch into prop mode!!!)
+    ##   - fix - remove leading spaces in regex (upstream) - why? why not?
+    m = PROP_KEY_RE.match( line )
+    if m
+      ###  switch into new mode
+      ##  switch context  to PROP_RE
+        puts "  ENTER PROP_RE MODE"   if debug?
+        key = m[:key]
+
+
+        ### todo - add prop yellow/red cards too - why? why not?
+        if ['sent off', 'red cards'].include?( key.downcase) 
+          @re = PROP_CARDS_RE    ## use CARDS_RE ???
+          tokens << [:PROP_REDCARDS, m[:key]]
+        elsif ['yellow cards'].include?( key.downcase )
+          @re = PROP_CARDS_RE  
+          tokens << [:PROP_YELLOWCARDS, m[:key]]
+        elsif ['ref', 'referee'].include?( key.downcase )
+          @re = PROP_RE     ## (re)use prop setup for now - why? why not?
+          tokens << [:PROP_REFEREE, m[:key]]
+        elsif ['goals'].include?( key.downcase )
+          @re = PROP_GOAL_RE
+          tokens << [:PROP_GOALS, m[:key]]
+        else   ## assume (team) line-up
+          @re = PROP_RE           ## use LINEUP_RE ???
+          tokens << [:PROP, m[:key]]
+        end
+
+        offsets = [m.begin(0), m.end(0)]
+        pos = offsets[1]    ## update pos
+    end
+
+    m = PLAYER_WITH_SCORE_RE.match( line )
+    if m
+      ##  switch context to GOAL_RE (goalline(s)
+      ##   split token (automagically) into two!! - player AND minute!!!
+      @re = GOAL_RE
+      puts "  ENTER GOAL_RE MODE"   if debug?
+
+      score = {}
+      ## must always have ft for now e.g. 1-1 or such
+      ###  change to (generic) score from ft -
+      ##     might be score a.e.t. or such - why? why not?
+      score[:ft] = [m[:ft1].to_i(10),
+                    m[:ft2].to_i(10)]  
+      ## note - for debugging keep (pass along) "literal" score
+      tokens << [:SCORE, [m[:score], score]]
+
+      ## auto-add player token 
+      tokens << [:PLAYER, m[:name]]
+  
+      offsets = [m.begin(0), m.end(0)]
+      pos = offsets[1]    ## update pos
+    end 
+
+    m = PLAYER_WITH_MINUTE_RE.match( line )
+    if m
+      ##  switch context to GOAL_RE (goalline(s)
+      ##   split token (automagically) into two!! - player AND minute!!!
+      @re = GOAL_RE
+      puts "  ENTER GOAL_RE MODE"   if debug?
+
+      ## check for optional open_bracket
+      tokens << [:'[']     if m[:open_bracket]
+
+      ## check for  -;  (none with separator)
+      ##    todo - find a better way? how possible?
+      tokens << [:NONE, "<|NONE|>"]   if m[:none]
+      
+
+
+      ## auto-add player token first
+      tokens << [:PLAYER, m[:name]]
+      ## minute props
+      minute = {}
+      minute[:m]      = m[:value].to_i(10)
+      minute[:offset] = m[:value2].to_i(10)   if m[:value2]
+      ##  t is minute only
+      tokens << [:MINUTE, [m[:minute], minute]]
+
+      offsets = [m.begin(0), m.end(0)]
+      pos = offsets[1]    ## update pos
+    end
+  end
+
+
+
   while m = @re.match( line, pos )
-#    if debug?
-#      pp m
-#      puts "pos: #{pos}"
-#    end
+    # if debug?
+    #  pp m
+    #  puts "pos: #{pos}"
+    # end
     offsets = [m.begin(0), m.end(0)]
 
     if offsets[0] != pos
@@ -345,10 +438,44 @@ def _tokenize_line( line )
     ## note: racc requires pairs e.g. [:TOKEN, VAL]
     ##         for VAL use "text" or ["text", { opts }]  array
 
-
-  t = if @re == PROP_RE
+  t = if @re == PROP_CARDS_RE 
+        if m[:space] || m[:spaces]
+              nil    ## skip space(s)
+         elsif m[:prop_name]
+              [:PROP_NAME, m[:name]]
+         elsif m[:minute]
+              minute = {}
+              minute[:m]      = m[:value].to_i(10)
+              minute[:offset] = m[:value2].to_i(10)   if m[:value2]
+             ## note - for debugging keep (pass along) "literal" minute
+             [:MINUTE, [m[:minute], minute]]
+         elsif m[:sym]
+            sym = m[:sym]
+            case sym
+            when ',' then [:',']
+            when ';' then [:';']
+            when '-' then [:'-']
+            else
+              nil  ## ignore others (e.g. brackets [])
+            end
+         else
+            ## report error
+             puts "!!! TOKENIZE ERROR (PROP_CARDS_RE) - no match found"
+             nil 
+         end    
+      elsif @re == PROP_RE   ### todo/fix - change to LINEUP_RE !!!!
          if m[:space] || m[:spaces]
               nil    ## skip space(s)
+         elsif m[:prop_key]   ## check for inline prop keys
+              key = m[:key]   
+              ##  supported for now coach/trainer (add manager?)
+              if ['coach', 
+                  'trainer'].include?( key.downcase )
+                [:COACH, m[:key]]   ## use COACH_KEY or such - why? why not?
+              else
+                ## report error - for unknown (inline) prop key in lineup
+                nil
+              end
          elsif m[:prop_name]
                if m[:name] == 'Y'
                  [:YELLOW_CARD, m[:name]]
@@ -376,11 +503,6 @@ def _tokenize_line( line )
             when '(' then [:'(']
             when ')' then [:')']
             when '-' then [:'-']
-           # when '.' then 
-           #     ## switch back to top-level mode!!
-           #     puts "  LEAVE PROP_RE MODE, BACK TO TOP_LEVEL/RE"  if debug?
-           #     @re = RE 
-           #     [:'.']
             else
               nil  ## ignore others (e.g. brackets [])
             end
@@ -389,16 +511,53 @@ def _tokenize_line( line )
              puts "!!! TOKENIZE ERROR (PROP_RE) - no match found"
              nil 
          end
+      elsif @re == GOAL_RE || @re == PROP_GOAL_RE
+         if m[:space] || m[:spaces]
+              nil    ## skip space(s)
+         elsif m[:prop_name]    ## note - change prop_name to player
+             [:PLAYER, m[:name]] 
+         elsif m[:minute]
+              minute = {}
+              minute[:m]      = m[:value].to_i(10)
+              minute[:offset] = m[:value2].to_i(10)   if m[:value2]
+             ## note - for debugging keep (pass along) "literal" minute
+             [:MINUTE, [m[:minute], minute]]
+         elsif m[:score]
+              score = {}
+              ## must always have ft for now e.g. 1-1 or such
+              ###  change to (generic) score from ft -
+              ##     might be score a.e.t. or such - why? why not?
+              score[:ft] = [m[:ft1].to_i(10),
+                            m[:ft2].to_i(10)]  
+              ## note - for debugging keep (pass along) "literal" score
+              [:SCORE, [m[:score], score]]
+         elsif m[:og]
+             [:OG, m[:og]]    ## for typed drop - string version/variants ??  why? why not?
+         elsif m[:pen]
+             [:PEN, m[:pen]]
+         elsif m[:sym]
+            sym = m[:sym]
+            ## return symbols "inline" as is - why? why not?
+            ## (?<sym>[;,@|\[\]-])
+ 
+            case sym
+            when ',' then [:',']
+            when ';' then [:';']
+            when '[' then [:'[']
+            when ']' then [:']']
+            else
+              nil  ## ignore others (e.g. brackets [])
+            end
+         else
+            ## report error
+            puts "!!! TOKENIZE ERROR (GOAL_RE) - no match found"
+            nil 
+         end
       ###################################################
       ## assume TOP_LEVEL (a.k.a. RE) machinery
       else  
         if m[:space] || m[:spaces]
            nil   ## skip space(s)
-        elsif m[:prop_key]
-           ##  switch context  to PROP_RE
-           @re = PROP_RE
-           puts "  ENTER PROP_RE MODE"  if debug?
-           [:PROP, m[:key]]
         elsif m[:text]
           [:TEXT, m[:text]]   ## keep pos - why? why not?
         elsif m[:status]   ## (match) status e.g. cancelled, awarded, etc.
@@ -436,7 +595,9 @@ def _tokenize_line( line )
             date = {}
  ## map month names
  ## note - allow any/upcase JULY/JUL etc. thus ALWAYS downcase for lookup
-            date[:y] = m[:year].to_i(10)  if m[:year]
+            date[:y]  = m[:year].to_i(10)  if m[:year]
+            ## check - use y too for two-digit year or keep separate - why? why not?
+            date[:yy] = m[:yy].to_i(10)    if m[:yy]    ## two digit year (e.g. 25 or 78 etc.)
             date[:m] = m[:month].to_i(10)  if m[:month]
             date[:m] = MONTH_MAP[ m[:month_name].downcase ]   if m[:month_name]
             date[:d]  = m[:day].to_i(10)   if m[:day]
@@ -480,6 +641,8 @@ def _tokenize_line( line )
         elsif m[:score]
             score = {}
             ## must always have ft for now e.g. 1-1 or such
+            ###  change to (generic) score from ft -
+            ##     might be score a.e.t. or such - why? why not?
             score[:ft] = [m[:ft1].to_i(10),
                           m[:ft2].to_i(10)]  
           ## note - for debugging keep (pass along) "literal" score
@@ -490,10 +653,6 @@ def _tokenize_line( line )
               minute[:offset] = m[:value2].to_i(10)   if m[:value2]
              ## note - for debugging keep (pass along) "literal" minute
              [:MINUTE, [m[:minute], minute]]
-        elsif m[:og]
-           [:OG, m[:og]]    ## for typed drop - string version/variants ??  why? why not?
-        elsif m[:pen]
-           [:PEN, m[:pen]]
         elsif m[:vs]
            [:VS, m[:vs]]
         elsif m[:sym]
@@ -514,8 +673,13 @@ def _tokenize_line( line )
           when '---'  then [:'---']   # level 3
           when '----' then [:'----']  # level 4
           else
+            puts "!!! TOKENIZE ERROR (sym) - ignore sym >#{sym}<"
             nil  ## ignore others (e.g. brackets [])
           end
+        elsif m[:any]
+           ## todo/check log error
+           puts "!!! TOKENIZE ERROR (any) - no match found >#{m[:any]}<"
+           nil   
         else
           ## report error
            puts "!!! TOKENIZE ERROR - no match found"
@@ -546,8 +710,8 @@ def _tokenize_line( line )
    ##
    ## if in prop mode continue if   last token is [,-]
    ##        otherwise change back to "standard" mode
-   if @re == PROP_RE
-     if [:',', :'-'].include?( tokens[-1][0] )
+   if @re == PROP_RE || @re == PROP_CARDS_RE || @re == PROP_GOAL_RE
+     if [:',', :'-', :';'].include?( tokens[-1][0] )
         ## continue/stay in PROP_RE mode
         ##  todo/check - auto-add PROP_CONT token or such
         ##                to help parser with possible NEWLINE
@@ -560,6 +724,12 @@ def _tokenize_line( line )
         tokens << [:PROP_END, "<|PROP_END|>"]    
      end
    end
+
+
+   if @re == GOAL_RE   ### ALWAYS switch back to top level mode
+     puts "  LEAVE GOAL_RE MODE, BACK TO TOP_LEVEL/RE"  if debug?
+     @re = RE 
+   end
   
   [tokens,errors]
 end