sportdb-parser 0.7.2 → 0.8.0

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