fifadat-convert 0.0.1 → 0.1.0

data/lib/fifadat/{convert/substitutions.rb → models/substitution.rb}

@@ -33,7 +33,10 @@
 
 
 
-def _build_sub_minute( h )
+class Sub       ## Substitution/SubOnOff  Event
+
+
+def self._build_sub_minute( h )
 
     ## split into minute
     ##  and offset (stoppage/injury/added time)
@@ -69,39 +72,111 @@ def _build_sub_minute( h )
 end
 
 
-
-def build_sub( h, players: )
+def self.build( h, players: )
 
       minute = _build_sub_minute( h )
 
       playerOff = players.find( h['IdPlayerOff'] )
       playerOn  = players.find( h['IdPlayerOn'] )
 
+       ## fix-fix-fix
+       ##  report warning if playerON nil!!!
        ## use N.N.  for  nil - why? why not?
-       playerOn = { name: 'N.N.'}      if playerOn.nil?
+       playerOn = Player::PLAYER_NIL      if playerOn.nil?
 
       assert( playerOff && playerOn,
                   "playerOff and/or playerOn is NIL in #{h.pretty_inspect}")
 
-      rec = { off:     playerOff[ :name ],
-              on:      playerOn[ :name ],
+      rec = { off:     playerOff,
+              on:      playerOn,
               minute:  minute
             }
 
-      rec
+      new( **rec )
 end
 
 
 
-def build_subs( recs, players: )
-    recs = recs.map  { |h| build_sub( h, players: players ) }
+def self._build_ary( recs, players: )
+    recs = recs.map  { |h| build( h, players: players ) }
     recs
 end
 
 
+
+attr_reader :off, :on, :minute
+
+def initialize( off:, on:, minute: )
+  @off    = off
+  @on     = on
+  @minute = minute
+end
+
+   def as_json(*)
+      h = {
+            'off'     => off.name,
+            'on'      => on.name,
+            'minute'   => minute
+          }
+      h
+   end
+
+end ## class Sub(stitution)
+
+
+
+
+
 __END__
 
 
+
+=begin
+ def add_subs( subs )
+        subs.each do |sub|
+
+          idPlayerOff = sub['IdPlayerOff']
+          idPlayerOn  = sub['IdPlayerOn']
+
+          ## note - parse & reformat minute for keep same format
+          minute  = _build_sub_minute( sub )
+
+          player_off = @recs[ idPlayerOff ]
+          player_on  = @recs[ idPlayerOn ]
+
+##
+##   note - skip special case for now
+##              with NO PLAYER ON (e.g. idPlayerOn is nil!!)
+       ##    next if idPlayerOn.nil?
+           ##  todo/fix - report/log warning!!!
+
+
+          if player_off.nil?
+             puts "!! player_off >#{idPlayerOff}< not found in:"
+             pp sub
+             puts "---"
+             pp @recs.values
+             exit 1
+          end
+
+          if player_on.nil?
+             puts "!! player_on >#{idPlayerOn}< not found in:"
+             pp sub
+             puts "---"
+             pp @recs.values
+             exit 1
+          end
+
+          assert( player_off && player_on,
+                  "subs player_off or player_on not found; sorry" )
+
+          player_off[ :sub ] = { minute: minute,
+                                 player_ref: player_on }
+        end
+   end
+=end
+
+
 !! ASSERT FAILED - playerOff and/or playerOn is NIL in {"IdEvent"=>nil,
  "Period"=>5,
  "Reason"=>0,

data/lib/fifadat/models/team.rb

@@ -0,0 +1,85 @@
+
+
+class Team
+
+
+def self.build( h )
+   if h
+      name = desc( h['TeamName'] )
+      ##  name = norm_team( name )
+
+      new( id:      h['IdTeam'],
+           name:    name,
+           code:    h['Abbreviation'],
+           country: h['IdCountry']    ## change to cc (country code) - why? why not?
+         )
+   else    ## assume nil - dummy record
+      TEAM_NIL
+   end
+end
+
+
+
+attr_reader :id, :name, :code, :country
+
+attr_accessor :count
+
+def initialize( name:,
+                id: nil,
+                code: nil, country: nil )
+    @name    = name
+    @id      = id
+    @code    = code
+    @country = country
+
+    @count = Hash.new(0)   ## match (reference/usage) count(er) by stage (name)!!
+end
+
+
+  ## shared dummy/nil record
+  TEAM_NIL = self.new( id:      '<nil>',
+                       name:    '?',
+                       code:    '?',           ## use nil - why? why not?
+                       country: '?' )          ## use nil - why? why not?
+
+
+
+=begin
+!! ASSERT FAILED - team records NOT matching -
+{:id=>"44129",
+ :name=>"Vasco da Gama",
+ :code=>"VDG",
+ :country=>"BRA",
+ :count=>7}
+ !=
+ {:id=>"44129",
+  :name=>"Vasco da Gama",
+  :code=>"VAS",
+  :country=>"BRA"}
+=end
+
+
+def ==(other)
+    return false   unless other.is_a?(Team)
+
+    ## check code too - why? why not?
+    ##   note - ignore code for now
+    self.id      == other.id &&
+    self.name    == other.name &&
+    self.country == other.country
+end
+
+
+def as_json(*)
+      h = {
+            'name'    => name,
+            'code'    => code,
+            'country' => country,
+            'count'   => count,
+            'id'      => id
+          }
+      h
+end
+
+
+end # class Team

data/lib/fifadat/tables/players.rb

@@ -0,0 +1,140 @@
+#
+# note - players here are for lineup (subs+bookings) and incl. starter/bench AND pos etc.
+#               do NOT use for team squads
+
+
+
+
+class Players
+   def initialize
+      @recs = {}
+   end
+
+   def add( recs )    ## rename to collect - why? why not?
+      recs.each do |rec|
+          raise ArgumentError,
+                 "player (obj) expected; got #{rec.class.name} - #{rec.inspect}"  unless rec.is_a?( Player )
+
+          rec = _add( rec )
+          rec.count += 1       ## track usage - why? why not?
+      end
+   end
+
+
+   def _add( new_rec )
+      rec =  @recs[ new_rec.id ]
+
+      if rec.nil?
+          rec = new_rec
+          @recs[ new_rec.id ] = new_rec
+      else
+          ## assert attributes equal - why? why not?
+          assert( new_rec == rec,
+                  "player records NOT matching - #{rec.pretty_inspect} != #{new_rec.pretty_inspect}")
+      end
+
+      rec
+   end
+
+
+
+   def find( id_player )
+       rec = @recs[ id_player ]
+       rec
+   end
+
+   def find!( id_player )
+       rec = @recs[ id_player ]
+       raise ArgumentError, "no player w/ id >#{id_player}< found; sorry"  if rec.nil?
+       rec
+   end
+
+
+
+
+   ###
+   ## todo/check
+   ##    add alias (or rename) starter  ??
+   ##   add new subs to  status == 2  - why? why not?
+   def lineup
+      @recs.values.select { |rec| rec.starter? }
+   end
+
+   def bench
+      @recs.values.select { |rec| rec.bench? }
+   end
+
+
+   def redcards
+      @recs.values.select { |rec| rec.red? }
+                  .map { |rec| rec.r }
+   end
+
+   def yellowcards
+      @recs.values.select { |rec| rec.yellow? }
+                  .map { |rec| rec.y }
+   end
+
+   def yellowredcards
+      @recs.values.select { |rec| rec.yellowred? }
+                  .map { |rec| rec.yr }
+   end
+
+
+
+
+   def add_bookings( bookings )  ##  yellow/red cards
+      bookings.each do |b|
+
+         card = b['Card']
+         assert( [0,1,2,3].include?( card ), "card 0/1/2/3 expected; got #{b.pretty_inspect}")
+
+         ##
+         ## what is card 0?  ignore for now
+         ##  Palmeiras v FC Porto  0-0   - 2025-06-15T18:00:00+00:00
+         ## !! ASSERT FAILED - card 1/2/3 expected; got {"Card"=>0,
+         ## "Period"=>5,
+         ## "IdEvent"=>nil,
+         ## "EventNumber"=>nil,
+         ## "IdPlayer"=>"495048",
+         ## "IdCoach"=>nil,
+         ## "IdTeam"=>"1884426",
+         ## "Minute"=>"72'",
+         ## "Reason"=>nil}
+         next if card == 0
+
+
+         idPlayer = b['IdPlayer']
+
+         ## booking (card) for coach or stuff!!!!
+         ##   skip for now
+         next   if idPlayer.nil? && (b['IdCoach'] || b['IdStaff'])
+
+
+         player = @recs[ idPlayer ]
+         assert( player, "booking player not found; sorry - #{b.pretty_inspect}" )
+
+           ## note - parse & reformat minute for keep same format
+          ## _fmt_minute( *_parse_minute( b['Minute'] ))
+         minute = _build_minute( b )
+
+          if card == 1      ## yellow
+             player.y =  Player::Card.new( player: player, type: 'Y', minute: minute )
+          elsif card == 2   ## red
+             player.r =  Player::Card.new( player: player, type: 'R', minute: minute )
+          elsif card == 3   ## yellow/red
+             player.yr = Player::Card.new( player: player, type: 'YR', minute: minute )
+          end
+      end
+   end
+
+
+
+   def dump
+      pp @recs.values
+      puts "  #{@recs.size} player(s)"
+   end
+
+   def size() @recs.size; end
+
+end  # class Players

data/lib/fifadat/tables/stadiums.rb

@@ -0,0 +1,71 @@
+
+
+
+class Stadiums
+   def initialize
+      @recs = {}
+   end
+
+   def add_matches( matches )  ## rename to add_matches - why? why not?
+     matches.each_with_index do |m|
+       stadium = Stadium.build( m['Stadium'] )
+       rec = _add( stadium )
+
+       ## update match counter by team
+       team_name = desc(m['Home']['TeamName'])
+       rec.count[ team_name ] += 1
+     end
+   end
+
+
+
+   def _add( new_rec )
+      rec =  @recs[ new_rec.id ]
+      if rec.nil?
+          rec = new_rec
+          @recs[ new_rec.id] = new_rec
+      else
+          ## assert attributes equal - why? why not?
+         assert( new_rec == rec,
+                  "stadium records NOT matching - #{rec.pretty_inspect} != #{new_rec.pretty_inspect}")
+      end
+      rec
+   end
+
+
+
+  def find!( h )
+      if h
+        name  = desc( h['Name'] )
+        city  = desc( h['CityName'] )
+        ## auto-generate id
+        ##  use slug of name plus id_city
+        ## add city name
+        ##  fix- add   0-9 & dash(-) to name too - why? why not?
+        id  =       name.downcase.gsub( /[^a-z]/, '' )
+        id += "_" + city.downcase.gsub( /[^a-z]/, '' )
+      else
+        puts "warn: empty stadium lookup:"
+        pp h
+        id = '<nil>'
+      end
+
+      ## check for nil - why? why not?
+       rec = @recs[ id ]
+       if rec.nil?
+          puts "#{@recs.size} stadiums:"
+          pp @recs.keys
+          raise ArgumentError, "stadium not found using >#{id}< - #{h.pretty_inspect}"
+       end
+       rec
+   end
+
+
+
+   def as_json( id: false )  ## note ignore remove id for now
+        @recs.values.as_json
+   end
+
+   def size() @recs.size; end
+
+end  # class Stadiums

data/lib/fifadat/tables/stages.rb

@@ -0,0 +1,58 @@
+
+
+
+class Stages
+
+   def self.read( path )
+       data = read_json_v2( path )
+       obj = new
+       obj.add( data['Results'] )
+       obj
+   end
+
+
+   def initialize
+      @recs = {}
+   end
+
+   def add( recs )    ## rename to collect - why? why not?
+      recs.each { |h| _add( Stage.build(h)) }
+   end
+
+
+   def _add( new_rec )
+      rec =  @recs[ new_rec.name ]
+      if rec.nil?
+          @recs[ new_rec.name ] = new_rec
+      else
+          raise ArgumentError, "duplicate stage entry: #{new_rec.pretty_inspect}"
+      end
+   end
+
+
+   ## add match stats
+   def add_matches( matches )
+        matches.each do |m|
+          name = desc( m['StageName'] )
+          rec  = find!( name )
+          rec.count += 1
+        end
+   end
+
+
+   def find!( name )
+       rec = @recs[ name ]
+       raise ArgumentError, "no stage w/ name >#{name}< found; sorry"  if rec.nil?
+       rec
+   end
+
+   def as_json(*)
+        ## note - sort by seq
+        @recs.values.sort do |l,r|
+             l.seq <=> r.seq
+         end.as_json
+   end
+
+   def size() @recs.size; end
+
+end  # class Stages

data/lib/fifadat/tables/teams.rb

@@ -0,0 +1,57 @@
+
+
+
+class Teams        ## use/change to TeamsRegistry, TeamsLookup, etc
+   def initialize
+      @recs = {}
+   end
+
+   def add_matches( matches )
+      ## note -   if team nil - will (auto-)add nil team (<nil>,?,?,?)
+      matches.each do |m|
+        rec1 = _add( Team.build( m['Home'] ) )
+        rec2 = _add( Team.build( m['Away'] ) )
+
+        stage_name = desc(m['StageName'])
+        rec1.count[stage_name] += 1
+        rec2.count[stage_name] += 1
+      end
+   end
+
+
+
+   def _add( new_rec )
+      rec =  @recs[ new_rec.id ]
+      if rec.nil?
+          rec = new_rec
+          @recs[ new_rec.id ] = new_rec
+      else
+          ## assert attributes equal - why? why not?
+          assert( new_rec == rec,
+                  "team records NOT matching - #{rec.pretty_inspect} != #{new_rec.pretty_inspect}")
+      end
+      rec
+   end
+
+
+   def find!( h )
+      ##  team1 = teams.find( m['HomeTeam'] )
+      ##  team2 = teams.find( m['AwayTeam'] )
+      ##  use lookup by  "IdTeam": "33161" for now - why? why not?
+
+      ## check for nil - why? why not?
+       rec = @recs[ h['IdTeam'] ]
+       raise ArgumentError, "team not found using #{h.pretty_inspect}  "  if rec.nil?
+       rec
+   end
+
+
+
+
+   def as_json( id: false )  ## note ignore remove id for now
+        @recs.values.as_json
+   end
+
+   def size() @recs.size; end
+
+end  # class Teams

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fifadat-convert
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-24 00:00:00.000000000 Z
+date: 2026-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fifadat
@@ -74,26 +74,30 @@ files:
 - Rakefile
 - bin/fifadat
 - lib/fifadat/convert.rb
-- lib/fifadat/convert/build_match.rb
-- lib/fifadat/convert/build_report.rb
 - lib/fifadat/convert/convert-reports.rb
 - lib/fifadat/convert/convert.rb
 - lib/fifadat/convert/errata.rb
-- lib/fifadat/convert/goals-calc_score.rb
-- lib/fifadat/convert/goals.rb
 - lib/fifadat/convert/helper-date.rb
 - lib/fifadat/convert/helper-minute.rb
 - lib/fifadat/convert/helper-score.rb
 - lib/fifadat/convert/norm.rb
-- lib/fifadat/convert/officials.rb
-- lib/fifadat/convert/penalties.rb
-- lib/fifadat/convert/players.rb
-- lib/fifadat/convert/stadiums.rb
-- lib/fifadat/convert/stages.rb
-- lib/fifadat/convert/substitutions.rb
-- lib/fifadat/convert/teams.rb
+- lib/fifadat/convert/reader.rb
 - lib/fifadat/convert/tool.rb
 - lib/fifadat/convert/version.rb
+- lib/fifadat/models/goal.rb
+- lib/fifadat/models/match.rb
+- lib/fifadat/models/match_report.rb
+- lib/fifadat/models/official.rb
+- lib/fifadat/models/penalty.rb
+- lib/fifadat/models/player.rb
+- lib/fifadat/models/stadium.rb
+- lib/fifadat/models/stage.rb
+- lib/fifadat/models/substitution.rb
+- lib/fifadat/models/team.rb
+- lib/fifadat/tables/players.rb
+- lib/fifadat/tables/stadiums.rb
+- lib/fifadat/tables/stages.rb
+- lib/fifadat/tables/teams.rb
 - lib/fifadata-convert.rb
 homepage: https://github.com/sportdb/sport.db
 licenses:

data/lib/fifadat/convert/build_match.rb

@@ -1,105 +0,0 @@
-
-
-
-def _build_match( m )   ## use _fill/build_match_basics() or such ???
-    rec = {}
-
-       ## 0 =>   FINISHED/complete (OK)
-       ## 1 =>   SCHEDULED/not yet played
-       status = m['MatchStatus']
-       timed  = m['TimeDefined']
-
-       if status == 1 && timed    ## note: use TIMED (instead of SCHEDULED)
-          rec[:status] = 'TIMED'
-       else
-          rec[:status] = MATCH_STATUS[ status ] || "#{status}-???"
-       end
-
-
-
-       rec[:stage]  = desc( m['StageName'] )
-
-       ## check optional  group, matchday, (match) num
-       ##    note - matchday is a string!! (check if always a number)
-       ##      ## convert to int if str - why? why not??
-       group = desc( m['GroupName'] )
-       rec[:group]  = group   if group
-
-       matchday  = m['MatchDay']
-       rec[:matchday]  = matchday.to_i(10)  if matchday
-
-       num  = m['MatchNumber']
-       rec[:num]  = num   if num
-
-
-       dateTime       = parse_date_utc( m['Date'] )
-       localDateTime  = parse_date_utc( m['LocalDate'] )
-
-       if timed
-         ##  pass along as is for now - why? why not
-         ##   note - Date is date_utc and
-         ##      LocalDate is date_local (also in utc BUT different HH:MM or possible day)
-         ## note - also in utc, that is, timezone is Z (not +03:00 or such!!!)
-
-         ## note - use datetime  - why? why not?
-         ##
-         ## note - cut-off/remove seconds
-         rec[:datetime_utc]   = dateTime.strftime( '%Y-%m-%dT%H:%MZ' )
-
-         ## note - use  20:30 UTC+1  or 20:30 UTC-3  for timezone format for now
-         rec[:datetime_local] = _fmt_date_local( dateTime, localDateTime )
-       else
-         rec[:date]      = dateTime.strftime( '%Y-%m-%d' )
-       end
-
-
-
-       if m['HomeTeam'] && m['AwayTeam']   ## assume match reports
-         team1 = build_team( m['HomeTeam'] )
-         team2 = build_team( m['AwayTeam'] )
-          ##  use full team details here (via lookup)
-         ##         when report (mode) - why? why not?
-         rec[:team1] = team1[:name]
-         rec[:team2] = team2[:name]
-       else
-         team1 =  build_team( m['Home'] )
-         team2 =  build_team( m['Away'] )
-         rec[:team1] = team1[:name]
-         rec[:team2] = team2[:name]
-       end
-
-
-
-  #####
-  #  handle score
-  ## m = (full) match hash incl.  IdMatch, etc.
-  ##  returns string e.g.  4-4  or 4-3 a.e.t etc
-
-     score = _parse_score( m )
-     rec[:score] = score      unless score.empty?
-
-
-       ## check - never in use?
-       rec[:home]  = true    if m['IsHome']
-
-
-       ## add country to stadium too - why? why not?
-       stadium = build_stadium( m['Stadium'] )
-
-
-       if m['HomeTeam'] && m['AwayTeam']   ## assume match reports
-         rec[:stadium] = {  name: stadium[:name],
-                            city: stadium[:city],
-                            street: stadium[:street],
-                            country: stadium[:country] }
-       else
-          rec[:stadium] = {  name:    stadium[:name],
-                              city:    stadium[:city] }
-       end
-
-       attendance = m['Attendance']
-       rec[:attendance] = attendance.to_i(10)   if attendance
-
-
-      rec
-end