fbtxt-document 0.9.0 → 0.9.1

data/lib/fbtxt/document/models/event.rb

@@ -0,0 +1,72 @@
+
+module Fbtxt
+  module Model
+
+
+##############
+## e.g.
+##    'Y',  Player, 44
+##    'YR', Player, 45+2
+
+class EventCard    ### use EventBooking - why? why not?
+    attr_reader :type
+    attr_reader :name
+    attr_reader :minute
+
+    def initialize( type:, name:, minute: nil )
+        @type   = type
+        @name   = name
+
+        ## note - auto-convert to our own Minute format
+        @minute =  if minute.is_a?( RaccMatchParser::Minute )
+                        Minute.new( m:      minute.m,
+                                    offset: minute.offset,
+                                    secs:   minute.secs )
+                   else
+                    minute
+                   end
+    end
+
+
+    def as_json(*)
+        h = { 'type' => type,
+              'name' => name }
+        h['minute'] = minute.to_s    if minute
+
+        h
+    end
+end  # class EventCard
+
+
+class EventSub   ## use just Sub or ??
+
+    attr_reader :name_on    ## use on only - why? why not?
+    attr_reader :name_off   ## use off only
+    attr_reader :minute
+
+    def initialize( on:, off:, minute: nil )
+        @name_on  = on
+        @name_off = off
+
+        ## note - auto-convert to our own Minute format
+        @minute =  if minute.is_a?( RaccMatchParser::Minute )
+                        Minute.new( m:      minute.m,
+                                    offset: minute.offset,
+                                    secs:   minute.secs )
+                   else
+                    minute
+                   end
+    end
+
+    def as_json(*)
+        h = { 'on'  => name_on,
+              'off' => name_off }
+        h['minute'] = minute.to_s    if minute
+
+        h
+    end
+end  ## EventSub
+
+
+end # module Model
+end # module Fbtxt

data/lib/fbtxt/document/models/goal.rb

@@ -0,0 +1,94 @@
+module Fbtxt
+ module Model
+
+
+class Goal  ### nested (non-freestanding) inside match (match is parent)
+
+  attr_reader :team,                ## note - 1|2 expected
+              :name,
+              :minute,
+              :owngoal,            ## true|false
+              :penalty             ## true|false
+
+  ## add alias for player => name - why? why not?
+  ## alias_method :player, :name
+
+  def owngoal?() @owngoal==true; end
+  def penalty?() @penalty==true; end
+  def team1?()   @team == 1; end
+  def team2?()   @team == 2; end
+
+
+  def initialize( team:,
+                  name:,
+                  minute:  nil,
+                  owngoal: false,
+                  penalty: false
+                )
+    @team    = team     # 1|2
+    @name    = name
+
+    ## note - auto-convert to our own Minute format
+    ##        is obj/incl. (optional) offset/injury time!!
+    @minute =  if minute.is_a?( RaccMatchParser::Minute )
+                        Minute.new( m:      minute.m,
+                                    offset: minute.offset,
+                                    secs:   minute.secs )
+                   else
+                    minute
+                   end
+
+    @owngoal = owngoal
+    @penalty = penalty
+  end
+
+  def state
+    [@team,
+     @name, @minute, @owngoal, @penalty
+     ]
+  end
+
+  def ==(o)
+    o.class == self.class && o.state == state
+  end
+
+  def pretty_print( q )
+    q.group( 4, '<Goal ', '>') do        ##  group( indent, open, close)
+      q.text( name )
+      q.text( " #{@minute}" )    if @minute
+
+      q.text( "(og)" )  if @owngoal
+      q.text( "(p)" )   if @penalty
+      q.text( " for #{@team}" )      ### team 1 or 2 - use home/away
+    end
+  end
+
+
+   ### note  - EXCLUDE team 1|2 from serialize
+   ##            maybe remove alltogether and split into goals[[],[]] - why? why not?
+    def as_json(*)
+        h = { 'name'  => name  }
+
+=begin
+          ## note - use a string for minutes for now
+          ##           allows e.g.  45+2 etc. too
+          minute_str  = "#{goal.minute}"
+          minute_str += "+#{goal.offset}"   if goal.offset
+
+          node['minute']  = minute_str
+=end
+
+        h['minute'] = minute.to_s    if minute
+
+        h['owngoal'] = true         if owngoal?
+        h['penalty'] = true         if penalty?
+
+        h
+    end
+
+
+end # class Goal
+
+
+end # module Model
+end # module Fbtxt

data/lib/fbtxt/document/{match_tree → models}/group.rb

@@ -1,5 +1,5 @@
 module Fbtxt
-class MatchTree
+ module Model
 
 class Group
       attr_reader :name, :teams
@@ -19,5 +19,5 @@ class Group
 end  # class Group
 
 
-end # class MatchTree
+end # module Model
 end # module Fbtxt

data/lib/fbtxt/document/models/lineup.rb

@@ -0,0 +1,147 @@
+=begin
+
+(double) check bookings
+  -  is trainer or co-trainer - why NOT included in lineup ???
+==> reading >austria/2025-26/1-bundesliga-full.txt<...
+!! warn - player >Thomas Turner< NOT found; skipping booking Thomas Turner 90+3
+!! warn - player >Thomas Turner< NOT found; skipping booking Thomas Turner 88
+!! warn - player >Tobias Schützenauer< NOT found; skipping booking Tobias Schützenauer 90+5
+!! warn - player >Jeyland MITCHELL< NOT found; skipping booking Jeyland MITCHELL 77
+!! warn - player >Lukas Gütlbauer< NOT found; skipping booking Lukas Gütlbauer 84
+=end
+
+
+
+module Fbtxt
+  module Model
+
+=begin
+## fix-fix-fix
+##    move into (nested inside) Lineup - why? why not?
+class Card
+  attr_reader :name, :minute
+  def initialize( name:, minute: nil )
+    @name   = name
+    @minute = minute
+  end
+end  ## class Card
+=end
+
+
+
+
+## note - lineup incl. starter & (optional) bench & sub(stituion)s
+class Lineup
+
+
+
+    def self.build( lineup )
+        ## add starter & bench (via substitutions)
+       starter = _collect_starter( lineup )
+       bench   = _collect_bench( lineup )
+       subs    = _collect_subs( lineup )
+
+       new( starter: starter,
+            bench: bench,
+            subs: subs )
+    end
+
+
+    def self._collect_starter( lineup )
+      recs = []
+      lineup.each do |item|
+ ##        puts " lineup.each item:"
+ ##        pp item
+           rec = Player.new( name:    item.name,
+                             captain: item.captain )
+
+           recs << rec
+      end
+      recs
+    end
+
+    def self._collect_bench( lineup )
+      recs = []
+      lineup.each do |item|
+           current = item
+           while current && current.sub
+              rec = Player.new( name:    current.sub.sub.name,
+                                captain: current.sub.sub.captain )
+
+               recs << rec
+               current = current.sub.sub
+           end
+      end
+      recs
+    end
+
+   def self._collect_subs( lineup )
+      recs = []
+      lineup.each do |item|
+           current = item
+           while current && current.sub
+              ##  fix-fix-fix - use player-ref for off/on
+              rec =  EventSub.new( off:  current.name,
+                                   on:   current.sub.sub.name,
+                                   minute: current.sub.minute )
+              recs << rec
+              current = current.sub.sub
+           end
+      end
+
+   ## note - (auto-)sort by minute if present
+   ###  fix-fix-fix  move sort to EventSub  <=>  - why? why not?
+   recs = recs.sort do |l,r|
+                    if l.minute && r.minute
+                        l.minute <=> r.minute
+                    else
+                       0  ## keep as is (no minutes available)
+                    end
+               end
+      recs
+    end
+
+
+
+
+
+    def initialize( starter:,
+                    bench: [],
+                    subs:  [] )
+        @starter = {}    ## note - indexed by (player) name
+        starter.each do |player|
+            @starter[player.name] = player
+        end
+
+        @bench   = {}    ## note - indexed by (player) name
+        bench.each do |player|
+             @bench[player.name] = player
+        end
+
+        @subs    = subs
+    end
+
+    def starter()  @starter.values; end
+    def bench()    @bnech.values; end
+    def subs()     @subs; end
+
+
+    def find_player( name )
+        player = @starter[name] || @bench[name]
+    end
+
+
+
+    def as_json(*)
+        h = { 'starter' => @starter.values.as_json }
+
+        h['bench'] = @bench.values.as_json    if @bench.size > 0
+        h['subs']  = @subs.as_json            if @subs.size > 0
+
+        h
+    end
+end  # class Lineup
+
+
+end # module Model
+end # module Fbtxt

data/lib/fbtxt/document/models/match.rb

@@ -0,0 +1,194 @@
+##
+# move (simpler) struct version inline to MatchTree for now
+#
+module Fbtxt
+ module Model
+
+
+
+class Match
+
+  attr_reader :num,
+              :date,
+              :time,
+              :time_local,
+              :team1,     :team2,      ## todo/fix: use team1_name, team2_name or similar - for compat with db activerecord version? why? why not?
+              :score,
+              :round,     ## todo/fix:  use round_num or similar - for compat with db activerecord version? why? why not?
+              :group,
+              :status,    ## e.g. replay, cancelled, awarded, abadoned, postponed, etc.
+              :ground,       ## (optional) add as text line for now (incl. city, timezone etc.)
+              :att            ## (optional) attendance as (integer) number
+
+
+  ## e.g. support (flat/undefined) [], or (nested/paired) [[],[]]
+  attr_accessor :goals      ## todo/fix: make goals like all other attribs!!
+
+###
+#  add details match (report) info
+##          lineup,bench,subs,bookings(y/yr/r/etc.)
+  attr_accessor :lineup  ## incl. starter/bench/subs!!!
+  attr_accessor :bookings    ## use cards - why? why not?
+
+  attr_accessor :referees
+
+  attr_accessor :penalties
+
+
+  def initialize( **kwargs )
+    update( **kwargs )  unless kwargs.empty?
+  end
+
+
+  def update( **kwargs )
+    @num      = kwargs[:num]     if kwargs.has_key?( :num )
+
+    ## note: check with has_key?  because value might be nil!!!
+    @date       = kwargs[:date]        if kwargs.has_key?( :date )
+    @time       = kwargs[:time]        if kwargs.has_key?( :time )
+    @time_local = kwargs[:time_local]  if kwargs.has_key?( :time_local )
+
+    ## todo/fix: use team1_name, team2_name or similar - for compat with db activerecord version? why? why not?
+    @team1    = kwargs[:team1]    if kwargs.has_key?( :team1 )
+    @team2    = kwargs[:team2]    if kwargs.has_key?( :team2 )
+
+    ## note: round is a string!!!  e.g. '1', '2' for matchday or 'Final', 'Semi-final', etc.
+    ##   todo: use to_s - why? why not?
+    @round    = kwargs[:round]    if kwargs.has_key?( :round )
+    @group    = kwargs[:group]    if kwargs.has_key?( :group )
+    @status   = kwargs[:status]   if kwargs.has_key?( :status )
+
+    @ground   = kwargs[:ground]   if kwargs.has_key?( :ground )
+    @att      = kwargs[:att]      if kwargs.has_key?( :att )
+
+    ## check/expects all-in-one score struct for convenience!!!
+    @score    = kwargs[:score]     if kwargs.has_key?( :score )
+
+    self   ## note - MUST return self for chaining
+  end
+
+
+
+def as_json
+  #####
+  ##  note - use string keys (NOT symbol for data keys)
+  ##            for easier json compatibility
+  data = {}
+
+  ## check round
+  if @round
+    data['round'] = if round.is_a?( Integer )
+                      "Matchday #{@round}"
+                    else ## assume string
+                      @round
+                    end
+  end
+
+
+  data['num'] = @num    if @num
+
+
+  if @date
+    ## assume 2020-09-19 date format!!
+    data['date']  = @date.is_a?( String ) ? @date : @date.strftime('%Y-%m-%d')
+
+    data['time']        = @time           if @time
+    data['time_local']  = @time_local     if @time_local
+  end
+
+
+  data['team1'] =  @team1.is_a?( String ) ? @team1 : @team1.name
+
+  ## note - for match status bye  team2 is nil!!!
+  ##           e.g.     Queen's Park       bye
+  ##                    Wanderers          bye
+  ##   todo/check - keep bye as a match - why? why not?
+  ##                      has no date/time & venue & score etc.
+  if @team2
+    data['team2'] =  @team2.is_a?( String ) ? @team2 : @team2.name
+  end
+
+  ## note - score might be
+  ##           1) array e.g. [0,1]   -- e.g. uses reported key internally
+  ##           2) hash  e.g. { 'ft' [0,1] } etc.
+  ##  note - w/o (walkout)  do NOT add empty score
+
+   ## note:
+   ##   use/assume full-time (ft) if reported - why? why not?
+   ##     in future check for score note or such
+   ##      to  use "plain" array or such - why? why not?
+
+  data['score'] = @score.as_json      if @score
+
+
+
+  ### check for goals
+  if @goals.is_a?(Array) && @goals.size > 0
+    data['goals1'] = []
+    data['goals2'] = []
+
+    @goals.each do |goal|
+         if goal.team == 1
+            data['goals1']  << goal.as_json
+          else  ## assume 2  (or better raise except if NOT 2)
+            data['goals2']  << goal.as_json
+          end
+     end  # each goal
+  end
+
+  ### check for penalties (shootout)
+  if @penalties.is_a?(Array) && @penalties.size > 0
+     data['penalties'] = @penalties.as_json
+  end
+
+
+
+  data['status'] = @status  if @status
+
+  data['group']  = @group   if @group
+
+  if @ground
+       ## note: might be array of string e.g. ['Wembley', 'London']
+       ##
+       ##  todo/check - auto-join to string - why? why not?
+       ##                   e.g.  ['Wembley', 'London']
+       ##                     to   'Wembley, London'
+       ##   note - auto-join geo tree for now
+       data['ground'] = @ground.join(', ')
+  end
+
+  data['attendance'] = @att   if @att
+
+
+###
+#  check for match (report) details
+#    quick & dirty first try/version/dump
+#      refine (serialize) format later
+    if @lineup.is_a?(Array) && @lineup.size > 0
+        data['lineup'] = @lineup.as_json
+    end
+
+
+    if @bookings.is_a?(Array) && @bookings.size > 0
+       if @bookings[0].empty? && @bookings[1].empty?
+          ##  skip empty bookings
+          ## "bookings": [[], []]
+       else
+         data['bookings'] = @bookings.as_json
+       end
+    end
+
+
+    if @referees.is_a?(Array) && @referees.size > 0
+        data['referees'] = @referees.as_json
+    end
+
+
+  data
+end
+end  # class Match
+
+
+
+end # module Model
+end # module Fbtxt

data/lib/fbtxt/document/models/minute.rb

@@ -0,0 +1,57 @@
+module Fbtxt
+ module Model
+
+
+class Minute
+
+    attr_reader :m, :offset, :secs
+
+    def initialize( m:, offset: nil, secs: nil )
+      @m      = m
+      @offset = offset
+      @secs   = secs
+    end
+
+    ## todo/check - rename offset to injury/stoppage (time) or such - why? why not?
+=begin
+Alternative naming conventions
+here are the three best ways to rename it
+ - stoppage:       Short, clean, and highly readable in a class context
+                       Minute.new(m: 90, stoppage: 4).
+ - stoppage_time:  Highly explicit if you want zero ambiguity.
+ - added_time:     Another officially recognized term that reads very naturally.
+=end
+
+
+    def as_json(*) to_s; end
+
+    def to_s
+      buf = String.new
+      buf << "#{m}"
+      ### note - do NOT autoadd minute quote for now
+      ##    make it an option e.g.  to_s( :quote) or such - why? why not?
+      ### buf << "'"
+      buf << "+#{offset}"      if offset
+      buf << "/#{secs} secs"   if secs
+      buf
+    end
+
+    def pretty_print( q )
+       q.text( to_s )
+    end
+
+
+    include Comparable   ## note - auto-adds <, <=, ==, >=, >, and between?
+    def <=>(other)
+       return nil unless other.is_a?(Minute)
+
+      ## returns -1/0/1
+       res =   m <=> other.m
+       res =  (offset||0) <=> (other.offset||0)   if res == 0
+       res
+    end
+end  # class Minute
+
+
+end # module Model
+end # module Fbtxt

data/lib/fbtxt/document/models/penalty.rb

@@ -0,0 +1,35 @@
+module Fbtxt
+ module Model
+
+class Penalty
+
+  ## todo
+  ##  - add attr_reader :team     ## note - 1|2 expected  - why? why not?
+
+
+    attr_reader :name
+    attr_reader :score
+    attr_reader :note
+
+    def initialize( name:, score: nil, note: nil )
+        @name    = name
+        @score   = score
+        @note    = note
+    end
+
+
+    ## add alias for name => player - why? why not?
+    ##  alias_method :player, :name
+
+
+    def as_json(*)
+        h = { 'name'  => name }
+        h['score'] = score     if score.is_a?(Array) && !score.empty?
+        h['note']  = note      if note
+
+        h
+    end
+end  ## Penalty
+
+end # module Model
+end # module Fbtxt

data/lib/fbtxt/document/models/player.rb

@@ -0,0 +1,32 @@
+
+module Fbtxt
+  module Model
+
+
+class Player
+
+    attr_reader :name
+    ## fix-fix-fix
+    ##   add pos(ition) e.g. GK,DF,MF,FW
+
+
+    def initialize( name:, captain: false )
+        @name    = name
+        @captain = captain
+    end
+
+    def captain?() @captain; end
+
+
+
+    def as_json(*)
+        h = { 'name' => name }
+        h['captain'] = true    if captain?
+
+        h
+    end
+end # class Player
+
+
+end # module Model
+end # module Fbtxt

data/lib/fbtxt/document/models/referee.rb

@@ -0,0 +1,24 @@
+
+module Fbtxt
+  module Model
+
+
+class Referee  ## rename to/use Official - why? why not?
+    attr_reader :name, :country
+
+    def initialize( name:, country: nil )
+        @name    = name
+        @country = country
+    end
+
+    def as_json(*)
+        h = { 'name' => name }
+        h['country'] = country    if country
+
+        h
+    end
+end  # class Referee
+
+
+end # module Model
+end # module Fbtxt

data/lib/fbtxt/document/{match_tree → models}/round.rb

@@ -1,6 +1,6 @@
 
 module Fbtxt
-class MatchTree
+  module Model
 
 
   class Round
@@ -30,5 +30,5 @@ class MatchTree
 end  # class Round
 
 
-end # class MatchTree
+end # module Model
 end # module Fbtxt