sportdb-parser 0.6.20 → 0.7.0

data/lib/sportdb/parser/token-time.rb

@@ -0,0 +1,141 @@
+module SportDb
+class Lexer
+
+
+
+##
+#  keep 18h30 - why? why not?
+#    add support for 6:30pm 8:20am etc. - why? why not?
+#
+#    check - only support h e.g. 18h30  or 18H30 too - why? why not?
+# e.g. 18:30 (or 18h30)
+#   note - optional timezone possible e.g.
+#        18:30 UTC+1   or 18:30 BST/UTC+1  or such!!!
+#        18:30 UTC+01  or 18:30 BST/UTC+01
+#       
+#
+#  note  18.30 no longer supported - MUST use 18:30 or 18h30 !!!
+#
+#
+#
+#   note -  local time is now (inline) part of time!!!
+#              and, thus, must always follow time
+#                     e.g. 18:30 (19:30 BST)
+#
+##    local time e.g (19:30 UTC+1) or (19:30 BST/UTC+1) or 
+##   note - timezone is optional!  e.g. (19:30) works too
+
+
+TIME_RE = %r{
+        \b
+    (?<time>  
+             (?<hour>\d{1,2})
+                   [:h] 
+              (?<minute>\d{2})
+                 
+                 #### optional (inline) timezone
+                 ##    note - non-utc timezone MUST be hard-coded (added) here!!!
+                 ##     avoids eating-up team names (separated by one space)
+                 ##            e.g.  18:30 MEX v MEX 
+                 (?:
+                    [ ]  ## require space - why? why not
+                     (?<timezone>
+                        (?: 
+                          ## GMT   - Greenwich Mean Time
+                          ## BST   - British Summer Time
+                          ## CES?T - Central European (Summer) Time
+                          ## EES?T - Eastern European (Summer) Time
+                          ##
+                          (?: GMT|BST|CES?T|EES?T) 
+                               (?: /
+                                   UTC  (?: [+-]\d{1,4} | ±0)
+                               )?
+                          )
+                          |
+                          (?:
+                             UTC  (?: [+-]\d{1,4} | ±0)
+                          )
+                     )
+                 )?
+        )          
+      \b  
+
+####
+###  note - local time is now INLINE and MUST follow time
+       (?:     
+           [ ]+   ## todo/check - make space optional - why? why not?
+           \(
+        (?<time_local>   
+                (?<local_hour>\d{1,2})
+                   [:h]    ### todo/fix - MUST match style in time above!!!
+                (?<local_minute>\d{2})
+                
+                ####
+                ## optional "local" timezone name eg. BRT or CEST etc.
+                (?:
+                    [ ] ## require space - why? why not
+                   (?<local_timezone>
+                      (?:  [A-Z]{3,4}
+                           (?: /
+                                   UTC (?: [+-]\d{1,4} | ±0)
+                           )? 
+                      )
+                      |    
+                      (?:     ## e.g. 0 or 00 or 0000
+                          UTC   (?: [+-]\d{1,4} | ±0)
+                      )   
+                  )
+               )?  # note - make timezone  optional!!!
+          )
+      \)       
+       )?
+}ix
+
+
+def self._build_time( m )
+              ## unify to iso-format
+              ###   12.40 => 12:40
+              ##    12h40 => 12:40 etc.
+              ##  keep string (no time-only type in ruby)
+              data = { time: {} }
+              
+              hour     = m[:hour].to_i(10)  ## allow 08/07/etc.
+              minute   = m[:minute].to_i(10)
+   
+              ##   check if 24:00 possible? or only 0:00 (23:59)
+              unless (hour   >=0 && hour   <=23) &&
+                     (minute >=0 && minute <=59)
+                 raise ArgumentError, "parse error - time >#{m[:time]}< out-of-range"
+              end
+   
+              data[:time][:h] = hour
+              data[:time][:m] = minute
+              data[:time][:timezone] = m[:timezone]    if m[:timezone] 
+      
+
+              ## check if local time present e.g.
+              ##    18:30 (19:30)
+              ##    18:30 (19:30 BST)  etc.
+              if m[:time_local]
+                  data[:time_local] = {}
+
+                local_hour     = m[:local_hour].to_i(10)  ## allow 08/07/etc.
+                local_minute   = m[:local_minute].to_i(10)
+  
+                ##   check if 24:00 possible? or only 0:00 (23:59)
+                unless (hour   >=0 && hour   <=23) &&
+                       (minute >=0 && minute <=59)
+                   raise ArgumentError, "parse error - local time >#{m[:time_local]}< out-of-range"
+                end
+  
+                data[:time_local][:h] = local_hour
+                data[:time_local][:m] = local_minute
+                data[:time_local][:timezone] = m[:local_timezone]    if m[:local_timezone] 
+            end
+
+              data
+end
+def _build_time(m) self.class._build_time(m); end
+
+end  #   class Lexer
+end  # module SportDb

data/lib/sportdb/parser/token.rb

@@ -4,63 +4,12 @@ module SportDb
 class Lexer
 
 
-##
-#  keep 18h30 - why? why not?
-#    add support for 6:30pm 8:20am etc. - why? why not?
-#
-#    check - only support h e.g. 18h30  or 18H30 too - why? why not?
-# e.g. 18.30 (or 18:30 or 18h30)
-TIME_RE = %r{
-    (?<time>  \b
-        (?:   (?<hour>\d{1,2})
-                 (?: :|\.|h )
-              (?<minute>\d{2})) 
-              \b
-    )
-}ix
-
-
-
-## add wday / stand-alone week day - as separate regex or 
-##          use TEXT with is_wday? check or such with
-##                requirement of beginning of line (anchored to line) only??
-##       - why? why not?
-
-WDAY_RE = %r{
-(?<wday>
-  \b     # note - alternation (|) is lowest precedence (such 
-         #    parathenes required around \b()\b !!!
-         ## note - NOT case sensitive!!!    
-       (?<day_name>
-        (?-i:
-          Mon|Mo|
-          Tue|Tu|
-          Wed|We|
-          Thu|Th|
-          Fri|Fr|
-          Sat|Sa|
-          Sun|Su
-       ))
-       (?=[ ]{2})   # positive lookahead for two space  
-       ## todo/check - must be followed by two spaces or space + [( etc.
-         ##   to allow words starting with weekday abbrevations - why? why not?
-         ##     check if any names (teams, rounds, etc) come up in practice 
-         ##   or maybe remove three letter abbrevations Mon/Tue
-         ##    and keep only Mo/Tu/We etc. - why? why not?
-)}x    
-
-
-
 
 BASICS_RE = %r{
-    ## e.g. (51) or (1) etc.  - limit digits of number???
-    ##  todo/fix - change num  to ord (for ordinal number)!!!!!
-    (?<num> \(  (?<value>\d+) \) )
-       |
     (?<vs>
        (?<=[ ])	# positive lookbehind for space
        (?-i: 
-         vs|v 
+           vs\.?|v|VS 
        )        # note - only match case sensitive (downcased letters)!!!
                 # note -  bigger match first e.g. vs than v etc.
        (?=[ ])   # positive lookahead for space
@@ -69,87 +18,275 @@ BASICS_RE = %r{
     (?<spaces> [ ]{2,}) |
     (?<space>  [ ])
         |
-    (?<sym>  (?<=^|[ ])  ## positive lookahead 
-                  (?: ----|
-                      ---|
-                      --
-                  )
-             (?=[ ])   ## positive lookahead
-    )
-        |
-    (?<sym> [;,/@|\[\]-] )
+    (?<sym> [,;/@|()\[\]-] )   ### note: add parantheses too e.g () - why? why not?
 }ix
 
 
 
+
+###
+## add att(endance) e.g.  att: 18000
+##
+##    A v B 2-1  att: 18000
+
+ATTENDANCE_RE = %r{
+    (?<attendance>
+     \b
+        att: [ ]*
+         (?<value>
+              [1-9]
+              (?: _? \d+ )*
+         )
+     \b
+)}ix
+
+
+## "inline" match status e.g.
+##  Clapham Rovers     w/o  Hitchin            
+##  Queen's Park       bye
+         
+## add support for WO or W-0 too - why? why not?
+INLINE_WO_RE = %r{
+                   (?<inline_wo>
+                       \b (?: w/o | W/O ) \b
+               )}x   ## note - NOT case insensitive 
+
+INLINE_BYE_RE = %r{ 
+                  (?<inline_bye>
+                      \b (?: bye | BYE ) \b
+               )}x   ## note - NOT case insensitive 
+
+
+###
+#   A n/p  B    (note - basically a inline short form of  A v B [cancelled] )
+#     N/P
+INLINE_NP_RE = %r{
+                   (?<inline_np>
+                       \b (?: n/p | N/P ) \b
+               )}x   ## note - NOT case insensitive 
+
+
+###
+#  abd/abd. or aban/aban.  [abandoned]
+#  ABD/ABAN
+INLINE_ABD_RE = %r{
+                   (?<inline_abd>
+                       \b (?: abd\.? |
+                              aban\.? |
+                              ABD | ABAN
+                          ) 
+                  ## POSITIVE lookahead - requires space
+                         (?= [ ])
+               )}x  ## note - NOT case insensitive 
+
+####
+#  susp/susp.  [suspended]
+#   SUSP
+INLINE_SUSP_RE = %r{
+                   (?<inline_susp>
+                       \b (?: susp\.? |
+                               SUSP ) 
+                  ## POSITIVE lookahead - requires space
+                         (?= [ ])
+               )}x  ## note - NOT case insensitive 
+
+
+####
+# ppd/ppd. or pst/pst. or pstp/pstp. or postp/postp.   [postponed] 
+#  PPD/PSTP/POSTP/P-P              
+#   todo/check - add/allow p-p too - why? why not?
+INLINE_PPD_RE = %r{
+                   (?<inline_ppd>
+                       \b (?: ppd\.? |
+                              pst\.? |
+                              po?stp\.? |
+                              PPD | PST | PO?STP | P-P
+                           ) 
+                  ## POSITIVE lookahead - requires space
+                         (?= [ ])
+               )}x   ## note - NOT case insensitive 
+
+####
+#  void via   x-x X-X
+#     todo/check - only allow X-X - why? why not?
+INLINE_VOID_RE = %r{
+                      (?<inline_void>
+                          \b (?: x-x |
+                                 X-X 
+                             )
+                        ## POSITIVE lookahead - requires space
+                           (?= [ ])
+                )}x ## note - NOT case insensitive
+
+
+####
+#  awd/awd.                [awarded]
+#   AWD
+#   note - recommendation is to allways include score
+#            thus, use/prefer SCORE_AWD e.g. 0-3 awd
+INLINE_AWD_RE =  %r{
+                   (?<inline_awd>
+                       \b (?: awd\.? | AWD ) 
+                  ## POSITIVE lookahead - requires space
+                         (?= [ ])
+               )}x   ## note - NOT case insensitive 
+
+###
+#  canc/canc.           [cancelled]
+#    CANC
+INLINE_CANC_RE =  %r{
+                   (?<inline_canc>
+                       \b (?: canc\.?  | CANC ) 
+                  ## POSITIVE lookahead - requires space
+                         (?= [ ])
+               )}x   ## note - NOT case insensitive 
+
+
+###
+##   home/away/neutral  - (h), (a), (n)
+##    add support for h/a/n  
+##       with (?-i \b [han] \b) lower-case and \b boundry - why? why not?
+
+TEAM_HOME_RE     = %r{  (?<team_home> \(h\) )}xi
+TEAM_AWAY_RE     = %r{  (?<team_away> \(a\)  )}xi
+TEAM_NEUTRAL_RE  = %r{  (?<team_neutral> \(n\) )}xi
+
+
+
+## "top-level" regex used for:
+##    - date_header
+##    - match_header & match_line_more
+##    - match_line
+
+
 RE = Regexp.union(
-                    STATUS_RE,
-                    SCORE_NOTE_RE,
-                    NOTE_RE,
-                    DURATION_RE,  # note - duration MUST match before date
+                    STATUS_RE,   ## match status e.g. [cancelled], etc.
+
+                    INLINE_WO_RE,    ## (inline) match status - w/o (walkout)
+                    INLINE_NP_RE,    ## (inline) match status - n/p (not played)
+                    INLINE_BYE_RE,   ## (inline) match status - bye (advance to next round)
+                    INLINE_ABD_RE,   ## (inline) match status - abd/abd. (abandoned)
+                    INLINE_SUSP_RE,  ## (inline) match status - susp/susp.  (suspended)
+                    INLINE_PPD_RE,   ## (inline) match status - ppd/ppd. or pstp/pstp. or postp/postp. or p-p (postponed)            
+                    INLINE_VOID_RE,  ## (inline) match status - x-x (voided) 
+                    INLINE_AWD_RE,   ## (inline) match status - awd/awd. (awarded)
+                    INLINE_CANC_RE,  ## (inline) match status - canc/canc. (cancelled/canceled)
+                   
+
+                    TEAM_HOME_RE,     ## (H)
+                    TEAM_AWAY_RE,     ## (A)
+                    TEAM_NEUTRAL_RE,  ## (N)
+
+                    NOTE_RE,  ### fix - change to INLINE_NOTE !!!
+                    DATE_LEGS_RE,  # note - must go before date!!!
                     DATE_RE,  ## note - date must go before time (e.g. 12.12. vs 12.12)
                      TIME_RE,
-                    SCORE_MORE_RE, 
-                    SCORE_RE,   ## note basic score e.g. 1-1 must go after SCORE_MORE_RE!!!
+                    ATTENDANCE_RE,   # note - allow att: for now inline in matches too - why? why not? 
+                    SCORE_LEGS_RE,
+                    SCORE_FULL_RE, 
+                    SCORE_FULLER_RE,
+                    SCORE_FULLER_MORE_RE,
+                    SCORE_AWD_RE,   #  (inline) score awarded e.g. 3-0 awd or 0-1 awd. etc.
+                    SCORE_ABD_RE,   #  (inline) score abandoned e.g. 2-1 abd.
+                    SCORE_RE,   ## note basic score e.g. 1-1 must go after SCORE_FULL_RE!!!
+                    
+                    ## note - add "experimental" "split" scores for now
+                    SCORE_TEAM_RE,   ##  e.g. (2) 1  for "split" scores
+                    SCORE_TEAM_PEN_RE,   ##  e.g. 1 (2)  
+                    
                     BASICS_RE, 
-                    WDAY_RE,  # allow standalone weekday name (e.g. Mo/Tu/etc.) - why? why not?
-                              #    note - wday MUST be after text e.g. Sun Ke 68' is Sun Ke (NOT Sun) etc.
                    TEXT_RE,
+                     ## note - score_team_num (e.g. 0 or 10 etc.)
+                     ##            MUST BE after TEXT 
+                     ##              only match if nothing else matches (expect ANY)
+                    SCORE_TEAM_NUM_RE,   ## e.g. 0 or 1 or 9 or 11 etc. (<100)
                    ANY_RE,
                       )
 
 
 
-######################################################
-## goal mode (switched to by PLAYER_WITH_MINUTE_RE)   
 
-GOAL_BASICS_RE = %r{
-    (?<spaces> [ ]{2,}) |
-    (?<space>  [ ])
-        |
-    (?<sym>  
-        [;,\[\]]   ## add (-) dash too - why? why not?   
-    )   
-}ix
 
 
-GOAL_RE = Regexp.union(
-    GOAL_BASICS_RE,
-    MINUTE_RE,
-    MINUTE_NA_RE,   ## note - add/allow not/available (n/a,na) minutes hack for now
-    GOAL_OG_RE, GOAL_PEN_RE,
-    SCORE_RE,
-    PROP_NAME_RE,    ## note - (re)use prop name for now for (player) name
-)
+##  ord (for ordinal number)
+##   e.g. (51) or (1) etc.  - limit digits of number - why? why not???
+ 
+START_WITH_ORD = %r{
+   \A  
+    [ ]*    ## ignore leading spaces (if any)
+     (?<ord>
+       \(  
+        (?<value>\d+) 
+       \)
+     )}ix
 
-## note - leave out n/a minute in goals - make minutes optional!!!
-PROP_GOAL_RE =  Regexp.union(
-    GOAL_BASICS_RE,
-    MINUTE_RE,
-   ## MINUTE_NA_RE,   ## note - add/allow not/available (n/a,na) minutes hack for now
-    GOAL_OG_RE, GOAL_PEN_RE,
-    SCORE_RE,
-    PROP_NAME_RE,    ## note - (re)use prop name for now for (player) name
-)
 
+###  
+##   e.g. 1930, 1986, 2002, 2010, 2022, 2026
+##         note - only YYYY
+##    note - look out for clubs like  1860 München (de) !!!
+##                                    1899 Hoffenheim (de)
+##                                    1896 Löwenherz  (ch - a.k.a. FC Winterthur ??)
+##                    any others starting with YYYY ?!
+##    note - YEAR requires TWO (trailing) spaces !!!!! e.g. 
+##       1930    Uruguay             4-2 Argentina
+##       1934    Italy               2-1 Czechoslovakia   (AET)
+##       2022    Argentina           3-3 France           (AET, 4-2 pen)
+##
+##     do NOT match (iso date!!) -  2020-11-12
+##                                  2020/11/12
+##                                  2020.11.12 etc.
 
-####
-# 
+START_WITH_YEAR = %r{
+   \A
+       [ ]*    ## ignore leading spaces (if any)
+     (?<year>
+        \d{4}
+     )
+     ## positive lookahead 
+       (?= [ ]{2} |   ## min. TWO spaces or 
+           [ ]@ |   ##   space with geo marker or
+           [ ]* \z  ##    year (date) header (end-of-line/string)
+        )   
+}x
+
+
+
+###
+## check for headings 
+##    e.g.  = heading 1
+##          == heading 2  etc.
+##          =Eurochampionship=
+##    note  -  no spaces required (same as in wikipedia!!)
+##             same as in wikipedia support six (6) levels
+##
 ##  note - use \A (instead of ^) - \A strictly matches the start of the string.
-ROUND_OUTLINE_RE = %r{   \A
+
+
+HEADING_RE = %r{   \A
                            [ ]*  ## ignore leading spaces (if any)
-                         (?: »|>> ) 
-                           [ ]+
-                            (?<round_outline>
+                         (?<heading_marker> ={1,6} ) 
+                           [ ]*
+                            (?<heading>
                                ## must start with letter - why? why not?
                                ###   1st round
                                ##  allow numbers e.g. Group A - 1 
-                               .+?   ## use non-greedy 
+                               [^=]+?   ## use non-greedy 
                             )
-                           [ ]*  ## ignore trailing spaces (if any) 
-                         $
+                           [ ]*  ## ignore trailing spaces (if any)
+                            (?: =* )  ## allow any trailing heading markers
+                           [ ]*  ## ignore trailing spaces (if any)
+                         \z
                        }ix
 
 
+HRULER_RE = %r{
+                 \A
+                           [ ]*  ## ignore leading spaces (if any)
+                    -{3,}  ## must be at least three dashes!!!
+                           [ ]*  ## ignore trailing spaces (if any)                   
+                 \z
+}ix
+
 end  # class Lexer
 end # module SportDb

data/lib/sportdb/parser/token_helpers.rb

@@ -0,0 +1,92 @@
+module SportDb
+class Lexer
+
+
+=begin
+def self._mk_is( re )
+    ##   add  \A ... \z to regex
+    ##     for strict matching of beginning and end of string
+    ##     regex note -  \z will NOT allow trailing newline(s)!!!!
+    ##      note - must double espace \\A,\\z  in quoted string!!
+    Regexp.new( %Q<   \\A
+                    (?:#{re.source})
+                       \\z
+                  >, re.options )
+end
+
+
+  IS_TEAM_RE = _mk_is( TEXT_RE )   ## todo/fix - rename TEXT_RE to TEAM_RE!!!
+  IS_DATE_RE = _mk_is( DATE_IIII_RE )    ## DATE_RE )
+=end
+
+
+def self._parse_team( str )  
+    ## note - strip - leading/trailing spaces
+    m = TEXT_RE.match( str.strip )
+    if m && m.pre_match == '' && m.post_match == ''
+      m
+    elsif  m
+        ## note - match BUT not anchored to start and end-of-string!!!
+        ##  report, error somehow??
+      nil   
+    else
+      nil  ## no match - return nil
+    end
+end
+
+
+def self._parse_date( str )
+    ## note - strip - leading/trailing spaces
+    m = DATE_RE.match( str.strip )
+    
+    ####  todo/fix/check:
+    ###   wrapped with  \A \z NOT working with union  - check later - why?
+    ###   use hand-coded  with pre_match = "" and post_match = ""
+    
+    if m && m.pre_match == '' && m.post_match == ''
+      ## return hash table with captured components
+      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]
+      ## 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]
+      date[:wday] = DAY_MAP[ m[:day_name].downcase ]   if m[:day_name]
+      date 
+    elsif  m
+        ## note - match BUT not anchored to start and end-of-string!!!
+        ##  report, error somehow??
+      nil   
+    else
+      nil  ## no match - return nil
+    end
+end   
+
+
+def self._parse_score_full( str )
+    ## note - strip - leading/trailing spaces
+    m=SCORE_FULL_RE.match( str )
+
+    if m && m.pre_match == '' && m.post_match == ''
+       score = {}
+       score[:p]  = [m[:p1].to_i,m[:p2].to_i]     if m[:p1] && m[:p2]
+       score[:et] = [m[:et1].to_i,m[:et2].to_i]   if m[:et1] && m[:et2]
+       score[:ft] = [m[:ft1].to_i,m[:ft2].to_i]   if m[:ft1] && m[:ft2]
+       score[:ht] = [m[:ht1].to_i,m[:ht2].to_i]   if m[:ht1] && m[:ht2]
+       ## score[:agg] = [m[:agg1].to_i,m[:agg2].to_i]   if m[:agg1] && m[:agg2]
+       score
+    elsif  m
+        ## note - match BUT not anchored to start and end-of-string!!!
+        ##  report, error somehow??
+      nil   
+    else
+      nil  ## no match - return nil
+    end
+end       
+       
+
+end  #   class Lexer
+end  # module SportDb

data/lib/sportdb/parser/version.rb

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

data/lib/sportdb/parser.rb

@@ -15,17 +15,39 @@ require 'cocos'
 
 require_relative 'parser/version'
 
-require_relative 'parser/lang'
+##
+## generic helper
+require_relative 'parser/blocktxt'
+
+## core machinery
 
 require_relative 'parser/token-score'
+require_relative 'parser/token-score_fuller'
+require_relative 'parser/token-score_legs'
+require_relative 'parser/token-time'
 require_relative 'parser/token-date'
+require_relative 'parser/token-date_duration'
 require_relative 'parser/token-text'
+require_relative 'parser/token-prop_name'    ## a.k.a token-text_ii
 require_relative 'parser/token-status'
-require_relative 'parser/token-minute'
+require_relative 'parser/token-note'
+require_relative 'parser/token-goals'
 require_relative 'parser/token-prop'    ## team prop(erty) mode (note - must be before token)
 require_relative 'parser/token-geo'
+require_relative 'parser/token-group'
+require_relative 'parser/token-round'
+require_relative 'parser/token-table'
 require_relative 'parser/token'
+
+
+### add token ("private") parse helpers  e.g.  _parse_team() etc.
+require_relative 'parser/token_helpers'
+
+
+require_relative 'parser/lexer_buffer'   ## incl. Tokens (aka TokenBuffer)
 require_relative 'parser/lexer'
+require_relative 'parser/lexer_tty'      ## teletype (tty) mode
+
 
 require_relative 'parser/parser'   ## auto-generated by racc (from parser.y)
 require_relative 'parser/racc_parser'