fbtxt-parser 0.9.0

data/lib/fbtxt/parser/lexer_buffer.rb

@@ -0,0 +1,68 @@
+
+module Fbtxt
+
+## note - Tokens was placed inside Lexer - keep "top-level" for now inside Fbtxt
+##            for easier reuse with (new) lexer variants!!
+
+## 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
+
+
+
+
+  ## pattern e.g. [:TEXT, [:VS,:SCORE], :TEXT]
+  def match?( *pattern )
+      ## puts "  starting match? #{pattern.inspect} @ #{@pos}"
+      pattern.each_with_index do |types,offset|
+          tok = peek(offset)
+          return false if tok.nil?   ## no more tokens (cannot match)
+
+          ## if single symbol wrap in array
+          types = types.is_a?(Array) ? types : [types]
+          return false  unless types.include?( tok.type )
+      end
+      true
+  end
+
+
+
+  def cur()           peek(0); end
+
+  def peek(offset=1)
+      ## return nil if eos
+      if @pos+offset >= @tokens.size
+          nil
+      else
+         @tokens[@pos+offset]
+      end
+  end
+
+  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
+end  # class Tokens
+end # module Fbtxt

data/lib/fbtxt/parser/lexer_token.rb

@@ -0,0 +1,126 @@
+module Fbtxt
+class Lexer
+
+
+
+class Token
+
+  ##   Token.newline( lineno: 1, offset: [1,2] )
+  ##     maps to =>
+  ##   Token.new( :NEWLINE, "\n", lineno: 1, offset: [1,2])
+  ##
+  ## use self.nl ?
+  def self.newline( lineno:, offset: [])
+     new( :NEWLINE, "\n", lineno: lineno, offset: offset )
+  end
+
+  ##   Token.literal( ",", lineno: 4, offset: [5,6])
+  ##    # maps to =>
+  ##   Token.new( ",", ",", lineno: 4, offset: [5,6])
+  ##
+  ## use self.lit?
+  def self.literal( literal, lineno:, offset: [])
+     new( literal, literal, lineno: lineno, offset: offset )
+  end
+
+  ## or use virt or pseudo - why? why not?
+  def self.virtual( type, lineno:, offset: [])
+     ## note - offset (start/end) should be same number (zero-width assertions!!)
+     ## e.g.    :GOALS_COMPAT, "<|GOALS_COMPAT|>"
+     new( type, '', lineno: lineno, offset: offset )
+  end
+
+
+  attr_reader :type,   :text,
+              :lineno, :offset
+
+  def initialize( type, text='',
+                   lineno:, offset: [],
+                   value: nil  )
+     @type    = type
+     @text    = text       # note - lexeme (string from source)
+     @lineno  = lineno     # note - lineno (integer number - not line as string) !!!
+
+     raise TypeError, "type Array required for offset; got #{offset.inspect}"  unless offset.is_a?( Array )
+     @offset  = offset  # note - for now char offset [start,end] in line (NOT absolute!!)
+                         #     maybe latter add MatchData#byteoffset instead - why? why not?
+     @value   = value   # might be (union of) string/array/hash
+  end
+
+  def value
+       ## note - if value is not set (nil) return text (lexeme)
+       ##             no need to duplicate text as value
+       @value.nil?  ? @text : @value
+  end
+
+
+##  note: do NOT use as_text/text to avoid confusion with (raw) text (lexeme)
+##
+##  use
+##    as_str                -- value (as String)
+##    as_int                -- value (as Integer)
+##    as_hash               -- value (as Hash)
+##    as_ary                -- value (as Array)
+
+  def as_str
+      raise TypeError, "token value #{@value.inspect} is #{@value.class.name} NOT string; sorry"   if @value && !@value.is_a?(String)
+       ## note - if value is not set (nil) return text (lexeme)
+       ##             no need to duplicate text as value
+      @value.nil?  ? @text : @value
+  end
+
+  def as_int
+     raise TypeError, "token value #{@value.inspect} is #{@value.class.name} NOT integer; sorry"    if !@value.is_a?(Integer)
+     @value
+  end
+
+  def as_hash
+     raise TypeError, "token value #{@value.inspect} is #{@value.class.name} NOT hash; sorry"    if !@value.is_a?(Hash)
+     @value
+  end
+
+  def as_ary
+     raise TypeError, "token value #{@value.inspect} is #{@value.class.name} NOT array; sorry"    if !@value.is_a?(Array)
+     @value
+  end
+
+
+  def to_legacy
+    ## return old "legacy" array format
+      if @value.nil?
+         [@type, @text]
+      else
+         [@type, [@text, @value]]
+      end
+  end
+
+
+## pretty print
+  def pretty_print( printer )
+    ## check for literal e.g. "," etc.
+    if @type.is_a?( String ) && @type == @text && @value.nil?
+       printer.text( "[#{@type.inspect}" )
+    elsif @type.is_a?( Symbol ) && @text == ''  && @value.nil?
+      ## assume virtual token  (zero-width)
+      ##   use <!...!> style
+      printer.text( "[<|#{@type}|>" )
+    else
+      printer.text( "[#{@type.inspect} #{@text.inspect}" )
+      printer.text( ", #{value.inspect}")            if @value
+    end
+
+
+    printer.text( " @#{@lineno}" )
+    ## note - for now print only start_offset (offset[0])
+    ##           to keep dump/output shorter
+    ##   note - start counting columns at one (NOT zero), thus, add +1 !!
+    printer.text( ":#{@offset[0]+1}" )         if @offset.is_a?(Array) && @offset.size == 2
+    printer.text( "]" )
+  end
+
+end # class Token
+
+
+
+end  # class Lexer
+end  # module Fbtxt

data/lib/fbtxt/parser/parse_tree--core.rb

@@ -0,0 +1,29 @@
+
+
+# module JsonSerializable
+#  def to_json(*args)
+#    as_json.to_json(*args)
+#  end
+# end
+
+###
+##  add as_json  to Object/Array/Hash
+class Object
+  def as_json(*)
+    self
+  end
+end
+
+class Array
+  def as_json(*)
+    map { |v| v.as_json }
+  end
+end
+
+class Hash
+  def as_json(*)
+    each_with_object({}) do |(k, v), h|
+      h[k.to_s] = v.as_json
+    end
+  end
+end

data/lib/fbtxt/parser/parse_tree-match.rb

@@ -0,0 +1,309 @@
+module Fbtxt
+  class Parser
+
+
+
+MatchLineBye   = Struct.new( :team, :note ) do
+  def pretty_print( q )
+    q.group( 4, '<MatchLineBye ', '>') do        ##  group( indent, open, close)
+      q.text( "#{team} bye")
+      if note
+        q.text( " note=" )
+        q.pp( note )
+      end
+    end
+  end
+end  # MatchLineBye
+
+
+
+
+MatchLineLegs   = Struct.new( :team1, :team2,
+                              :score )  do
+  def pretty_print( q )
+    q.group( 4, '<MatchLineLegs ', '>') do        ##  group( indent, open, close)
+      q.text( "#{team1} v #{team2}")
+
+      members.zip(values) do |name, value|
+        next if [:team1, :team2].include?( name )
+        next if value.nil?
+
+        q.breakable
+        q.text( "#{name}=" )
+        q.pp( value )
+      end
+    end
+  end
+end
+
+
+#
+#  note: use two status attributes for now
+#         1) inline_status and 2) (note_)status
+#              for now  e.g.  A abd. B     vs   A  v B [abadoned]
+#                             A 3-0 awd B  vs   A  3-0 B [awarded]
+#   note - BOTH might be present at the same time
+
+
+MatchLine   = Struct.new( :header,  :tty,   ## tty = TELETYPE MODE for teams and score!!
+                          :num, :date, :time, :time_local, :year,
+                          :team1, :team2,
+                          :score,
+                          :status,  :status_inline, :status_note,
+                          :round_inline_short, :round_inline_big,
+                          :geo,
+                          :neutral,  ## true/false - NOT -home/away - neutral ground
+                          :note,
+                          :att )  do   ## change to geos - why? why not?
+
+
+  def as_json(*)
+    h =  { 'team1' => team1.as_json,
+           'team2' => team2.as_json,
+         }
+
+      members.zip(values) do |name, value|
+        next if [:team1, :team2].include?( name )
+        next if value.nil?
+
+        h[name.to_s] = value.as_json
+      end
+
+    ['<MatchLine>', h]
+  end
+
+
+  def pretty_print( q )
+    q.group( 4, '<MatchLine ', '>') do        ##  group( indent, open, close)
+      q.text( "#{team1} v #{team2}")
+
+      members.zip(values) do |name, value|
+        next if [:team1, :team2].include?( name )
+        next if value.nil?
+
+        q.breakable
+        q.text( "#{name}=" )
+        q.pp( value )
+      end
+    end
+  end
+
+end  #  struct MatchLine
+
+
+
+GoalLine    = Struct.new( :goals ) do
+
+  def as_json(*)
+    ['<GoalLine>', { 'goals' => goals.as_json }]
+  end
+
+  def pretty_print( q )
+    q.group( 4, '<GoalLine ', '>') do
+      q.text( "goals=" )
+      q.pp( goals )
+    end
+  end
+end  # GoalLine
+
+
+
+###
+##  change/rename Goal to GoalScorer  - why? why not?
+
+Goal        = Struct.new( :player, :minutes, :count ) do
+
+  def as_json(*)
+    h = { 'player' => player.as_json }
+
+    h['count']   = count.as_json     if count
+    h['minutes'] = minutes.as_json   if minutes && !minutes.empty?
+
+    ## ['<Goal>', h]
+    h   # note - return "inline" json object
+  end
+
+
+  def to_s
+    buf = String.new
+    buf << "#{player}"
+    if count
+       buf << (" " + count.inspect + ",")
+    else
+      if minutes.nil? || minutes.empty?
+        ## add nothing if no minutes available/present
+      else
+        buf << " "
+        buf << minutes.map { |min| min.to_s }.join(' ')
+      end
+    end
+    buf
+  end
+
+  def pretty_print( q )
+    q.text( to_s )
+  end
+end
+
+
+## check - use a different name e.g. GoalLineScore or such - why? why not?
+GoalLineAlt = Struct.new( :goals ) do
+  def pretty_print( q )
+    q.group( 4, '<GoalLineAlt ', '>') do
+      q.text( "goals=" )
+      q.pp( goals )
+    end
+  end
+end  # GoalLineAlt
+
+
+##
+##   score and player REQUIRED
+##   note - (goal) minute is optional
+##          if no minute goal type is optional e.g. "standalone" (p), (og), etc.
+
+GoalAlt   = Struct.new( :score, :player, :minute, :goal_type ) do
+  def to_s
+    buf = String.new
+    buf << "#{score[0]}-#{score[1]}"
+    buf << " #{player}"
+    buf << " #{minute}"     if minute
+    buf << " #{goal_type}"  if goal_type
+    buf
+  end
+
+  def pretty_print( q )
+    q.text( to_s )
+  end
+end  # GoalAlt
+
+
+
+GoalLineCompat = Struct.new( :goals ) do
+  def pretty_print( q )
+    q.group( 4, '<GoalLineCompat ', '>') do
+      q.text( "goals=" )
+      q.pp( goals )
+    end
+  end
+end  # GoalLineCompat
+
+
+##
+##   minute and player REQUIRED
+##   note - score (e.g. 1-1) is optional
+##          goal type is optional e.g. "standalone" (p), (og), etc.
+
+GoalCompat    = Struct.new( :score, :player, :minute, :goal_type ) do
+  def to_s
+    buf = String.new
+    buf << "#{minute}"
+    buf << " #{player}"
+    buf << " #{goal_type}"             if goal_type
+    buf << " #{score[0]}-#{score[1]}"  if score
+    buf
+  end
+
+  def pretty_print( q )
+    q.text( to_s )
+  end
+end
+
+
+
+##   FIX/FIX/FIX
+##   split into Minute and
+##             GoalMinute  (Minute+GoalType)
+##
+##  fix - move :og, :pen  to Goal if possible - why? why not?
+##  or change to GoalMinute ???
+##
+##  fix!!! split into GoalMinute and Minute
+##            goal_minute incl. :og, :pen, :freekick, :header,
+##                     seconds etc.
+##
+##  GoalMinute = Minute + GoalType !!!
+
+GoalMinute      = Struct.new( :m, :offset, :secs,
+                             :og, :pen, :header, :freekick,
+                         )  do
+
+
+    def as_json(*)  to_s; end
+
+    def to_s
+      buf = String.new
+      buf << "#{m}"
+      buf << "'"
+      buf << "+#{offset}"  if offset
+      buf << "(og)"   if og
+      buf << "(p)"  if pen
+      buf << "(f)"  if freekick
+      buf << "(h)"  if header
+      buf << " (#{secs} secs)"   if secs
+      buf
+    end
+
+    def pretty_print( q )
+       q.text( to_s )
+    end
+
+    ### quick hack:
+    ### split struct into  Minute+GoalType structs
+    def to_minute
+        Minute.new( m:      m,
+                    offset: offset,
+                    secs:   secs )
+    end
+
+    def to_goal_type
+        if og || pen || header || freekick
+          GoalType.new( og:       og,
+                        pen:      pen,
+                        header:   header,
+                        freekick: freekick )
+        else
+           nil   ## note - return nil; if no goal type present!!
+        end
+    end
+end
+
+
+GoalType  = Struct.new( :og, :pen, :header, :freekick )  do
+    def to_s
+      buf = String.new
+      buf << "(og)"   if og
+      buf << "(pen)"  if pen
+      buf << "(f)"    if freekick
+      buf << "(h)"    if header
+      buf
+    end
+
+    def pretty_print( q )
+       q.text( to_s )
+    end
+end   # GoalType
+
+
+
+Minute      = Struct.new( :m, :offset, :secs )  do
+    def as_json(*) to_s; end
+
+    def to_s
+      buf = String.new
+      buf << "#{m}"
+      buf << "'"
+      buf << "+#{offset}"      if offset
+      buf << "/#{secs} secs"   if secs
+      buf
+    end
+
+    def pretty_print( q )
+       q.text( to_s )
+    end
+end  # Minute
+
+
+
+  end   # class Parser
+end   # module Fbtxt