sportdb-parser 0.5.4 → 0.5.6

data/lib/sportdb/parser/racc_tree.rb

@@ -0,0 +1,162 @@
+
+####
+#   RaccMatchParser support machinery (incl. node classes/abstract syntax tree)
+
+class RaccMatchParser
+
+
+LineupLine = Struct.new( :team, :lineup ) do
+  def pretty_print( printer )
+    printer.text( "<LineupLine " )
+    printer.text( self.team )
+    printer.text( " lineup=" + self.lineup.pretty_inspect )
+    printer.text( ">" )
+  end
+end
+
+Lineup     = Struct.new( :name, :card, :sub ) do
+  def pretty_print( printer )
+    buf = String.new
+    buf <<  self.name 
+    buf << " card=" + self.card.pretty_inspect    if card
+    buf << " sub=" + self.sub.pretty_inspect      if sub
+    printer.text( buf ) 
+  end
+end
+
+
+Card       = Struct.new( :name, :minute ) do
+  def to_s
+    buf = String.new
+    buf << "#{self.name}"
+    buf << " #{self.minute.to_s}"   if self.minute
+    buf
+  end
+
+  def pretty_print( printer )
+    printer.text( to_s )
+  end  
+end
+
+
+Sub        = Struct.new( :minute, :sub )  do
+  def pretty_print( printer )
+    buf = String.new 
+    buf << "(#{self.minute.to_s} " 
+    buf << self.sub.pretty_inspect  
+    buf << ")"
+    printer.text( buf ) 
+  end
+end
+
+
+
+GroupDef   = Struct.new( :name, :teams ) do
+  def pretty_print( printer )
+    printer.text( "<GroupDef " )
+    printer.text( self.name )
+    printer.text( " teams=" + self.teams.pretty_inspect )
+    printer.text( ">" )
+  end
+end
+
+
+RoundDef   = Struct.new( :name, :date, :duration )  do
+  def pretty_print( printer )
+    printer.text( "<RoundDef " )
+    printer.text( self.name )
+    printer.text( " date=" + self.date.pretty_inspect ) if date
+    printer.text( " durattion=" + self.duration.pretty_inspect ) if duration
+    printer.text( ">" )
+  end
+end
+
+DateHeader = Struct.new( :date ) do
+  def pretty_print( printer )
+    printer.text( "<DateHeader " )
+    printer.text( "#{self.date.pretty_inspect}>" )
+  end
+end
+
+GroupHeader = Struct.new( :name ) do
+  def pretty_print( printer )
+    printer.text( "<GroupHeader " )
+    printer.text( "#{self.name}>" )
+  end
+end
+
+RoundHeader = Struct.new( :names ) do
+  def pretty_print( printer )
+    printer.text( "<RoundHeader " )
+    printer.text( "#{self.names.join(', ')}>" )
+  end
+end
+
+MatchLine   = Struct.new( :ord, :date, :time,
+                          :team1, :team2, :score,
+                          :status, 
+                          :geo,
+                          :timezone )  do   ## change to geos - why? why not?
+
+  def pretty_print( printer )
+    printer.text( "<MatchLine " )
+    printer.text( "#{self.team1} v #{self.team2}")
+    printer.breakable
+
+    members.zip(values) do |name, value|
+      next if [:team1, :team2].include?( name )
+      next if value.nil?
+      
+      printer.text( "#{name}=#{value.pretty_inspect}" )
+    end    
+
+    printer.text( ">" )
+  end  
+
+end
+
+GoalLine    = Struct.new( :goals1, :goals2 ) do
+  def pretty_print( printer )
+    printer.text( "<GoalLine " )
+    printer.text( "goals1=" + self.goals1.pretty_inspect + "," )
+    printer.breakable
+    printer.text( "goals2=" + self.goals2.pretty_inspect + ">" )
+  end  
+end
+
+Goal        = Struct.new( :player, :minutes ) do
+  def to_s
+    buf = String.new
+    buf << "#{self.player}"
+    buf << " "
+    buf << minutes.map { |min| min.to_s }.join(' ')
+    buf
+  end
+
+  def pretty_print( printer )
+    printer.text( to_s )
+  end  
+
+end
+
+
+##
+##  fix - move :og, :pen  to Goal if possible - why? why not?
+##  or change to GoalMinute ???
+Minute      = Struct.new( :m, :offset, :og, :pen )  do
+    def to_s
+      buf = String.new
+      buf << "#{self.m}"
+      buf << "+#{self.offset}"  if self.offset 
+      buf << "'"
+      buf << "(og)"   if self.og
+      buf << "(pen)"  if self.pen
+      buf
+    end
+ 
+    def pretty_print( printer ) 
+       printer.text( to_s ) 
+    end  
+end
+
+end  # class RaccMatchParser

data/lib/sportdb/parser/tokenizer.rb

@@ -14,8 +14,239 @@ def log( msg )
 end
 
 
+## 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 tokenize_with_errors( line, debug: false )
+  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
+
+
+
+
+### convience helper - ignore errors by default
+def tokenize( lines, debug: false )
+  tokens, _ = tokenize_with_errors( lines, debug: debug )
+  tokens
+end
+
+def tokenize_with_errors( lines, debug: false )
+
+##
+##  note - for convenience - add support
+##         comments (incl. inline end-of-line comments) and empty lines here
+##             why? why not?
+##         why?  keeps handling "centralized" here in one place
+
+   ## todo/fix - rework and make simpler
+    ##             no need to double join array of string to txt etc.
+
+    txt_pre =  if lines.is_a?( Array )
+               ## join together with newline
+                 lines.reduce( String.new ) do |mem,line|
+                                               mem << line; mem << "\n"; mem
+                                            end
+               else  ## assume single-all-in-one txt
+                 lines
+               end
+
+    ##  preprocess automagically - why? why not?
+    ##   strip lines with comments and empty lines striped / removed
+    ##      keep empty lines? why? why not?
+    ##      keep leading spaces (indent) - why?
+    txt = String.new
+    txt_pre.each_line do |line|    ## preprocess
+       line = line.strip
+       next if line.empty? || line.start_with?('#')   ###  skip empty lines and comments
+       
+       line = line.sub( /#.*/, '' ).strip             ###  cut-off end-of line comments too
+       
+       txt << line
+       txt << "\n"
+    end
+    
+
+    tokens_by_line = []   ## note: add tokens line-by-line (flatten later)
+    errors         = []   ## keep a list of errors - why? why not?
+  
+    txt.each_line do |line|
+        line = line.rstrip   ## note - MUST remove/strip trailing newline (spaces optional)!!!
+ 
+        more_tokens, more_errors = _tokenize_line( line, debug: debug )
+        
+        tokens_by_line  << more_tokens   
+        errors          += more_errors
+    end # each line
+
+
+
+
+    tokens_by_line = tokens_by_line.map do |tokens|
+        #############
+        ## 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]
+                       t = if is_group?( text )
+                               [:GROUP, text]
+                             elsif is_round?( text ) || is_leg?( text )
+                               [:ROUND, text]
+                             else
+                               t  ## pass through as-is (1:1)
+                             end
+                    end
+                   t
+                 end
+
+        #################
+        ## pass 2                  
+        ##    transform tokens (using simple patterns) 
+        ##      to help along the (racc look ahead 1 - LA1) parser       
+        nodes = []
+
+        buf = Tokens.new( tokens )
+        ## pp buf
+
+
+    loop do
+          break if buf.eos?
+
+          if buf.pos == 0   ## MUST start line
+            ## check for
+            ##    group def or round def
+            if buf.match?( :ROUND, :'|' )    ## assume round def (change round to round_def)
+                      nodes << [:ROUND_DEF, buf.next[1]]
+                      nodes << buf.next 
+                      nodes += buf.collect
+                      break
+            end
+            if buf.match?( :GROUP, :'|' )    ## assume group def (change group to group_def)
+                      nodes << [:GROUP_DEF, buf.next[1]]
+                      nodes << buf.next 
+                      ## change all text to team - why? why not?
+                      nodes += buf.collect { |t|
+                                t[0] == :TEXT ? [:TEAM, t[1]] : t
+                               }
+                      break
+            end
+          end
+
+
+          if 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
+          else
+             ## pass through
+             nodes << buf.next
+          end
+    end  # loop
+    nodes  
+  end  # map tokens_by_line
+
+
+
+    ## flatten tokens
+    tokens = []
+    tokens_by_line.each do |tok|
+         tokens  += tok 
+         tokens  << [:NEWLINE, "\n"]   ## auto-add newlines
+    end
+
+    [tokens,errors]
+end   # method tokenize_with_errors
+
+
+
+def _tokenize_line( line, debug: false )
   tokens = []
   errors = []   ## keep a list of errors - why? why not?
 
@@ -252,11 +483,5 @@ def tokenize_with_errors( line, debug: false )
 end
 
 
-### convience helper - ignore errors by default
-def tokenize(  line, debug: false )
-   tokens, _ = tokenize_with_errors( line, debug: debug )
-   tokens
-end
-
 end  # class Parser
 end # module SportDb

data/lib/sportdb/parser/version.rb

@@ -4,7 +4,7 @@ module SportDb
     module Parser
   MAJOR = 0    ## todo: namespace inside version or something - why? why not??
   MINOR = 5
-  PATCH = 4
+  PATCH = 6
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version