sportdb-parser 0.7.2 → 0.8.0

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

@@ -0,0 +1,309 @@
+module SportDb
+  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 SportDb

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