sportdb-parser 0.7.1 → 0.8.0

data/lib/sportdb/parser/parse_tree-props.rb

@@ -0,0 +1,233 @@
+module SportDb
+  class Parser
+
+
+=begin
+RefereeLine = Struct.new( :name, :country ) do
+  def pretty_print( printer )
+    printer.text( "<RefereeLine " )
+    printer.text( name )
+    printer.text( " (#{country})" )  if country
+    printer.text( ">" )
+  end
+end
+=end
+
+
+## support multiple referees (incl. assistant refs etc.)
+RefereeLine = Struct.new( :referees ) do
+  def pretty_print( q )
+    q.group( 4, '<RefereeLine ', '>') do
+      q.pp( referees )
+    end
+  end
+end   # RefereeLine
+
+Referee = Struct.new( :name, :country ) do
+  def to_s
+    buf = String.new
+    buf <<  name
+    buf << " (#{country})"    if country
+    buf
+  end
+
+  def pretty_print( q )
+    q.text( to_s )
+  end
+end  # Referee
+
+
+AttendanceLine = Struct.new( :att ) do
+  def pretty_print( q )
+    q.group( 4, '<AttendanceLine ', '>') do
+      q.pp( att )
+    end
+  end
+end  # AttendanceLine
+
+
+
+
+PenaltiesLine = Struct.new( :penalties ) do
+  def as_json(*)
+    ['<PenaltiesLine>', { 'penalties' => penalties.as_json }]
+  end
+
+  def pretty_print( q )
+    q.group( 4, '< ', '>') do
+      q.pp( penalties )
+    end
+  end
+end  # PenaltiesLine
+
+
+Penalty = Struct.new( :name, :score, :note ) do
+  def as_json(*)
+   h = { 'name' => name }
+   h['score'] =  "#{score[0]}-#{score[1]}"   if score
+   h['note']  =  "(#{note})"                 if note
+
+   ## ['<Penalty>', h]
+   h   # note - return "inline" json object
+  end
+
+  def to_s
+    buf = String.new
+    buf << "#{score[0]}-#{score[1]} "   if score
+    buf <<  name
+    buf << " (#{note})"    if note
+    buf
+  end
+
+
+  def pretty_print( q )
+    q.text( to_s )
+  end
+end  # Penalty
+
+
+
+
+##  find a better name for player (use bookings?) - note - red/yellow card for trainer possible
+CardsLine = Struct.new( :type,
+                        :bookings,
+                         ) do
+  def pretty_print( q )
+    q.group( 4, '<CardsLine ', '>') do
+      q.text( type )
+      ## note - either (all-in-one or undetermined) bookings: []
+      ##                               or bookings1/2 aka:    [[],[]]
+      q.text( " bookings=" )
+      q.pp( bookings )
+    end
+  end
+end  # CardsLine
+
+
+Booking = Struct.new( :name, :minute ) do
+  def to_s
+    buf = String.new
+    buf << "#{name}"
+    buf << " #{minute.to_s}"   if minute
+    buf
+  end
+
+  def pretty_print( q )
+    q.text( to_s )
+  end
+end  # Booking
+
+
+
+
+##
+## change :lineup to :lineups  (e.g. requires array of lineups)
+LineupLine = Struct.new( :team, :lineup, :coach ) do
+  def as_json(*)
+    h = { 'team'    => team.as_json,
+          'lineups' => lineup.as_json
+        }
+    h['coach']  =  coach.as_json               if coach
+
+    ['<LineupLine>', h]
+  end
+
+  def pretty_print( q )
+    q.group( 4, '<LineupLine ', '>') do
+      q.text( team )
+      q.text( ' ' )
+
+      ##  todo/fix - check for   "flat" items - no formation
+      ##                           or empty lineup (possible?)
+      ## add formation e.g. (1-) 3-4-2-1
+      formation = lineup.map { |item| item.size }
+      ## note - remove first entry (assume it's 1 for goalee!)
+      formation.shift
+      q.text( formation.join('-'))
+      q.text( ' ')
+
+      q.pp( lineup )
+
+      if coach
+        q.breakable
+        q.text( "coach=" + coach )
+      end
+    end
+  end
+end  # LineupLine
+
+
+Lineup     = Struct.new( :name, :captain, :cards, :sub ) do
+  def as_json(*)
+    h = { 'name'   => name.as_json }
+    h['captain']   =  captain.as_json   if captain
+    h['cards']     =  cards.as_json     if cards
+    h['sub']       =  sub.as_json       if sub
+
+    ## ['<Lineup>', h]
+    h     ## note - return "inline" json object (not tagged array with json object)
+  end
+
+  def pretty_print( q )
+    q.group( 0, '', '') do    ##  group( indent, open, close)
+      q.text( name )
+      q.text( ' [c]' )   if captain
+
+      if cards
+        q.text( ' ' )
+        q.pp( cards )
+      end
+
+      if sub
+        q.breakable   ## can become either a space or a newline
+        q.pp( sub )
+      end
+    end
+  end
+end  # Lineup
+
+
+
+
+
+Card       = Struct.new( :name, :minute ) do
+  def as_json(*)  to_s; end
+
+  def to_s
+    buf = String.new
+    buf << "#{name}"
+    buf << " #{minute.to_s}"   if minute
+    buf
+  end
+
+  def pretty_print( q )
+    q.text( to_s )
+  end
+end
+
+
+
+##
+##  fix-fix-fix
+##    change :sub  to :lineup  - why? why not?
+
+Sub        = Struct.new( :minute, :sub )  do
+  def as_json(*)
+    h = { 'lineup' => sub.as_json }
+    h['minute'] =  minute.as_json       if minute
+
+    ## ['<Sub>', h]
+    h  # note - return "inline" json object (not tagged array with json object)
+  end
+
+  def pretty_print( q )
+    q.group( 0, '(', ')') do
+       q.text( "#{minute.to_s} " )   if minute
+       q.pp( sub )
+    end
+  end
+end  # Sub
+
+
+  end   # class Parser
+end   # module SportDb

data/lib/sportdb/parser/parse_tree.rb

@@ -0,0 +1,202 @@
+
+####
+#   Parser support machinery (incl. node classes/abstract syntax tree)
+
+
+module SportDb
+  class Parser
+
+
+GroupDef   = Struct.new( :name, :teams ) do
+
+  def as_json(*)
+    ["<GroupDef>", { 'name'   => name.as_json,
+                     'teams'  => teams.as_json }
+    ]
+  end
+
+  def pretty_print( q )
+    q.group( 4, '<GroupDef ', '>' ) do        ##  group( indent, open, close)
+      q.text( name )
+      q.text( " teams=" )
+      q.pp( teams )
+    end
+  end
+end  # GroupDef
+
+
+
+##
+## note -   for now exclusive really
+##                    either date OR duration
+RoundDef   = Struct.new( :name, :date, :duration )  do
+
+  def as_json(*)
+    h = { 'name' => name.as_json }
+
+    h['date']     = date.as_json      if date
+    h['duration'] = duration.as_json  if duration
+
+    ["<RoundDef>", h]
+  end
+
+  def pretty_print( q )
+    q.group( 4, '<RoundDef ', '>' ) do
+      q.text( name )
+      if date
+        q.text( " date=")
+        q.pp( date )
+      end
+      if duration
+        q.text( " duration=")
+        q.pp( duration )
+      end
+    end
+  end
+
+end  # RoundDef
+
+
+##
+## note -   for now exclusive really
+##                    either date OR year
+DateHeader = Struct.new( :date, :year ) do
+
+  def as_json(*)
+    h = {}
+    h['date']   = date.as_json     if date
+    h['year']   = year.as_json     if year
+
+    ['<DateHeader>', h]
+  end
+
+
+  def pretty_print( q )
+    q.group( 4, '<DateHeader ', '>' ) do
+      q.pp( date )  if date
+      q.pp( year )  if year
+    end
+  end
+end   # DateHeader
+
+
+
+DateHeaderLegs = Struct.new( :date1, :date2 ) do
+
+  def as_json(*)
+    ['<DateHeaderLegs>', { 'leg1' => date1.as_json,
+                           'leg2' => date2.as_json,
+                         }
+    ]
+  end
+
+  def pretty_print( q )
+    q.group( 4, '<DateHeaderLegs ', '>' ) do
+      q.text( "leg1=" )
+      q.pp( date1 )
+      q.text( " leg2=" )
+      q.pp( date2 )
+    end
+  end
+end   # DateHeaderLegs
+
+
+
+RoundOutline = Struct.new( :outline, :level ) do
+  def as_json(*)
+    ['<RoundOutline>', { 'outline' => outline.as_json,
+                         'level'   => level.as_json, }
+    ]
+  end
+
+  def pretty_print( q )
+    q.group( 4, '<RoundOutline ', '>' ) do
+       q.text( outline )
+       q.text( " level=#{level}" )
+    end
+  end
+end  # RoundOutline
+
+
+
+
+
+class BlankLine
+  def as_json(*)
+    ['<BlankLine>']
+  end
+
+  def pretty_print( q )
+    q.text( "<BlankLine>" )
+  end
+end  # BlankLine
+
+
+
+NoteLine = Struct.new( :text ) do
+  def as_json(*)
+    ['<NoteLine>', { 'text' => text.as_json } ]
+  end
+  def pretty_print( q )
+    q.group( 4, '<NoteLine ', '>' ) do
+      q.text( text )
+    end
+  end
+end  # NoteLine
+
+
+NotaBene = Struct.new( :text ) do
+  def as_json(*)
+    ['<NotaBene>', { 'text' => text.as_json } ]
+  end
+  def pretty_print( q )
+    q.group( 4, '<NotaBene ', '>' ) do
+      q.text( text )
+    end
+  end
+end  # NotaBene
+
+
+
+
+
+## todo/check - use a generic Heading instead of Heading1/2/3 - why? why not?
+Heading1 = Struct.new( :text ) do
+  def as_json(*)
+    ['<Heading1>', { 'text' => text.as_json }]
+  end
+
+  def pretty_print( q )
+    q.group( 4, '<Heading1 ', '>' ) do
+      q.text( text )
+    end
+  end
+end # Heading1
+
+Heading2 = Struct.new( :text ) do
+  def as_json(*)
+    ['<Heading2>', { 'text' => text.as_json }]
+  end
+
+  def pretty_print( q )
+    q.group( 4, '<Heading2 ', '>' ) do
+      q.text( text )
+    end
+  end
+end  #  Heading2
+
+Heading3 = Struct.new( :text ) do
+  def as_json(*)
+    ['<Heading3>', { 'text' => text.as_json }]
+  end
+
+  def pretty_print( q )
+    q.group( 4, '<Heading3 ', '>' ) do
+      q.text( text )
+    end
+  end
+end  # Heading3
+
+
+  end   # class Parser
+end   # module SportDb

data/lib/sportdb/parser/parser-top.rb

@@ -0,0 +1,102 @@
+
+
+module SportDb
+
+class ParserResult
+   attr_reader :tree, :errors
+   def initialize( tree, errors=[] )
+       @tree, @errors = tree, errors
+   end
+
+   def ok?()  @errors.size == 0; end
+   def nok?() !ok?; end
+end  # class ParserResult
+
+
+class Parser
+  include Debuggable     ## auto-adds debug?, _trace, _info, etc.
+
+  def initialize( txt )
+    @tree   = []
+    @errors = []
+
+    lexer = Lexer.new( txt )
+    ##  note - use tokenize_with_errors and add/collect tokenize errors
+    @tokens, @errors = lexer.tokenize_with_errors
+    ## pp @tokens
+  end
+
+
+  def next_token
+    tok = @tokens.shift
+   ## _trace( "next_token => #{tok.pretty_inspect}" )
+
+    ##  convert to racc format single char literal tokens e.g. '@' etc.
+    ##                  note - literal token MUST be string (NOT symbol)
+    ##    note - racc expects array with to items
+    ##               -  item[0] is the token id
+    ##               -  item[1] is the token value
+
+    ## note - returns nil for end-of-file !!!
+    tok = [tok.type, tok]   if tok
+
+    tok
+  end
+
+
+#  on_error do |error_token_id, error_value, value_stack|
+#      puts "Parse error on token: #{error_token_id}, value: #{error_value}"
+#  end
+
+  def parse_with_errors
+     _trace( "start parse:" )
+     do_parse
+
+     _trace( "#{@tree.size} parse tree node(s): " +  @tree.pretty_inspect)
+
+     [@tree, @errors]
+  end
+
+
+  def parse  ## convenience shortcut (ignores errors)
+     puts "[DEPRECATED] parse; use new (porcelain/public) Fbtxt.parse api!!"
+     tree, _ = parse_with_errors
+     tree
+  end
+
+  attr_reader :errors
+  def errors?
+     puts "[DEPRECATED] errors?; use new (porcelain/public) Fbtxt.parse api!!"
+     @errors.size > 0;
+  end
+
+
+  def on_error(error_token_id, error_value, value_stack)
+    ## note - get  error_token (as string) e.g. MINUTE, DATE, etc.
+    error_token = Racc_token_to_s_table[error_token_id]
+
+    msg = "parse error on token: #{error_token}"
+
+    ## add error_value  - might be Lexer::Token or value
+    if error_value.is_a?( Lexer::Token)
+      if error_value.type == :NEWLINE
+         ## skip print of "literal" newline
+      else
+         msg << " >#{error_value.text}<"
+      end
+      msg << " @#{error_value.lineno}"
+    else
+      msg << " >#{error_value.inspect}"
+    end
+
+    ## add stack - why? why not?
+    ## "stack: #{value_stack.inspect}"
+
+    _error( msg )
+
+    @errors << msg
+  end
+
+
+end   # class Parser
+end  # module SportDb