sportdb-parser 0.4.0 → 0.5.1

data/lib/sportdb/parser/parser.rb

@@ -1,214 +1,822 @@
-module SportDb
-class Parser
-
-
-## transforms
-##
-##  Netherlands  1-2 (1-1)   England
-##   =>  text => team
-##       score|vs
-##       text => team
-
-
-## token iter/find better name
-##  e.g. TokenBuffer/Scanner or such ??
-class Tokens
-    def initialize( tokens )
-        @tokens = tokens
-        @pos = 0
-    end
-
-    def pos()  @pos; end
-    def eos?() @pos >= @tokens.size; end
-
-
-    def include?( *types )
-        pos = @pos
-        ## puts "  starting include? #{types.inspect} @ #{pos}"
-        while pos < @tokens.size do
-            return true   if types.include?( @tokens[pos][0] )
-            pos +=1
-        end
-        false
-    end
-
-    ## pattern e.g. [:text, [:vs,:score], :text]
-    def match?( *pattern )
-        ## puts "  starting match? #{pattern.inspect} @ #{@pos}"
-        pattern.each_with_index do |types,offset|
-            ## if single symbol wrap in array
-            types = types.is_a?(Array) ? types : [types]
-            return false  unless types.include?( peek(offset) )
-        end
-        true
-    end
-
-
-    ## return token type  (e.g. :text, :num, etc.)
-    def cur()           peek(0); end
-    ## return content (assumed to be text)
-    def text(offset=0)
-        ## raise error - why? why not?
-        ##   return nil?
-        if peek( offset ) != :text
-            raise ArgumentError, "text(#{offset}) - token not a text type"
-        end
-        @tokens[@pos+offset][1]
-    end
-
-
-    def peek(offset=1)
-        ## return nil if eos
-        if @pos+offset >= @tokens.size
-            nil
-        else
-           @tokens[@pos+offset][0]
-        end
-    end
-
-    ## note - returns complete token
-    def next
-       # if @pos >= @tokens.size
-       #     raise ArgumentError, "end of array - #{@pos} >= #{@tokens.size}"
-       # end
-       #   throw (standard) end of iteration here why? why not?
-
-        t = @tokens[@pos]
-        @pos += 1
-        t
-    end
-
-    def collect( &blk )
-        tokens = []
-        loop do
-          break if eos?
-          tokens <<  if block_given?
-                        blk.call( self.next )
-                     else
-                        self.next
-                     end
-        end
-        tokens
-    end
-end  # class Tokens
-
-
-
-##
-##
-##  add !!!!
-##   collect_until e.g. collect_until( :text )
-
-
-def parse_with_errors( line, debug: false )
-    errors = []
-    tokens, token_errors = tokenize_with_errors( line, typed: true )
-    errors += token_errors
-
-#############
-## pass 1
-##   replace all texts with keyword matches (e.g. group, round, leg, etc.)
-     tokens = tokens.map do |t|
-                      if t[0] == :text
-                          text = t[1]
-                          if is_group?( text )
-                             [:group, text]
-                          elsif is_leg?( text )
-                             [:leg, text]
-                          elsif is_round?( text )
-                             [:round, text]
-                          else
-                              t   ## pass through as-is (1:1)
-                          end
-                      else
-                         t
-                      end
-                end
-
-
-    ## puts "tokens:"
-    ## pp tokens
-
-## transform tokens into (parse tree/ast) nodes
-    nodes = []
-
-    buf = Tokens.new( tokens )
-    ## pp buf
-
-
-    loop do
-          break if buf.eos?
-
-          ## simplify - remove separator for round + leg pair
-          ##     e.g.  Round of 16, 1st Leg
-          ##     allow Round of 16 - 1st Leg  too - why? why not?
-          if buf.match?( :round, [:',', :'|',
-                                    :'-',
-                                    :vs,   ### fix - change parser to issue :'-' only for (-) not :vs!!!
-                                    ], :leg )
-                    nodes << [:round, buf.next[1]]
-                    buf.next  ## swallow separator
-                    nodes << [:leg, buf.next[1]]
-                    next
-          end
-
-
-          if buf.pos == 0   ## MUST start line
-            ## check for
-            ##    group def or round def
-            if buf.match?( :round, :'|', [:date, :duration] )    ## assume round def (change round to round_def)
-                      nodes << [:round_def, buf.next[1]]
-                      buf.next ## swallow pipe
-                      nodes += buf.collect
-                      break
-            end
-            if buf.match?( :group, :'|', :text )    ## assume group def (change group to group_def)
-                      nodes << [:group_def, buf.next[1]]
-                      buf.next ## swallow pipe
-                      ## change all text to team
-                      nodes += buf.collect { |t|
-                                t[0] == :text ? [:team, t[1]] : t
-                               }
-                      break
-            end
-          end
-
-
-          if buf.match?( :text, :'-', :text )  ## hacky? convert "generic" :- to :vs
-             nodes << [:team, buf.next[1]]     ##    keep this rule/option - why? why not?
-             nodes << [:vs]
-             nodes << [:team, buf.next[1]]
-          elsif buf.match?( :text, [:score, :vs], :text )
-             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
-          elsif buf.cur == :'@'
-               ## add all to the end as is
-               ##   only change text to geo
-              nodes += buf.collect  { |t|
-                           t[0] == :text ? [:geo, t[1]] : t
-                            }
-              break
-          else
-             ## pass through
-             nodes << buf.next
-          end
-    end
-
-    [nodes,errors]
-end
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.8.1
+# from Racc grammar file "parser.y".
+#
+
+require 'racc/parser.rb'
+class RaccMatchParser < Racc::Parser
+##### State transition tables begin ###
+
+racc_action_table = [
+    29,    50,    12,    92,    28,    53,    26,    50,    22,    33,
+    57,    16,    76,    37,    77,    13,    57,    23,    14,    15,
+    51,    20,    22,    12,    60,    28,    51,    26,    55,    56,
+    60,    38,    16,    26,    55,    56,    13,   108,    23,    14,
+    15,    35,    20,    22,    41,    63,    39,    42,    45,    44,
+   109,    81,    82,    34,    36,    41,    67,    69,    70,    71,
+    72,    94,    95,   106,   107,    47,    61,    65,    66,    79,
+    83,    84,    60,    85,    87,    89,    38,    90,    41,    97,
+    41,    99,    33,   101,    76,    60,   110,   111,   112,   113,
+    60,    41,    41,    33,   116,    60,   118,   119 ]
+
+racc_action_check = [
+     1,    19,     1,    58,     1,    20,     1,    46,    20,    12,
+    23,     1,    33,    15,    33,     1,    47,     1,     1,     1,
+    19,     1,     1,     0,    58,     0,    46,     0,    23,    23,
+    23,    15,     0,    16,    47,    47,     0,    78,     0,     0,
+     0,    13,     0,     0,    16,    25,    16,    17,    17,    17,
+    78,    36,    36,    13,    14,    25,    31,    31,    31,    31,
+    31,    60,    60,    77,    77,    18,    24,    26,    29,    34,
+    39,    40,    41,    43,    49,    51,    53,    54,    62,    63,
+    65,    67,    68,    70,    74,    76,    80,    83,    84,    88,
+    92,    96,    98,   103,   104,   105,   113,   115 ]
+
+racc_action_pointer = [
+    21,     0,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,     1,    37,    38,     9,    27,    43,    48,    -3,
+   -14,   nil,   nil,     4,    62,    38,    60,   nil,   nil,    68,
+   nil,    53,   nil,     3,    52,   nil,    32,   nil,   nil,    58,
+    59,    46,   nil,    55,   nil,   nil,     3,    10,   nil,    70,
+   nil,    58,   nil,    54,    60,   nil,   nil,   nil,    -2,   nil,
+    34,   nil,    61,    75,   nil,    63,   nil,    77,    74,   nil,
+    79,   nil,   nil,   nil,    75,   nil,    59,    50,    33,   nil,
+    82,   nil,   nil,    83,    84,   nil,   nil,   nil,    84,   nil,
+   nil,   nil,    64,   nil,   nil,   nil,    74,   nil,    75,   nil,
+   nil,   nil,   nil,    85,    82,    69,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,    79,   nil,    87,   nil,   nil,   nil,   nil ]
+
+racc_action_default = [
+   -80,   -80,    -1,    -3,    -4,    -5,    -6,    -7,    -8,    -9,
+   -10,   -11,   -80,   -80,   -41,   -50,   -80,   -80,   -80,   -80,
+   -47,   -49,   -52,   -80,   -80,   -64,   -80,   -69,   -79,   -80,
+    -2,   -80,   -13,   -20,   -80,   -39,   -80,   -37,   -51,   -80,
+   -80,   -80,   -40,   -80,   -43,   -44,   -80,   -80,   -46,   -80,
+   -54,   -80,   -48,   -50,   -80,   -59,   -60,   -61,   -71,   -72,
+   -75,   -63,   -80,   -67,   -70,   -80,   120,   -80,   -80,   -15,
+   -16,   -18,   -19,   -21,   -22,   -24,   -80,   -80,   -80,   -32,
+   -80,   -35,   -36,   -80,   -80,   -42,   -45,   -53,   -55,   -56,
+   -58,   -73,   -80,   -76,   -77,   -78,   -66,   -68,   -65,   -12,
+   -14,   -17,   -23,   -80,   -80,   -27,   -29,   -30,   -31,   -33,
+   -34,   -38,   -62,   -80,   -74,   -80,   -26,   -28,   -57,   -25 ]
+
+racc_goto_table = [
+    32,    64,    91,    75,    48,    96,     2,    30,    98,     1,
+    31,    68,    73,    74,   104,   105,    78,    80,    43,    46,
+   103,    52,    88,    40,    62,    93,   nil,   nil,   nil,   nil,
+   nil,    86,   nil,   nil,   nil,   nil,   114,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   102,   nil,   nil,   nil,   nil,   117,
+   nil,   nil,   nil,   nil,   nil,   nil,   100,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    64,   nil,    64,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   115 ]
+
+racc_goto_check = [
+    13,    35,    18,    17,    27,    33,     2,     2,    33,     1,
+    12,    14,    15,    16,    19,    20,    21,    22,    24,    26,
+    18,    28,    30,    32,    34,    37,   nil,   nil,   nil,   nil,
+   nil,    27,   nil,   nil,   nil,   nil,    18,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,    17,   nil,   nil,   nil,   nil,    18,
+   nil,   nil,   nil,   nil,   nil,   nil,    13,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    35,   nil,    35,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,    13 ]
+
+racc_goto_pointer = [
+   nil,     9,     6,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    -2,   -12,   -20,   -21,   -20,   -30,   -56,   -63,
+   -62,   -18,   -19,   nil,     1,   nil,     1,   -15,     1,   nil,
+   -29,   nil,     7,   -57,    -1,   -24,   nil,   -35 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,     3,     4,     5,     6,     7,     8,     9,
+    10,    11,   nil,   nil,   nil,   nil,   nil,   nil,    59,   nil,
+   nil,   nil,   nil,    17,   nil,    18,    19,   nil,    21,    49,
+   nil,    54,    24,    25,   nil,    27,    58,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 30, :_reduce_none,
+  2, 30, :_reduce_none,
+  1, 31, :_reduce_none,
+  1, 31, :_reduce_none,
+  1, 31, :_reduce_none,
+  1, 31, :_reduce_none,
+  1, 31, :_reduce_none,
+  1, 31, :_reduce_none,
+  1, 31, :_reduce_none,
+  1, 31, :_reduce_none,
+  1, 31, :_reduce_none,
+  4, 40, :_reduce_12,
+  1, 41, :_reduce_13,
+  3, 41, :_reduce_14,
+  2, 41, :_reduce_15,
+  1, 43, :_reduce_none,
+  2, 43, :_reduce_17,
+  1, 43, :_reduce_none,
+  1, 43, :_reduce_none,
+  1, 42, :_reduce_20,
+  2, 42, :_reduce_21,
+  1, 44, :_reduce_22,
+  2, 44, :_reduce_23,
+  1, 44, :_reduce_24,
+  4, 46, :_reduce_25,
+  3, 45, :_reduce_26,
+  1, 48, :_reduce_27,
+  2, 48, :_reduce_28,
+  1, 49, :_reduce_none,
+  1, 49, :_reduce_none,
+  4, 35, :_reduce_31,
+  1, 50, :_reduce_32,
+  2, 50, :_reduce_33,
+  4, 36, :_reduce_34,
+  1, 51, :_reduce_35,
+  1, 51, :_reduce_36,
+  2, 32, :_reduce_37,
+  4, 32, :_reduce_38,
+  2, 33, :_reduce_39,
+  2, 34, :_reduce_40,
+  1, 52, :_reduce_41,
+  3, 52, :_reduce_42,
+  1, 53, :_reduce_none,
+  1, 53, :_reduce_none,
+  3, 37, :_reduce_45,
+  2, 37, :_reduce_46,
+  1, 54, :_reduce_47,
+  2, 54, :_reduce_48,
+  1, 54, :_reduce_none,
+  1, 57, :_reduce_50,
+  2, 57, :_reduce_51,
+  1, 57, :_reduce_52,
+  2, 56, :_reduce_53,
+  1, 56, :_reduce_54,
+  2, 58, :_reduce_55,
+  1, 59, :_reduce_56,
+  3, 59, :_reduce_57,
+  3, 55, :_reduce_58,
+  1, 60, :_reduce_59,
+  1, 60, :_reduce_60,
+  1, 60, :_reduce_61,
+  4, 38, :_reduce_62,
+  2, 38, :_reduce_63,
+  1, 61, :_reduce_64,
+  3, 61, :_reduce_65,
+  3, 61, :_reduce_66,
+  1, 63, :_reduce_none,
+  2, 63, :_reduce_none,
+  1, 62, :_reduce_69,
+  2, 62, :_reduce_70,
+  2, 64, :_reduce_71,
+  1, 65, :_reduce_72,
+  2, 65, :_reduce_73,
+  3, 65, :_reduce_74,
+  1, 47, :_reduce_75,
+  2, 47, :_reduce_76,
+  1, 66, :_reduce_77,
+  1, 66, :_reduce_78,
+  1, 39, :_reduce_79 ]
+
+racc_reduce_n = 80
+
+racc_shift_n = 120
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :PROP => 2,
+  "." => 3,
+  :NEWLINE => 4,
+  "," => 5,
+  "-" => 6,
+  ";" => 7,
+  :PROP_NAME => 8,
+  "(" => 9,
+  ")" => 10,
+  "[" => 11,
+  "]" => 12,
+  :YELLOW_CARD => 13,
+  :RED_CARD => 14,
+  :GROUP => 15,
+  "|" => 16,
+  :TEXT => 17,
+  :ROUND => 18,
+  :DATE => 19,
+  :DURATION => 20,
+  :ORD => 21,
+  :TIME => 22,
+  "@" => 23,
+  :SCORE => 24,
+  :VS => 25,
+  :MINUTE => 26,
+  :OG => 27,
+  :PEN => 28 }
+
+racc_nt_base = 29
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+Ractor.make_shareable(Racc_arg) if defined?(Ractor)
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "PROP",
+  "\".\"",
+  "NEWLINE",
+  "\",\"",
+  "\"-\"",
+  "\";\"",
+  "PROP_NAME",
+  "\"(\"",
+  "\")\"",
+  "\"[\"",
+  "\"]\"",
+  "YELLOW_CARD",
+  "RED_CARD",
+  "GROUP",
+  "\"|\"",
+  "TEXT",
+  "ROUND",
+  "DATE",
+  "DURATION",
+  "ORD",
+  "TIME",
+  "\"@\"",
+  "SCORE",
+  "VS",
+  "MINUTE",
+  "OG",
+  "PEN",
+  "$start",
+  "statements",
+  "statement",
+  "date_header",
+  "group_header",
+  "round_header",
+  "group_def",
+  "round_def",
+  "match_line",
+  "goal_lines",
+  "empty_line",
+  "lineup_lines",
+  "lineup",
+  "lineup_name",
+  "lineup_sep",
+  "lineup_name_more",
+  "card",
+  "lineup_sub",
+  "minute",
+  "card_body",
+  "card_type",
+  "team_values",
+  "round_date_opts",
+  "round_values",
+  "round_sep",
+  "match_opts",
+  "match",
+  "more_match_opts",
+  "date_opts",
+  "geo_opts",
+  "geo_values",
+  "score_value",
+  "goal_lines_body",
+  "goals",
+  "goal_sep",
+  "goal",
+  "minutes",
+  "minute_opts" ]
+Ractor.make_shareable(Racc_token_to_s_table) if defined?(Ractor)
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+# reduce 1 omitted
+
+# reduce 2 omitted
+
+# reduce 3 omitted
+
+# reduce 4 omitted
+
+# reduce 5 omitted
+
+# reduce 6 omitted
+
+# reduce 7 omitted
+
+# reduce 8 omitted
+
+# reduce 9 omitted
+
+# reduce 10 omitted
+
+# reduce 11 omitted
+
+module_eval(<<'.,.,', 'parser.y', 30)
+  def _reduce_12(val, _values, result)
+      @tree << LineupLine.new( team:    val[0],
+                                                    lineup:  val[1]
+                                                  ) 
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 37)
+  def _reduce_13(val, _values, result)
+     result = [[val[0]]]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 40)
+  def _reduce_14(val, _values, result)
+                           ## if lineup_sep is -  start a new sub array!!
+                       if val[1] == '-'
+                          result << [val[2]]
+                       else
+                          result[-1] << val[2]
+                       end
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 48)
+  def _reduce_15(val, _values, result)
+     result = val[0]
+    result
+  end
+.,.,
+
+# reduce 16 omitted
+
+module_eval(<<'.,.,', 'parser.y', 52)
+  def _reduce_17(val, _values, result)
+     result = val[0]
+    result
+  end
+.,.,
+
+# reduce 18 omitted
+
+# reduce 19 omitted
+
+module_eval(<<'.,.,', 'parser.y', 58)
+  def _reduce_20(val, _values, result)
+                                  result = Lineup.new( name: val[0] )
+
+    result
+  end
+.,.,
 
+module_eval(<<'.,.,', 'parser.y', 62)
+  def _reduce_21(val, _values, result)
+                                  kwargs = { name: val[0] }.merge( val[1] )
+                              result = Lineup.new( **kwargs )
 
-### convience helper - ignore errors by default
-def parse( line, debug: false )
-  nodes, _ = parse_with_errors( line, debug: debug )
-  nodes
-end
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 68)
+  def _reduce_22(val, _values, result)
+                                  result = { card: val[0] }
 
+    result
+  end
+.,.,
 
-end #  class Parser
-end  # module SportDb
+module_eval(<<'.,.,', 'parser.y', 72)
+  def _reduce_23(val, _values, result)
+                                  result = { card: val[0], sub: val[1] }
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 76)
+  def _reduce_24(val, _values, result)
+                                  result = { sub: val[0] }
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 82)
+  def _reduce_25(val, _values, result)
+                                  result = Sub.new( minute: val[1], sub: val[2] )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 88)
+  def _reduce_26(val, _values, result)
+                                  kwargs = val[1]
+                              result = Card.new( **kwargs )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 93)
+  def _reduce_27(val, _values, result)
+     result = { name: val[0] }
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 96)
+  def _reduce_28(val, _values, result)
+     result = { name: val[0], minute: val[1] }
+    result
+  end
+.,.,
+
+# reduce 29 omitted
+
+# reduce 30 omitted
+
+module_eval(<<'.,.,', 'parser.y', 107)
+  def _reduce_31(val, _values, result)
+                          @tree << GroupDef.new( name:  val[0],
+                                             teams: val[2] )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 113)
+  def _reduce_32(val, _values, result)
+                                                   result = val
+                                               ## e.g. val is ["Austria"] 
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 117)
+  def _reduce_33(val, _values, result)
+                                                   result.push( val[1] )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 126)
+  def _reduce_34(val, _values, result)
+                          kwargs = { name: val[0] }.merge( val[2] )
+                      @tree<< RoundDef.new( **kwargs )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 131)
+  def _reduce_35(val, _values, result)
+     result = { date: val[0][1] }
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 132)
+  def _reduce_36(val, _values, result)
+     result = { duration: val[0][1] }
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 138)
+  def _reduce_37(val, _values, result)
+                         @tree <<  DateHeader.new( date: val[0][1] )  
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 142)
+  def _reduce_38(val, _values, result)
+                         @tree <<  DateHeader.new( date: val[1][1] )  
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 149)
+  def _reduce_39(val, _values, result)
+                         @tree <<  GroupHeader.new( name: val[0] )  
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 159)
+  def _reduce_40(val, _values, result)
+                         @tree <<  RoundHeader.new( names: val[0] )  
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 162)
+  def _reduce_41(val, _values, result)
+      result = val
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 163)
+  def _reduce_42(val, _values, result)
+       result.push( val[2] )
+    result
+  end
+.,.,
+
+# reduce 43 omitted
+
+# reduce 44 omitted
+
+module_eval(<<'.,.,', 'parser.y', 174)
+  def _reduce_45(val, _values, result)
+                           puts "match:"
+                       pp val[1]
+                       puts "more match opts:"
+                       pp val[2]  
+
+                       kwargs = {}.merge( val[0], val[1], val[2] )
+                       @tree << MatchLine.new( **kwargs )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 184)
+  def _reduce_46(val, _values, result)
+                          kwargs = {}.merge( val[0], val[1] )
+                      @tree << MatchLine.new( **kwargs )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 189)
+  def _reduce_47(val, _values, result)
+       result = { ord: val[0][1][:value] }
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 190)
+  def _reduce_48(val, _values, result)
+       result = { ord: val[0][1][:value] }.merge( val[1] )
+    result
+  end
+.,.,
+
+# reduce 49 omitted
+
+module_eval(<<'.,.,', 'parser.y', 194)
+  def _reduce_50(val, _values, result)
+       result = { date: val[0][1]}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 195)
+  def _reduce_51(val, _values, result)
+       result = { date: val[0][1], time: val[1][1] }
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 196)
+  def _reduce_52(val, _values, result)
+       result = { time: val[0][1]}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 200)
+  def _reduce_53(val, _values, result)
+     result = { geo: val[0]}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 201)
+  def _reduce_54(val, _values, result)
+     result = {}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 205)
+  def _reduce_55(val, _values, result)
+     result = val[1]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 208)
+  def _reduce_56(val, _values, result)
+      result = val
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 209)
+  def _reduce_57(val, _values, result)
+      result.push( val[2] )
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 214)
+  def _reduce_58(val, _values, result)
+                             result = { team1: val[0],
+                                    team2: val[2]
+                                  }.merge( val[1] )   
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 219)
+  def _reduce_59(val, _values, result)
+      result = { score: val[0][1] }
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 220)
+  def _reduce_60(val, _values, result)
+      result = {}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 221)
+  def _reduce_61(val, _values, result)
+      result = {}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 238)
+  def _reduce_62(val, _values, result)
+                           kwargs = val[1]
+                       @tree << GoalLine.new( **kwargs )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 243)
+  def _reduce_63(val, _values, result)
+                             kwargs = val[0]
+                         @tree << GoalLine.new( **kwargs )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 248)
+  def _reduce_64(val, _values, result)
+      result = { goals1: val[0],
+                                                              goals2: [] } 
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 251)
+  def _reduce_65(val, _values, result)
+      result = { goals1: [],
+                                                              goals2: val[2] } 
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 254)
+  def _reduce_66(val, _values, result)
+      result = { goals1: val[0],
+                                                              goals2: val[2] }
+
+    result
+  end
+.,.,
+
+# reduce 67 omitted
+
+# reduce 68 omitted
+
+module_eval(<<'.,.,', 'parser.y', 268)
+  def _reduce_69(val, _values, result)
+     result = val
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 269)
+  def _reduce_70(val, _values, result)
+     result.push( val[1])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 274)
+  def _reduce_71(val, _values, result)
+                    result = Goal.new( player:  val[0],
+                                   minutes: val[1] )   
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 281)
+  def _reduce_72(val, _values, result)
+     result = val
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 282)
+  def _reduce_73(val, _values, result)
+     result.push( val[1])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 283)
+  def _reduce_74(val, _values, result)
+     result.push( val[2])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 289)
+  def _reduce_75(val, _values, result)
+                            kwargs = {}.merge( val[0][1] )
+                        result = Minute.new( **kwargs )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 294)
+  def _reduce_76(val, _values, result)
+                            kwargs = { }.merge( val[0][1] ).merge( val[1] )
+                        result = Minute.new( **kwargs )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 298)
+  def _reduce_77(val, _values, result)
+      result = { og: true }
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 299)
+  def _reduce_78(val, _values, result)
+      result = { pen: true }
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 304)
+  def _reduce_79(val, _values, result)
+     puts '  MATCH empty_line'
+    result
+  end
+.,.,
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
 
+end   # class RaccMatchParser