sportdb-parser 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17e2ccd1472c3f56b5c1f4f4374e66de6b5297c67a5a0fa86206489ac560a00e
-  data.tar.gz: 1c6de22e1c9dda2cc2a0b75654737882b7ce4c7e9f191b61889887c844fc35b9
+  metadata.gz: 35a69fdc1a31058e1a0069e89106bb68f2c9bbff10465a4111d0d0bf0eb3a210
+  data.tar.gz: 98f2e0b3f1d21d71b783d96c6e5cac7f2357d436951cae0865558a2289dd2bca
 SHA512:
-  metadata.gz: ac121460004ce5f4287668ea8753feee5729124a265474bfcf065775ffd099a5f867109fc16b2d8d46b6ee7a327bdc8b4c14539f22d1ef43ee285f457097eae0
-  data.tar.gz: 340afd868ceceeaa31532ea89251d5bfa2874f649933a18124bb4a5ba28e837c3a59284144d376f17c125ca93c12436cc473c7fda94a3b72866960fdc2c9cba8
+  metadata.gz: b7f43a3c0fd14130b2f5c278b0d0742b4a2d71a489383b80c8a8349c70ebb14280c54b53fc008782c9b539b4ffa4df1442c2f4e82e70ebea05a695343472f613
+  data.tar.gz: 7b636234a8a66671f35d5d7bdc0113b2df0131b9e065e86eb8f8c688b58ce2eb4d931e21a91a69bfb23dab5d56ed2b78d04400fd308c960fe9f1eb3653f5ab53

data/CHANGELOG.md

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

data/Manifest.txt

@@ -3,30 +3,43 @@ Manifest.txt
 README.md
 Rakefile
 lib/sportdb/parser.rb
-lib/sportdb/parser/blocktxt.rb
+lib/sportdb/parser/lexer-on_goal.rb
+lib/sportdb/parser/lexer-on_group_def.rb
+lib/sportdb/parser/lexer-on_prop_lineup.rb
+lib/sportdb/parser/lexer-on_prop_misc.rb
+lib/sportdb/parser/lexer-on_prop_penalties.rb
+lib/sportdb/parser/lexer-on_round_def.rb
+lib/sportdb/parser/lexer-on_top.rb
+lib/sportdb/parser/lexer-prep_doc.rb
+lib/sportdb/parser/lexer-prep_line.rb
+lib/sportdb/parser/lexer-tokenize.rb
 lib/sportdb/parser/lexer.rb
 lib/sportdb/parser/lexer_buffer.rb
-lib/sportdb/parser/lexer_tty.rb
+lib/sportdb/parser/lexer_token.rb
 lib/sportdb/parser/parser.rb
 lib/sportdb/parser/parser_runtime.rb
 lib/sportdb/parser/racc_parser.rb
 lib/sportdb/parser/racc_tree.rb
+lib/sportdb/parser/token-date--helpers.rb
+lib/sportdb/parser/token-date--names.rb
 lib/sportdb/parser/token-date.rb
 lib/sportdb/parser/token-date_duration.rb
 lib/sportdb/parser/token-geo.rb
+lib/sportdb/parser/token-goals--helpers.rb
 lib/sportdb/parser/token-goals.rb
 lib/sportdb/parser/token-group.rb
 lib/sportdb/parser/token-note.rb
 lib/sportdb/parser/token-prop.rb
 lib/sportdb/parser/token-prop_name.rb
 lib/sportdb/parser/token-round.rb
+lib/sportdb/parser/token-score--helpers.rb
 lib/sportdb/parser/token-score.rb
+lib/sportdb/parser/token-score_full.rb
 lib/sportdb/parser/token-score_fuller.rb
 lib/sportdb/parser/token-score_legs.rb
 lib/sportdb/parser/token-status.rb
-lib/sportdb/parser/token-table.rb
+lib/sportdb/parser/token-status_inline.rb
 lib/sportdb/parser/token-text.rb
 lib/sportdb/parser/token-time.rb
 lib/sportdb/parser/token.rb
-lib/sportdb/parser/token_helpers.rb
 lib/sportdb/parser/version.rb

data/lib/sportdb/parser/lexer-on_goal.rb

@@ -0,0 +1,172 @@
+module SportDb
+class Lexer
+
+
+
+
+GOAL_RE = Regexp.union(
+    SPACES_RE,
+    GOAL_NONE_RE,
+    GOAL_MINUTE_RE,
+    GOAL_MINUTE_NA_RE,
+    GOAL_COUNT_RE,
+    PROP_NAME_RE,    ## note - (re)use prop name for now for (player) name
+    GOAL_SEP_ALT_RE,   ##  note - add dash (-) with (required) spaces
+    /  (?<sym> [;,)])  /x
+    ## todo/fix - add ANY_RE !!!!
+)
+
+def _on_goal( m, ctx: )
+
+         if m[:space] || m[:spaces]
+              nil    ## skip space(s)
+         elsif m[:goals_none]    ## note - eats-up semicolon!! e.g. -; or - ;
+             # was:[:GOALS_NONE,"<|GOALS_NONE|>"]
+             ##   use literal text!!
+             Token.new( :GOALS_NONE, m[:goals_none],
+                            lineno: ctx.lineno, offset: m.offset(:goals_none))
+         elsif m[:goal_sep_alt]
+             # was: [:GOAL_SEP_ALT, "<|GOAL_SEP_ALT|>" ]   ## e.g. dash (-) WITH leading & trailing space required
+             Token.new( :GOAL_SEP_ALT, m[:goal_sep_alt],
+                              lineno: ctx.lineno, offset: m.offset(:goal_sep_alt))
+         elsif m[:prop_name]    ## note - change prop_name to player
+             Token.new( :PLAYER, m[:name],
+                              lineno: ctx.lineno, offset: m.offset(:name))
+         elsif m[:goal_minute]
+             Token.new( :GOAL_MINUTE, m[:goal_minute],
+                              lineno: ctx.lineno, offset: m.offset(:goal_minute),
+                              value: _build_goal_minute( m ))
+         elsif m[:goal_minute_na]
+              ## note -  (re)use GOAL_MINUTE token; no extra GOAL_MINUTE_NA or such - why? why not?
+              ##          make sure to handle 'm' => nil upstream!!!
+              ##                     change to  999 or -1 or such - why? why not?
+             Token.new( :GOAL_MINUTE, m[:goal_minute_na],
+                               lineno: ctx.lineno, offset: m.offset(:goal_minute_na),
+                                value: _build_goal_minute_na( m ))
+         elsif m[:goal_count]
+              Token.new( :GOAL_COUNT, m[:goal_count],
+                                lineno: ctx.lineno, offset: m.offset(:goal_count),
+                                value: _build_goal_count( m ))
+         elsif m[:sym]
+            case m[:sym]
+            when ')'  ## leave goal mode!!
+                _trace( "LEAVE GOAL_RE MODE" )
+                @re = RE
+                ##  note - use/return GOAL_END token   - change to GOAL_END_PAREN(THESIS)
+                ##                                or GOAL_PAREN_CLOSE/END ???
+                ##   fix - use ) too - why? why not?
+                ## was: [:GOALS_END, '<|GOALS_END|>']
+                Token.virtual( :GOALS_END, lineno: ctx.lineno  )
+            else
+                Token.literal( m[:sym], lineno: ctx.lineno, offset: m.offset(:sym))
+            end
+         else
+            ctx.warn_on_else( m, mode: 'GOAL' )
+            nil
+         end
+end
+
+
+
+
+GOAL_ALT_RE = Regexp.union(
+    SPACES_RE,
+    SCORE_RE,        ## e.g.  1-0, 0-1, etc.
+    GOAL_MINUTE_RE,
+    GOAL_TYPE_RE,
+    PROP_NAME_RE,    ## note - (re)use prop name for now for (player) name
+    /  (?<sym> [,)])  /x    ## note - no semicolon (;)
+    ## todo/fix - add ANY_RE !!!!
+)
+
+def _on_goal_alt( m, ctx: )
+
+         if m[:space] || m[:spaces]
+              nil    ## skip space(s)
+         elsif m[:prop_name]    ## note - change prop_name to player
+             Token.new(:PLAYER, m[:name],
+                           lineno: ctx.lineno, offset: m.offset(:name))
+         elsif m[:goal_minute]
+             Token.new( :GOAL_MINUTE, m[:goal_minute],
+                              lineno: ctx.lineno, offset: m.offset(:goal_minute),
+                              value: _build_goal_minute( m ))
+         elsif m[:goal_type]
+             Token.new( :GOAL_TYPE,m[:goal_type],
+                              lineno: ctx.lineno, offset: m.offset(:goal_type),
+                              value: _build_goal_type( m ))
+         elsif m[:score]
+             Token.new( :SCORE, m[:score],
+                              lineno: ctx.lineno, offset: m.offset(:score),
+                              value: _build_score( m ))
+         elsif m[:sym]
+            case m[:sym]
+            when ')'  ## leave goal mode!!
+                _trace( "LEAVE GOAL_ALT_RE MODE" )
+                @re = RE
+                ##  note - use/return GOAL_END token   - change to GOAL_END_PAREN(THESIS)
+                ##                                or GOAL_PAREN_CLOSE/END ???
+                ## [:GOALS_END, '<|GOALS_END|>']
+                Token.virtual( :GOALS_END, lineno: ctx.lineno  )
+            else
+                Token.literal( m[:sym], lineno: ctx.lineno, offset: m.offset(:sym))
+            end
+         else
+            ctx.warn_on_else( m, mode: 'GOAL_ALT' )
+            nil
+         end
+end
+
+
+
+GOAL_COMPAT_RE = Regexp.union(
+    SPACES_RE,
+    SCORE_RE,        ## e.g.  1-0, 0-1, etc.
+    MINUTE_RE,          ## note - matches minute e.g.  92, 7, 7' 7+3, etc.
+    GOAL_TYPE_RE,
+    PROP_NAME_RE,    ## note - (re)use prop name for now for (player) name
+    /  (?<sym> [,)])  /x    ## note - no semicolon (;)
+    ## todo/fix - add ANY_RE !!!!
+)
+
+
+def _on_goal_compat( m, ctx: )      ## note - m is MatchData object
+
+         if m[:space] || m[:spaces]
+              nil    ## skip space(s)
+         elsif m[:prop_name]    ## note - change prop_name to player
+             Token.new(:PLAYER, m[:name],
+                           lineno: ctx.lineno, offset: m.offset(:name))
+         elsif m[:minute]
+             Token.new(:MINUTE, m[:minute],
+                           lineno: ctx.lineno, offset: m.offset(:minute),
+                           value: _build_minute( m ))
+         elsif m[:goal_type]
+             Token.new( :GOAL_TYPE,m[:goal_type],
+                              lineno: ctx.lineno, offset: m.offset(:goal_type),
+                              value: _build_goal_type( m ))
+
+         elsif m[:score]
+             Token.new( :SCORE, m[:score],
+                              lineno: ctx.lineno, offset: m.offset(:score),
+                              value: _build_score( m ))
+         elsif m[:sym]
+            case m[:sym]
+            when ')'  ## leave goal mode!!
+                _trace( "LEAVE GOAL_COMPAT_RE MODE" )
+                @re = RE
+                ##  note - use/return GOAL_END token   - change to GOAL_END_PAREN(THESIS)
+                ##                                or GOAL_PAREN_CLOSE/END ???
+                ## [:GOALS_END, '<|GOALS_END|>']
+                Token.virtual( :GOALS_END, lineno: ctx.lineno  )
+            else
+                Token.literal( m[:sym], lineno: ctx.lineno, offset: m.offset(:sym))
+            end
+         else
+            ctx.warn_on_else( m, mode: 'GOAL_COMPAT' )
+            nil
+         end
+end
+
+
+end ## class Lexer
+end ## module SportDb

data/lib/sportdb/parser/lexer-on_group_def.rb

@@ -0,0 +1,31 @@
+module SportDb
+class Lexer
+
+
+
+### note - add comma (,) as optional separator
+GROUP_DEF_RE = Regexp.union(  SPACES_RE,
+                              TEXT_RE,
+                              / (?<sym> [:|,] )  /x,
+                              ANY_RE,
+                           )
+
+
+def _on_group_def( m, ctx: )      ## note - m is MatchData object
+
+           if m[:spaces] || m[:space]
+               nil    ## skip spaces
+           elsif m[:text]
+               Token.new(:TEAM,  m[:text],
+                 lineno: ctx.lineno, offset: m.offset(:text))
+           elsif m[:sym]
+                Token.literal( m[:sym], lineno: ctx.lineno, offset: m.offset(:sym))
+           else
+              ctx.warn_on_else( m, mode: 'GROUP_DEF' )
+              nil
+           end
+end
+
+
+end ## class Lexer
+end ## module SportDb

data/lib/sportdb/parser/lexer-on_prop_lineup.rb

@@ -0,0 +1,79 @@
+module SportDb
+class Lexer
+
+
+
+PROP_LINEUP_RE = Regexp.union(
+   SPACES_RE,
+   MINUTE_RE,   ## e.g.  44 or 44' or 45+1 or 45+1' etc.
+
+   INLINE_CAPTAIN,  ## e.g. [c]
+   INLINE_YELLOW,   ## e.g. [Y] or [Y 44] or [Y 44'] or [Y 45+1']
+   INLINE_YELLOW_RED,  ## e.g. [Y/R] or [Y/R 78]
+   INLINE_RED,         ## e.g. [R] or [R 42] or [R 42']
+
+   PROP_KEY_INLINE_RE,
+   PROP_NAME_RE,
+   /  (?<sym>  [;,()\[\]-]) /x
+   ## todo/fix - add ANY_RE here too!!!
+)
+
+
+def _on_prop_lineup( m, ctx: )      ## note - m is MatchData object
+
+         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 )
+                ## use PROP_COACH or COACH_KEY or such - why? why not?
+                Token.new(:COACH, m[:key],
+                             lineno: ctx.lineno, offset: m.offset(:key))
+              else
+                ## report error - for unknown (inline) prop key in lineup
+                nil
+              end
+         elsif m[:inline_captain]
+              Token.new(:INLINE_CAPTAIN, m[:inline_captain],
+                            lineno: ctx.lineno, offset: m.offset(:inline_captain))
+         elsif m[:inline_yellow]
+              card = {}
+              card[:m]      = m[:minute].to_i(10)  if m[:minute]
+              card[:offset] = m[:offset].to_i(10)  if m[:offset]
+              Token.new(:INLINE_YELLOW, m[:inline_yellow],
+                               lineno: ctx.lineno, offset: m.offset(:inline_yellow),
+                                value: card)
+         elsif m[:inline_red]
+              card = {}
+              card[:m]      = m[:minute].to_i(10)  if m[:minute]
+              card[:offset] = m[:offset].to_i(10)  if m[:offset]
+              Token.new(:INLINE_RED, m[:inline_red],
+                              lineno: ctx.lineno, offset: m.offset(:inline_red),
+                              value: card)
+         elsif m[:inline_yellow_red]
+              card = {}
+              card[:m]      = m[:minute].to_i(10)  if m[:minute]
+              card[:offset] = m[:offset].to_i(10)  if m[:offset]
+              Token.new(:INLINE_YELLOW_RED, m[:inline_yellow_red],
+                               lineno: ctx.lineno, offset: m.offset(:inline_yellow_red),
+                               value: card)
+         elsif m[:prop_name]
+              Token.new(:PROP_NAME, m[:name],
+                               lineno: ctx.lineno, offset: m.offset(:prop_name))
+         elsif m[:minute]
+              Token.new(:MINUTE, m[:minute],
+                           lineno: ctx.lineno, offset: m.offset(:minute),
+                           value: _build_minute( m ))
+         elsif m[:sym]
+              Token.literal( m[:sym], lineno: ctx.lineno, offset: m.offset(:sym))
+         else
+             ctx.warn_on_else( m, mode: 'PROP_LINEUP' )
+             nil
+         end
+end
+
+
+end ## class Lexer
+end ## module SportDb

data/lib/sportdb/parser/lexer-on_prop_misc.rb

@@ -0,0 +1,110 @@
+module SportDb
+class Lexer
+
+
+
+## note - no inline keys possible
+##         todo/fix - use custom (limited) prop basics too
+PROP_CARDS_RE =  Regexp.union(
+   SPACES_RE,
+   MINUTE_RE,
+   PROP_NAME_RE,
+   /  (?<sym>  [;,-]) /x
+   ## todo/fix - add ANY_RE here too!!!
+)
+
+
+def _on_prop_cards( m, ctx: )      ## note - m is MatchData object
+
+         if m[:space] || m[:spaces]
+              nil    ## skip space(s)
+         elsif m[:prop_name]
+              Token.new(:PROP_NAME, m[:name],
+                               lineno: ctx.lineno, offset: m.offset(:prop_name))
+         elsif m[:minute]
+              Token.new(:MINUTE, m[:minute],
+                           lineno: ctx.lineno, offset: m.offset(:minute),
+                           value: _build_minute( m ))
+         elsif m[:sym]
+              Token.literal( m[:sym], lineno: ctx.lineno, offset: m.offset(:sym))
+         else
+             ctx.warn_on_else( m, mode: 'PROP_CARDS' )
+             nil
+         end
+end
+
+
+
+PROP_ATTENDANCE_RE  = Regexp.union(
+   SPACES_RE,
+   ENCLOSED_NAME_RE,       # e.g. (sold out) etc.  why? why not?
+   PROP_NUM_RE,                 # e.g. 28 000 or 28_000  (NOT 28,000 is not valid!!!)
+   ## todo/fix - add ANY_RE here too!!!
+)
+
+def _on_prop_attendance( m, ctx: )      ## note - m is MatchData object
+
+         if m[:space] || m[:spaces]
+              nil    ## skip space(s)
+         elsif m[:enclosed_name]
+              ## reserverd for use for sold out or such (in the future) - why? why not?
+             Token.new(:ENCLOSED_NAME, m[:name],
+                             lineno: ctx.lineno, offset: m.offset(:name))
+         elsif m[:num]
+             Token.new(:PROP_NUM, m[:num],
+                             lineno: ctx.lineno, offset: m.offset(:num),
+                             value: m[:value].to_i(10))
+         else
+            ctx.warn_on_else( m, mode: 'PROP_ATTENDANCE' )
+            nil
+         end
+end
+
+
+
+PROP_REFEREE_RE = Regexp.union(
+   SPACES_RE,
+   ENCLOSED_NAME_RE,       # e.g. (sold out) etc.  why? why not?
+   PROP_NUM_RE,                 # e.g. 28 000 or 28_000  (NOT 28,000 is not valid!!!)
+   PROP_KEY_INLINE_RE,
+   PROP_NAME_RE,
+   /  (?<sym>  [;,]) /x
+   ## todo/fix - add ANY_RE here too!!!
+)
+
+def _on_prop_referee( m, ctx: )      ## note - m is MatchData object
+
+         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 ['att', 'attn', 'attendance' ].include?( key.downcase )
+                ## use ATTENDANCE_PROP or ATTENDANCE_KEY or such - why? why not?
+                Token.new(:ATTENDANCE, m[:key],
+                                 lineno: ctx.lineno, offset: m.offset(:key))
+              else
+                ## report error - for unknown (inline) prop key in lineup
+                nil
+              end
+         elsif m[:prop_name]    ## note - change prop_name to player or to (plain) name?
+              Token.new(:PROP_NAME, m[:name],
+                               lineno: ctx.lineno, offset: m.offset(:prop_name))
+         elsif m[:num]
+             Token.new(:PROP_NUM, m[:num],
+                             lineno: ctx.lineno, offset: m.offset(:num),
+                             value: m[:value].to_i(10))
+         elsif m[:enclosed_name]
+              ## use HOLD,SAVE,POST or such keys - why? why not?
+             Token.new(:ENCLOSED_NAME, m[:name],
+                             lineno: ctx.lineno, offset: m.offset(:name))
+         elsif m[:sym]
+              Token.literal( m[:sym], lineno: ctx.lineno, offset: m.offset(:sym))
+         else
+            ctx.warn_on_else( m, mode: 'PROP_REFEREE' )
+            nil
+         end
+end
+
+end ## class Lexer
+end ## module SportDb

data/lib/sportdb/parser/lexer-on_prop_penalties.rb

@@ -0,0 +1,40 @@
+module SportDb
+class Lexer
+
+
+
+
+PROP_PENALTIES_RE = Regexp.union(
+   SPACES_RE,
+   SCORE_RE,               # e.g. 1-1 etc.
+   ENCLOSED_NAME_RE,       # e.g. (save), (post), etc.
+   PROP_NAME_RE,
+    /  (?<sym>  [;,]) /x    ## add [] too - why? why not?
+   ## todo/fix - add ANY_RE here too!!!
+)
+
+def _on_prop_penalties( m, ctx: )      ## note - m is MatchData object
+         if m[:space] || m[:spaces]
+              nil    ## skip space(s)
+         elsif m[:prop_name]    ## note - change prop_name to player
+              Token.new(:PROP_NAME, m[:name],
+                               lineno: ctx.lineno, offset: m.offset(:prop_name))
+         elsif m[:enclosed_name]
+              ## use HOLD,SAVE,POST or such keys - why? why not?
+             Token.new(:ENCLOSED_NAME, m[:name],
+                             lineno: ctx.lineno, offset: m.offset(:name))
+         elsif m[:score]
+             Token.new( :SCORE, m[:score],
+                              lineno: ctx.lineno, offset: m.offset(:score),
+                              value: _build_score( m ))
+         elsif m[:sym]
+              Token.literal( m[:sym], lineno: ctx.lineno, offset: m.offset(:sym))
+         else
+            ctx.warn_on_else( m, mode: 'PROP_PENALTIES ')
+            nil
+         end
+end
+
+
+end ## class Lexer
+end ## module SportDb

data/lib/sportdb/parser/lexer-on_round_def.rb

@@ -0,0 +1,37 @@
+module SportDb
+class Lexer
+
+
+
+### note - add comma (,) as optional separator
+ROUND_DEF_RE = Regexp.union(  SPACES_RE,
+                              DURATION_RE,  # note - duration MUST match before date
+                              DATE_RE,  ## note - date must go before time (e.g. 12.12. vs 12.12)
+                              / (?<sym> [:|,] ) /x,
+                              ANY_RE
+                           )
+
+
+def _on_round_def( m, ctx: )      ## note - m is MatchData object
+
+
+           if m[:spaces] || m[:space]
+               nil    ## skip spaces
+           elsif m[:date]
+              Token.new(:DATE, m[:date],
+                           lineno: ctx.lineno, offset: m.offset(:date),
+                           value: _build_date(m))
+           elsif m[:duration]
+              Token.new(:DURATION, m[:duration],
+                            lineno: ctx.lineno, offset: m.offset(:duration),
+                            value: _build_duration( m ))
+           elsif m[:sym]
+              Token.literal( m[:sym], lineno: ctx.lineno, offset: m.offset(:sym))
+           else
+              ctx.warn_on_else( m, mode: 'ROUND_DEF' )
+              nil
+           end
+end
+
+end ## class Lexer
+end ## module SportDb

data/lib/sportdb/parser/lexer-on_top.rb

@@ -0,0 +1,125 @@
+module SportDb
+class Lexer
+
+
+def _on_top( m, ctx: )      ## note - m is MatchData object
+
+        ##  note - top-level (for now always) assumes TEAM for TEXT match!!
+        ##           fix/fix/fix change TEXT_RE/:text to  TEAM_RE/:team !!!
+
+        if m[:space] || m[:spaces]
+           nil   ## skip space(s)
+        elsif m[:text]         then Token.new(:TEAM,  m[:text],
+                                                      lineno: ctx.lineno, offset: m.offset(:text))
+        elsif m[:team_home]    then Token.new(:TEAM_HOME,  m[:team_home],
+                                                      lineno: ctx.lineno, offset: m.offset(:team_home))
+        elsif m[:team_away]    then Token.new(:TEAM_AWAY,  m[:team_away],
+                                                      lineno: ctx.lineno, offset: m.offset(:team_away))
+        elsif m[:team_neutral] then Token.new(:TEAM_NEUTRAL, m[:team_neutral],
+                                                      lineno: ctx.lineno, offset: m.offset(:team_neutral))
+
+        ## (match) status e.g. cancelled, awarded, etc.
+        ##  inline:  w/o - walkover
+        ##           n/p - not played
+        ##           bye
+        ##           abd/abd. - abandoned
+        ##           void
+        ##           susp/susp. - suspended
+        ##           ppd/ppd. or postp/postp. - postponed
+        ##           awd/awd. - awarded
+        ##           canc/canc. - cancelled/canceled
+        elsif m[:inline_wo]   then Token.new(:INLINE_WO, m[:inline_wo],
+                                                  lineno: ctx.lineno, offset: m.offset(:inline_wo))
+        elsif m[:inline_np]   then Token.new(:INLINE_NP, m[:inline_np],
+                                                  lineno: ctx.lineno, offset: m.offset(:inline_np))
+        elsif m[:inline_bye]  then Token.new(:INLINE_BYE, m[:inline_bye],
+                                                  lineno: ctx.lineno, offset: m.offset(:inline_bye))
+        elsif m[:inline_abd]  then Token.new(:INLINE_ABD, m[:inline_abd],
+                                                  lineno: ctx.lineno, offset: m.offset(:inline_abd))
+        elsif m[:inline_void] then Token.new(:INLINE_VOID, m[:inline_void],
+                                                  lineno: ctx.lineno, offset: m.offset(:inline_void))
+        elsif m[:inline_susp] then Token.new(:INLINE_SUSP, m[:inline_susp],
+                                                  lineno: ctx.lineno, offset: m.offset(:inline_susp))
+        elsif m[:inline_ppd]  then Token.new(:INLINE_PPD, m[:inline_ppd],
+                                                  lineno: ctx.lineno, offset: m.offset(:inline_ppd))
+        elsif m[:inline_awd]  then Token.new(:INLINE_AWD, m[:inline_awd],
+                                                  lineno: ctx.lineno, offset: m.offset(:inline_awd))
+        elsif m[:inline_canc] then Token.new(:INLINE_CANC, m[:inline_canc],
+                                                  lineno: ctx.lineno, offset: m.offset(:inline_canc))
+        elsif m[:status]      then Token.new(:STATUS, m[:status],
+                                                  lineno: ctx.lineno, offset: m.offset(:status),
+                                                  value: _build_status( m ))
+        elsif m[:note]
+            ###  todo/check:
+            ##      use value hash - why? why not? or simplify to:
+            ## [:NOTE, [m[:note], {note: m[:note] } ]]
+             Token.new(:NOTE, m[:note],
+                               lineno: ctx.lineno, offset: m.offset(:note))
+
+        elsif m[:attendance]
+             att = {}
+             att[:value] = m[:value].gsub( '_', '' ).to_i(10)
+             ## note - for token id use INLINE_ATTENDANCE  (ATTENDANCE in use for prop!!!)
+            Token.new(:INLINE_ATTENDANCE, m[:attendance],
+                                   lineno: ctx.lineno, offset: m.offset(:attendance),
+                                          value: att)
+
+        elsif m[:time]         then Token.new(:TIME, m[:time],
+                                                lineno: ctx.lineno, offset: m.offset(:time),
+                                                value: _build_time(m))
+        elsif m[:date]         then Token.new(:DATE, m[:date],
+                                                lineno: ctx.lineno, offset: m.offset(:date),
+                                                value: _build_date(m))
+        elsif m[:date_legs]    then Token.new(:DATE_LEGS, m[:date_legs],
+                                                 lineno: ctx.lineno, offset: m.offset(:date_legs),
+                                                 value: _build_date_legs(m))
+
+        elsif m[:score_legs]   then Token.new(:SCORE_LEGS, m[:score_legs],
+                                                  lineno: ctx.lineno, offset: m.offset(:score_legs),
+                                                  value: _build_score_legs( m ))
+        elsif m[:score_full]   then Token.new(:SCORE_FULL, m[:score_full],
+                                                  lineno: ctx.lineno, offset: m.offset(:score_full),
+                                                  value: _build_score_full( m ))
+        elsif m[:score_fuller] then Token.new(:SCORE_FULLER, m[:score_fuller],
+                                                  lineno: ctx.lineno, offset: m.offset(:score_fuller),
+                                                  value: _build_score_fuller( m ))
+        elsif m[:score_fuller_more] then Token.new(:SCORE_FULLER_MORE, m[:score_fuller_more],
+                                                      lineno: ctx.lineno, offset: m.offset(:score_fuller_more),
+                                                      value: _build_score_fuller_more( m ))
+        elsif m[:score]      then Token.new(:SCORE,  m[:score],
+                                                lineno: ctx.lineno, offset: m.offset(:score),
+                                                value: _build_score( m ))
+        elsif m[:score_awd]  then Token.new(:SCORE_AWD, m[:score_awd],
+                                                lineno: ctx.lineno, offset: m.offset(:score_awd),
+                                                value: _build_score_awd( m ))
+        elsif m[:score_abd]  then Token.new(:SCORE_ABD, m[:score_abd],
+                                                lineno: ctx.lineno, offset: m.offset(:score_abd),
+                                                value: _build_score_abd( m ))
+
+        elsif m[:vs]         then Token.new(:VS, m[:vs],
+                                              lineno: ctx.lineno, offset: m.offset(:vs))
+        elsif m[:sym]
+          case m[:sym]  ## return symbols "inline" as is - why? why not?
+          when '@'    ##  enter geo mode
+            _trace( 'ENTER GEO_RE MODE' )
+            @re = GEO_RE
+            @geo_count = 0
+            Token.literal( m[:sym], lineno: ctx.lineno, offset: m.offset(:sym))
+          when '('    ## enter goal scorer mode on "free-floating" open paranthesis!!!
+             _trace( 'ENTER GOAL_RE MODE' )
+             @re = GOAL_RE
+              ## note - eat-up ( for now; do NOT pass along as token
+              ##       pass along "virutal" INLINE GOALS - why? why not?
+              Token.virtual( :INLINE_GOALS, lineno: ctx.lineno )
+          else
+            Token.literal( m[:sym], lineno: ctx.lineno, offset: m.offset(:sym))
+          end
+        else
+           ctx.warn_on_else( m )
+           nil
+        end
+end
+
+
+end ## class Lexer
+end ## module SportDb