fbtxt-pp 0.0.2

data/lib/fbtxt-pp/models/officials.rb

@@ -0,0 +1,26 @@
+
+###
+#  officials  (referees)
+
+
+class Official
+
+  def self.build( h )
+     new(
+           name:        h['name'],
+           country:     h['country'],
+           type:        h['type']
+     )
+  end
+
+  attr_reader :name, :country,
+              :type
+
+  def initialize( name:,
+                  country: nil,
+                  type:    nil )
+     @name    = name
+     @country = country
+     @type    = type
+  end
+end  ## class Official

data/lib/fbtxt-pp/models/penalties.rb

@@ -0,0 +1,29 @@
+
+
+class Penalty
+  def self.build( h )
+
+    new( name:   h['name'],
+         scored: h['scored'],   ## true|false  for now only
+         score:  h['score'],
+         team:   h['team']     ## 1|2
+         )
+  end
+
+
+  attr_reader :name,
+              :scored, :score, :team
+
+  def initialize( name:,
+                  scored:, score:,
+                  team:  )
+    @name     = name
+    @scored   = scored
+    @score    = score   ## maybe allow empty score - why? why not?
+
+    @team     = team
+  end
+
+  def scored?() @scored; end
+
+end # class Penalty

data/lib/fbtxt-pp/models/players.rb

@@ -0,0 +1,274 @@
+
+
+class Player
+
+  def self.build( h )
+
+##    rec = { id:      h['IdPlayer'],
+##
+##    status:     h['Status'],
+##    pos:        h['Position'],
+
+     new(
+           name:        h['name'],
+           short_name:  h['short_name'],
+           captain:     h['captain'],
+           id:          h['id']
+     )
+  end
+
+
+
+  attr_reader :id,
+              :name, :short_name,
+              :alt_names,
+              :captain,            ## true|false
+              :pos,
+              :y, :yr, :r,  ## cards/bookings - yellow, yellow-red, red
+              :sub          ## (recursive) sub(stitution) record
+
+  attr_accessor :status      ## e.g. 1-starter, 2-bench
+
+
+
+  def initialize( name:, short_name: nil,
+                  captain: false,
+                  id: nil )
+     @alt_names  = []
+
+     norm = norm_name( name )
+     if norm != name
+       puts "  NORM PLAYER NAME >#{name}<  =>  >#{norm}<"
+       @alt_names << name
+       name = norm
+     end
+
+     @name       = name
+     @short_name = short_name
+
+     @captain    = captain
+
+     @id  = id
+
+     @pos     = nil  ## fix-fix-fix - add pos(ition)
+     @status  = nil  ##  e.g. starter/bench|sub/etc.
+
+     ## todo/check - add "generic" sentoff  for pre-cards era - why? why not?
+     @y, @yr, @r  = nil,nil,nil
+
+     @sub     = nil
+  end
+
+   ## get lookup keys (id+name+alt_names)
+   def keys
+      keys = []
+      keys << @id                if @id
+      keys << slugify(@name)
+      keys += @alt_names.map {|name| slugify(name)}   unless @alt_names.empty?
+
+      ##  note - make sure keys are unique
+      keys.uniq
+   end
+
+
+
+
+  def captain?()  @captain; end
+  def starter?()  @status == 1; end
+  def bench?()    @status == 2; end
+  ##  add is_ variants - why? why not?
+  alias_method :is_starter?, :starter?
+  alias_method :is_bench?,   :bench?
+
+
+  def yellow?()    @y;  end
+  def yellowred?() @yr; end
+  def red?()       @r;  end
+
+
+   class Booking  ## (nested) booking record/struct
+       ## add :reason or such later
+       attr_reader :minute
+       def initialize( minute: nil )
+          @minute = minute
+       end
+   end ## (nested) booking record/struct
+
+   def add_yellow( minute: nil )    @y  = Booking.new( minute: minute ); end
+   def add_yellowred( minute: nil ) @yr = Booking.new( minute: minute ); end
+   def add_red( minute: nil )       @r  = Booking.new( minute: minute ); end
+
+
+
+  class Sub  ## (nested) sub(stitution) record/struct
+     attr_reader :minute,
+                 :player
+     def initialize( player:,
+                     minute: nil )
+         @player = player
+         @minute = minute
+     end
+  end  ## (nested) class Sub
+
+  def add_sub( player:,  minute: nil )
+      @sub = Sub.new( player: player,
+                      minute: minute )
+  end
+end  ## class Player
+
+
+
+
+
+
+
+class Players
+   def initialize
+      @recs   = []
+      @lookup = {}
+   end
+
+
+   def add_starter( recs )
+      recs.each do |h|
+         rec = Player.build( h )
+         rec.status = 1  ## set status to starter flag (1)
+        _add( rec )
+      end
+   end
+
+   def add_bench( recs )
+      recs.each do |h|
+         rec = Player.build( h )
+         rec.status = 2
+        _add( rec )
+      end
+   end
+
+
+###
+#  note:
+#    PAK Nam Chol  - North Korea  is two players with same name in the same team!!
+#                      with different jersey number 4/14
+
+   def _add( new_rec )
+      @recs << new_rec
+
+      new_rec.keys.each do |key|
+         rec  =  @lookup[ key ]
+         if rec.nil?
+            @lookup[ key ] = new_rec
+         else
+           if key == 'paknamchol'      ||
+              key == 'deniskovalevich'
+              ## ignore for now
+              ##   fix later (use/prefer numeric ids!!!)
+           else
+             raise ArgumentError,
+               "duplicate player records  #{rec.pretty_inspect} == #{new_rec.pretty_inspect}"
+           end
+         end
+      end
+   end
+
+
+   def find( q )
+      key = slugify( q )
+      @lookup[ key ]
+   end
+
+
+
+   def add_subs( subs )
+        subs.each do |sub|
+
+          player_off = find( sub['off'] )
+          player_on  = find( sub['on'] )
+
+          minute = sub['minute']
+
+          if player_off.nil?
+             puts "!! player_off not found in:"
+             pp sub
+             puts "---"
+             pp @recs
+             exit 1
+          end
+
+          if player_on.nil?
+             ### quick fix for N.N.
+             if sub['on'] == 'N.N.'
+               player_on = Player.build( { 'name' => 'N.N.'} )
+             else
+               puts "!! player_on not found in:"
+               pp sub
+               puts "---"
+               pp @recs
+               exit 1
+             end
+          end
+
+          assert( player_off && player_on,
+                  "subs player_off or player_on not found; sorry" )
+
+          player_off.add_sub( player: player_on,
+                              minute: minute )
+        end
+   end
+
+
+   def add_yellow( bookings)     _add_bookings( bookings, type: 'y' ); end
+   def add_yellowred( bookings)  _add_bookings( bookings, type: 'yr' ); end
+   def add_red( bookings)        _add_bookings( bookings, type: 'r' ); end
+
+      def _add_bookings( bookings, type: )
+      bookings.each do |b|
+
+          ## note - ignores cards coach and stuff for now upstream!!!
+          player = find( b['name'])
+          assert( player, "booking player not found; sorry- #{b.pretty_inspect}" )
+
+          minute =  b['minute']
+
+          case type.to_sym
+          when :y   then  player.add_yellow( minute: minute )
+          when :r   then  player.add_red( minute: minute )
+          when :yr  then  player.add_yellowred( minute: minute )
+          else
+              raise ArgumentError,
+                "expected :y|:r|:yr - unknown card type for booking: #{b.pretty_inspect}"
+          end
+      end
+   end
+
+
+
+  ###
+   ## todo/check
+   ##    add alias (or rename) starter  ??
+   ##   add new subs to  status == 2  - why? why not?
+   def lineup
+      recs = @recs.select { |rec| rec.starter? }
+      recs
+   end
+
+
+=begin
+   def find!( id_player )
+       rec = @recs[ id_player ]
+       raise ArgumentError, "no player w/ id >#{id_player}< found; sorry"  if rec.nil?
+       rec
+   end
+
+
+   ## all players with red or red-yellow card (sent off)
+   def sentoff
+      recs = @recs.values.select { |rec| rec[:r] || rec[:yr] }
+      recs
+   end
+=end
+
+
+   def size() @recs.size; end
+
+end  # class Players

data/lib/fbtxt-pp/models/score.rb

@@ -0,0 +1,85 @@
+
+class Score
+
+
+def self.build( score )
+  if score.nil?
+        raise ArgumentError, "Score.build - expected Hash or Array; got nil"
+  elsif score.is_a?(Hash)
+      new( **score.transform_keys(&:to_sym) )
+  elsif score.is_a?(Array)
+       new( reported: score )
+  else
+       raise ArgumentError, "Score.build - expected Hash or Array; got type #{score} #{score.class.name}"
+  end
+end
+
+
+
+attr_reader   :ht, :ft, :et, :p, :agg,
+              :reported
+
+
+def initialize( ht: nil, ft: nil, et: nil, p: nil, agg: nil,
+               reported: nil,
+               score: nil )
+   @ht, @ft, @et, @p, @agg = ht, ft, et, p, agg
+
+   ##
+   ## note: use reported for "generic" score where
+   ##             period is not known (might be  full-time or aet)
+   ##          or undefined e.g. for  abandoned or awarded (administered) score
+   @reported = reported
+
+   if score
+      puts " DEPRECATED - score got score keyword (use reported):"
+      pp [ ht, ft, et, p, agg, reported, score]
+      @reported = score
+   end
+end
+
+
+
+def to_s
+    if @reported
+        ## check for ary empty - why? why not?
+        "#{@reported[0]}-#{@reported[1]}"
+    else
+      if @et && @p
+             if @ft && @ht
+               "#{@et[0]}-#{@et[1]} a.e.t." +
+               " (#{@ft[0]}-#{@ft[1]}, #{@ht[0]}-#{@ht[1]}), " +
+               "#{@p[0]}-#{@p[1]} pen."
+             elsif @ft
+               "#{@et[0]}-#{@et[1]} a.e.t." +
+               " (#{@ft[0]}-#{@ft[1]}), " +
+               "#{@p[0]}-#{@p[1]} pen."
+            else
+               "#{@et[0]}-#{@et[1]} a.e.t., " +
+               "#{@p[0]}-#{@p[1]} pen."
+             end
+      elsif @et && @p.nil?
+             if @ft && @ht
+                "#{@et[0]}-#{@et[1]} a.e.t."+
+                " (#{@ft[0]}-#{@ft[1]}, #{@ht[0]}-#{@ht[1]})"
+             elsif @ft
+                "#{@et[0]}-#{@et[1]} a.e.t."+
+                " (#{@ft[0]}-#{@ft[1]})"
+             else
+                "#{@et[0]}-#{@et[1]} a.e.t."
+             end
+      elsif  @ft &&  @et.nil? && @p.nil?
+              if @ht
+                "#{@ft[0]}-#{@ft[1]} (#{@ht[0]}-#{@ht[1]})"
+              else
+               "#{@ft[0]}-#{@ft[1]}"
+              end
+      else
+           ## raise error/warn - about unknown (or empty) score type - why? why not?
+            ''
+      end
+    end
+end
+
+
+end  # class Score

data/lib/fbtxt-pp/models/stadiums.rb

@@ -0,0 +1,114 @@
+
+
+class Stadium
+
+   def self.build( h )
+     if h['name'].nil?
+       puts "stadium without name:"
+       pp h
+       exit 1
+     end
+
+      new(  name:    h['name'],
+            city:    h['city'],
+            country: h['country'],
+            street:  h['street']
+         )
+   end
+
+
+   attr_reader :id,
+               :name, :city, :street,
+               :country
+
+   def initialize( name:, city:, street: nil,
+                   country: nil,
+                   id: nil)
+
+    ##  name, city_name = norm_stadium( name, city_name: city_name )
+
+     if id.nil?
+        ## auto-generate id
+        ##  use slug of name plus id_city
+        ## add city name
+        id  =       slugify( name )
+        id += '_' + slugify( city )
+     end
+
+     @id = id
+
+     @name    = name
+     @city    = city
+     @street  = street
+     @country = country
+   end
+end  ## class Stadium
+
+
+
+
+
+class Stadiums
+   def initialize
+      @recs    = {}
+      @by_city = {}    ## track by cities
+   end
+
+
+   def add( recs )
+      recs.each do |rec|
+        _add( Stadium.build(  rec ) )
+      end
+   end
+
+
+   def _add( new_rec )
+      rec =  @recs[ new_rec.id ]
+      if rec.nil?
+          rec = new_rec
+          @recs[ new_rec.id ] = new_rec
+
+          city_rec = @by_city[ new_rec.city] ||= []
+          city_rec << new_rec
+      else
+         raise ArgumentError,
+            "duplicate stadium records  #{rec.pretty_inspect} == #{new_rec.pretty_inspect}"
+      end
+   end
+
+
+   def find!( h )
+       ## quick & dirty verion
+        name = h['name']
+        city = h['city']
+
+        id  =       slugify( name )
+        id += '_' + slugify( city )
+
+        rec =  @recs[ id ]
+        raise ArgumentError, "no stadium found for #{h.inspect} using id >#{id}<"  if rec.nil?
+        rec
+   end
+
+
+
+   def each( sort: true, &blk )
+      recs = if sort
+                @recs.values.sort do |l,r|
+                   res = l.country <=> r.country
+                   res = l.city    <=> r.city      if res == 0
+                   res
+                end
+             else
+                 @recs.values
+             end
+
+      recs.each( &blk )
+   end
+
+
+   def size() @recs.size; end
+
+   def cities() @by_city.keys; end
+
+end  # class Stadiums

data/lib/fbtxt-pp/models/teams.rb

@@ -0,0 +1,161 @@
+
+
+
+
+TEAM_MODS = {
+   ## nati(onal) teams (e.g. world cup)
+   ##  map "offical" country names to common country names
+   'Germany FR'          => 'West Germany',
+   'German DR'           => 'East Germany',
+   'Korea Republic'      => 'South Korea',
+   'Korea DPR'           => 'North Korea',
+   'China PR'            => 'China',
+   'Republic of Ireland' => 'Ireland',
+   'IR Iran'             => 'Iran',
+   'United States'       => 'USA',
+   'Czechia'             => 'Czech Republic',
+   'Türkiye'             => 'Turkey',
+   ##  Côte d'Ivoire  [fr]  => Ivory Coast   ???
+
+   ## austria (at)
+   ##   remove cut-out (commerical) sponsor names
+   'RZ Pellets WAC'       => 'Wolfsberger AC',  ## WAC
+   'CASHPOINT SCR Altach' => 'SCR Altach',
+   'SV Guntamatic Ried'   => 'SV Ried',
+}
+
+
+class Team
+   def self.build( h )
+       ## pp h
+       new( id:      h['id'],
+            name:    h['name'],
+            code:    h['code'],
+            country: h['country'] )
+   end
+
+
+   attr_reader :id,
+               :name,
+               :alt_names,
+               :code, :country
+   ## attr_accessor :count       ## read/write - let's you update (match) count
+
+   def initialize( name:,
+                   code:,
+                   country:,
+                   id: nil)
+      @alt_names = []
+
+      norm = norm_name( name )
+      if norm != name
+        puts "  NORM TEAM NAME  >#{name}<  =>  >#{norm}<"
+        @alt_names << name
+        name = norm
+      end
+
+      ## check for mods/canonical  name
+      mod = TEAM_MODS[ name ]
+      if mod
+         puts "   MOD TEAM NAME  >#{name}<  =>  >#{mod}<"
+         @alt_names << name
+         name = mod
+      end
+
+      @name  = name
+
+      @code    = code
+      @country = country
+
+      @id  = id
+
+      ## @count = 0
+   end
+
+
+
+   ## get lookup keys (id+name+alt_names)
+   def keys
+      keys = []
+      keys << @id                if @id
+      keys << slugify(@name)
+      keys += @alt_names.map {|name| slugify(name)}   unless @alt_names.empty?
+
+      ##  note - make sure keys are unique
+      keys.uniq
+   end
+
+
+   def dummy?()   @name == 'N.N.'; end
+   alias_method :unknown?, :dummy?
+
+   DUMMY = build(  { 'name'    => 'N.N.',
+                     'code'    => 'UNK',
+                     'country' => 'UNK', } )
+end   # class Team
+
+
+
+
+
+class Teams
+   def initialize
+      @recs   = []
+      @lookup = {}
+   end
+
+   def add( recs )
+      recs.each do |rec|
+        _add( Team.build( rec ) )
+      end
+   end
+
+   def _add( new_rec )
+      @recs << new_rec
+
+      new_rec.keys.each do |key|
+         rec  =  @lookup[ key ]
+         if rec.nil?
+            @lookup[ key ] = new_rec
+         else
+           raise ArgumentError,
+             "duplicate team records  #{rec.pretty_inspect} == #{new_rec.pretty_inspect}"
+         end
+      end
+   end
+
+
+   ## note - search by   id, name or alt_names !!
+   def find!( q )
+      if q == '?'    ## return dummy
+        rec = Team::DUMMY
+      else
+        key = slugify( q )
+        rec =  @lookup[ key ]
+        if rec.nil?
+           raise ArgumentError, "no team found for q(uery) >#{q}< using key >#{key}<"
+        end
+        rec
+      end
+   end
+
+
+=begin
+   def recs( sort: true  )
+      recs = @recs.values
+      if sort
+        recs = recs.sort do |l,r|
+                res = r[:count] <=> l[:count]
+                res = l[:name] <=> r[:name]  if res == 0
+                res
+             end
+      end
+      recs
+   end
+=end
+
+
+   def each( &blk ) @recs.each( &blk ); end
+   def size()       @recs.size; end
+
+end  # class Teams