jumbotron 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02e887f5ad4260dddda6dde8d391430ffbad31b7b7069dd851e9560cd6f92540
-  data.tar.gz: 1a18545151d81f504bc9bf208316ff2b1cf68086f062cf590d0953f9ca28e546
+  metadata.gz: 59e55efb1ece4d237011869ce7416fd4cda99a2e95feb914c21e93a3f23aecaa
+  data.tar.gz: 2199925a6f4a46d2db581c63e2a5eb55b81a26483195a396a4b7c111ae41bee1
 SHA512:
-  metadata.gz: c20c23af5c011df7a9ea866a1923e37abf79b3eea2dfe82e47b561051f3ba6bc43dfb519def7288007e71c7a801020e9d5b32f3d2a76be82c6b85061c2f9bbe1
-  data.tar.gz: 5414a02d268f32a257752bc29e47b959c46a0dc9b6d680da58c789ff22bd6d76a56a4c264a0068bc32f91aef79a40827b4568a731807dedfcf975966a452d63c
+  metadata.gz: ae7c4b2c06eed8291bafcb279940f0ca45ad5b33a62cc5970a5c1d353eae0c4d8bde4173e62811d13dade3038107940a828f37b2b3e1c1d6a7f2c118f62d5447
+  data.tar.gz: 8ecd32a04d755e5eb0422fccbb98b10beead9f3b88de8f8e885f2b8e4f458af6a672d1bdf9a63040b88e352186cea328565263dff18d001298b1a0cf97389748

data/app/adapters/jumbotron/adapters/espn/nfl.rb

@@ -66,6 +66,21 @@ module Jumbotron
                  INTERRUPTED_LIFECYCLES.include?(game.lifecycle)
                }
 
+        # Bounded post-final scoreboard re-observation when post-game record is still
+        # missing (Strategy B). Stops after window or once post_game is persisted.
+        policy :post_final_record,
+               type: :post_final_game_update,
+               cadence: Cadence.new(every: 15, unit: :minute),
+               eligible: lambda { |game, now:|
+                 return false unless game.lifecycle == "completed"
+                 return false if game.changed_at.nil? || game.changed_at < now - 6.hours
+
+                 participants = game.game_participants
+                 return false if participants.empty?
+
+                 participants.any? { |participant| participant.record_summary_post_game.blank? }
+               }
+
         policy :far_future_lines,
                type: :future_line_update,
                cadence: Cadence.new(every: 1, unit: :week),

data/app/adapters/jumbotron/adapters/espn/nfl_helpers/scoreboard.rb

@@ -80,11 +80,14 @@ module Jumbotron
             raise TransformError, "venue id required" if venue.id.blank?
             raise TransformError, "venue name required" if venue.full_name.blank?
 
+            address = venue.respond_to?(:address) ? venue.address : nil
             Canonical::VenueInput.new(
               provider_identities: [
                 Canonical::ProviderIdentityRef.new(provider: "espn", namespace: "venue", id: venue.id.to_s)
               ],
-              name: venue.full_name.to_s
+              name: venue.full_name.to_s,
+              city: address&.city.presence,
+              region: address&.state.presence
             )
           end
           private_class_method :transform_venue
@@ -104,13 +107,22 @@ module Jumbotron
               ],
               team_name: name.to_s,
               team_nickname: TeamNickname.resolve(team),
+              team_abbreviation: team.abbreviation.presence,
               role: competitor.home_away.to_s,
               score: coerce_score(competitor.score),
-              result: coerce_result(competitor.winner, lifecycle)
+              result: coerce_result(competitor.winner, lifecycle),
+              record_summary: total_record_summary(competitor)
             )
           end
           private_class_method :transform_participant
 
+          def self.total_record_summary(competitor)
+            records = competitor.respond_to?(:records) ? Array(competitor.records) : []
+            total = records.find { |record| record.type.to_s == "total" }
+            total&.summary.presence
+          end
+          private_class_method :total_record_summary
+
           def self.coerce_score(raw)
             return nil if raw.nil? || raw == ""
 

data/app/adapters/jumbotron/adapters/espn/nfl_helpers/teams.rb

@@ -25,7 +25,8 @@ module Jumbotron
                 Canonical::ProviderIdentityRef.new(provider: "espn", namespace: "team", id: team.id.to_s)
               ],
               name: name.to_s,
-              nickname: TeamNickname.resolve(team)
+              nickname: TeamNickname.resolve(team),
+              abbreviation: team.abbreviation.presence
             )
           end
           private_class_method :transform_team

data/app/deserializers/jumbotron/deserializers/clients/espn/competitor.rb

@@ -13,6 +13,7 @@ module Jumbotron
             field :winner, type: Support.types.boolean, nullable: true
             field :order, type: Support.types.integer, nullable: true
             field :team, type: Team::Result, required: true
+            field :records, type: Support.types.array(CompetitorRecord::Result), nullable: true
           end
 
           def self.call(payload)
@@ -25,10 +26,22 @@ module Jumbotron
               score: coerce_score(Support.payload.fetch(payload, "score")),
               winner: Support.payload.fetch(payload, "winner"),
               order: Support.payload.fetch(payload, "order"),
-              team: Support.nest("team", Support.payload.fetch(payload, "team")) { |raw| Team.call(raw) }
+              team: Support.nest("team", Support.payload.fetch(payload, "team")) { |raw| Team.call(raw) },
+              records: map_records(Support.payload.fetch(payload, "records"))
             )
           end
 
+          def self.map_records(raw)
+            return nil if raw.equal?(Support.missing) || raw.nil?
+
+            Array(raw).each_with_index.map do |item, index|
+              CompetitorRecord.call(item)
+            rescue CommandTower::Clients::Errors::DeserializationError => e
+              raise CommandTower::Deserializers::Clients::Errors.prefix(e, "records[#{index}]")
+            end
+          end
+          private_class_method :map_records
+
           def self.coerce_id(raw)
             return raw if raw.equal?(Support.missing) || raw.nil? || raw.is_a?(String)
 

data/app/deserializers/jumbotron/deserializers/clients/espn/competitor_record.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        class CompetitorRecord
+          class Result < CommandTower::Deserializers::Clients::Result
+            field :type, type: Support.types.string, required: true
+            field :summary, type: Support.types.string, required: true
+            field :name, type: Support.types.string, nullable: true
+          end
+
+          def self.call(payload)
+            Support.ensure_hash!(payload, label: "competitor.record")
+
+            Result.build!(
+              type: Support.payload.fetch(payload, "type"),
+              summary: Support.payload.fetch(payload, "summary"),
+              name: Support.payload.fetch(payload, "name")
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/venue.rb

@@ -9,6 +9,7 @@ module Jumbotron
             field :id, type: Support.types.string, required: true
             field :full_name, type: Support.types.string, required: true
             field :indoor, type: Support.types.boolean, nullable: true
+            field :address, type: VenueAddress::Result, nullable: true
           end
 
           def self.call(payload)
@@ -17,10 +18,18 @@ module Jumbotron
             Result.build!(
               id: coerce_id(Support.payload.fetch(payload, "id")),
               full_name: Support.payload.fetch(payload, "fullName"),
-              indoor: Support.payload.fetch(payload, "indoor")
+              indoor: Support.payload.fetch(payload, "indoor"),
+              address: map_address(Support.payload.fetch(payload, "address"))
             )
           end
 
+          def self.map_address(raw)
+            return nil if raw.equal?(Support.missing) || raw.nil?
+
+            VenueAddress.call(raw)
+          end
+          private_class_method :map_address
+
           def self.coerce_id(raw)
             return raw if raw.equal?(Support.missing) || raw.nil? || raw.is_a?(String)
 

data/app/deserializers/jumbotron/deserializers/clients/espn/venue_address.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        class VenueAddress
+          class Result < CommandTower::Deserializers::Clients::Result
+            field :city, type: Support.types.string, nullable: true
+            field :state, type: Support.types.string, nullable: true
+            field :country, type: Support.types.string, nullable: true
+          end
+
+          def self.call(payload)
+            Support.ensure_hash!(payload, label: "venue.address")
+
+            Result.build!(
+              city: Support.payload.fetch(payload, "city"),
+              state: Support.payload.fetch(payload, "state"),
+              country: Support.payload.fetch(payload, "country")
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/jumbotron/canonical.rb

@@ -4,13 +4,17 @@ module Jumbotron
   module Canonical
     ProviderIdentityRef = Data.define(:provider, :namespace, :id)
 
-    TeamInput = Data.define(:provider_identities, :name, :nickname) do
-      def initialize(provider_identities:, name:, nickname: nil)
+    TeamInput = Data.define(:provider_identities, :name, :nickname, :abbreviation) do
+      def initialize(provider_identities:, name:, nickname: nil, abbreviation: nil)
         super
       end
     end
 
-    VenueInput = Data.define(:provider_identities, :name)
+    VenueInput = Data.define(:provider_identities, :name, :city, :region) do
+      def initialize(provider_identities:, name:, city: nil, region: nil)
+        super
+      end
+    end
 
     ParticipantInput = Data.define(
       :provider_identities,
@@ -18,9 +22,20 @@ module Jumbotron
       :role,
       :score,
       :result,
-      :team_nickname
+      :team_nickname,
+      :team_abbreviation,
+      :record_summary
     ) do
-      def initialize(provider_identities:, team_name:, role:, score:, result:, team_nickname: nil)
+      def initialize(
+        provider_identities:,
+        team_name:,
+        role:,
+        score:,
+        result:,
+        team_nickname: nil,
+        team_abbreviation: nil,
+        record_summary: nil
+      )
         super
       end
     end

data/app/models/jumbotron/public.rb

@@ -19,13 +19,21 @@ module Jumbotron
       :season_phase,
       :kind
     )
-    Team = Data.define(:id, :name, :nickname, :key) do
-      def initialize(id:, name:, key:, nickname: nil)
-        super(id:, name:, nickname:, key:)
+    Team = Data.define(:id, :name, :nickname, :key, :abbreviation) do
+      def initialize(id:, name:, key:, nickname: nil, abbreviation: nil)
+        super(id:, name:, nickname:, key:, abbreviation:)
+      end
+    end
+    Venue = Data.define(:id, :name, :city, :region) do
+      def initialize(id:, name:, city: nil, region: nil)
+        super
+      end
+    end
+    Participant = Data.define(:role, :score, :result, :team, :record) do
+      def initialize(role:, score:, result:, team:, record: nil)
+        super
       end
     end
-    Venue = Data.define(:id, :name)
-    Participant = Data.define(:role, :score, :result, :team)
     GameSegment = Data.define(:kind, :number)
     # Clock label text. Name is canonical/public contract, not Kernel#display.
     GameClock = Data.define(:mode, :seconds, :display) # rubocop:disable Lint/DataDefineOverride

data/app/services/jumbotron/services/adapters/resolve_game_update_policy.rb

@@ -8,6 +8,7 @@ module Jumbotron
           future_game_update
           live_game_update
           interrupted_game_update
+          post_final_game_update
         ].freeze
 
         validate :adapter_id, required: true

data/app/services/jumbotron/services/adapters/select_eligible_games.rb

@@ -20,7 +20,7 @@ module Jumbotron
           end
 
           games = Game.where(league_id: league.id)
-                      .includes(:season, :season_phase, :schedule_group)
+                      .includes(:season, :season_phase, :schedule_group, :game_participants)
                       .select { |game| policy.eligible?(game, now: now) }
 
           context.league = league

data/app/services/jumbotron/services/canonical/upsert_game_participant.rb

@@ -14,7 +14,8 @@ module Jumbotron
             team_input: Jumbotron::Canonical::TeamInput.new(
               provider_identities: participant_input.provider_identities,
               name: participant_input.team_name,
-              nickname: participant_input.team_nickname
+              nickname: participant_input.team_nickname,
+              abbreviation: participant_input.team_abbreviation
             ),
             observed_at: observed_at,
             change_set: change_set
@@ -46,16 +47,18 @@ module Jumbotron
         end
 
         def create_new!(team)
-          gp = game.game_participants.create!(
+          attrs = {
             team: team,
             role: participant_input.role,
             score: participant_input.score,
             result: participant_input.result,
             observed_at: observed_at,
             changed_at: observed_at
-          )
+          }.merge(initial_record_attrs)
+          gp = game.game_participants.create!(attrs)
           change_set.record(subject: gp, attribute: "role", previous: nil, new_value: gp.role)
           change_set.record(subject: gp, attribute: "score", previous: nil, new_value: gp.score)
+          record_create_history!(gp)
           gp
         end
 
@@ -78,11 +81,96 @@ module Jumbotron
             participant.public_send("#{key}=", value)
             material = true
           end
+          material |= apply_record_snapshots!(participant)
           participant.observed_at = observed_at
           participant.changed_at = observed_at if material
           participant.save!
           participant
         end
+
+        def initial_record_attrs
+          summary = participant_input.record_summary
+          return {} if summary.blank?
+
+          attrs = {
+            record_summary_current: summary,
+            record_observed_at: observed_at
+          }
+          if game.lifecycle == "completed"
+            attrs[:record_summary_post_game] = summary
+          elsif game.lifecycle != "cancelled"
+            attrs[:record_summary_entering] = summary
+          end
+          attrs
+        end
+
+        def record_create_history!(participant)
+          %i[
+            record_summary_entering
+            record_summary_current
+            record_summary_post_game
+          ].each do |attr|
+            value = participant.public_send(attr)
+            next if value.blank?
+
+            change_set.record(subject: participant, attribute: attr.to_s, previous: nil, new_value: value)
+          end
+        end
+
+        def apply_record_snapshots!(participant)
+          summary = participant_input.record_summary
+          return false if summary.blank?
+
+          material = false
+          if participant.record_summary_current != summary
+            change_set.record(
+              subject: participant,
+              attribute: "record_summary_current",
+              previous: participant.record_summary_current,
+              new_value: summary
+            )
+            participant.record_summary_current = summary
+            material = true
+          end
+          participant.record_observed_at = observed_at
+
+          if game.lifecycle == "completed"
+            material |= apply_post_game_record!(participant, summary)
+          elsif game.lifecycle != "cancelled"
+            material |= assign_entering_record!(participant, summary)
+          end
+          material
+        end
+
+        def assign_entering_record!(participant, summary) # rubocop:disable Naming/PredicateMethod
+          return false if participant.record_summary_entering == summary
+
+          change_set.record(
+            subject: participant,
+            attribute: "record_summary_entering",
+            previous: participant.record_summary_entering,
+            new_value: summary
+          )
+          participant.record_summary_entering = summary
+          true
+        end
+
+        # Authoritative post-game only: never invent W–L; if total still equals
+        # entering on a completed observation, leave post_game nil (Strategy B).
+        def apply_post_game_record!(participant, summary) # rubocop:disable Naming/PredicateMethod
+          entering = participant.record_summary_entering
+          return false if entering.present? && summary == entering
+          return false if participant.record_summary_post_game == summary
+
+          change_set.record(
+            subject: participant,
+            attribute: "record_summary_post_game",
+            previous: participant.record_summary_post_game,
+            new_value: summary
+          )
+          participant.record_summary_post_game = summary
+          true
+        end
       end
     end
   end

data/app/services/jumbotron/services/canonical/upsert_team.rb

@@ -58,6 +58,7 @@ module Jumbotron
             team.changed_at = observed_at
           end
           apply_nickname!(team)
+          apply_abbreviation!(team)
           # key is immutable after assignment — never regenerate from name or provider id
           team.observed_at = observed_at
           team.save!
@@ -68,6 +69,7 @@ module Jumbotron
           team = Team.create!(
             name: team_input.name,
             nickname: team_input.nickname,
+            abbreviation: team_input.abbreviation,
             key: allocate_key!(team_input.name),
             observed_at: observed_at,
             changed_at: observed_at
@@ -82,6 +84,14 @@ module Jumbotron
               new_value: team.nickname
             )
           end
+          if team.abbreviation.present?
+            change_set.record(
+              subject: team,
+              attribute: "abbreviation",
+              previous: nil,
+              new_value: team.abbreviation
+            )
+          end
           team
         end
 
@@ -99,6 +109,20 @@ module Jumbotron
           team.changed_at = observed_at
         end
 
+        def apply_abbreviation!(team)
+          return if team_input.abbreviation.nil?
+          return if team.abbreviation == team_input.abbreviation
+
+          change_set.record(
+            subject: team,
+            attribute: "abbreviation",
+            previous: team.abbreviation,
+            new_value: team_input.abbreviation
+          )
+          team.abbreviation = team_input.abbreviation
+          team.changed_at = observed_at
+        end
+
         def allocate_key!(name)
           base = Jumbotron::TeamKey.normalize(name)
           return base unless Team.exists?(key: base)

data/app/services/jumbotron/services/canonical/upsert_venue.rb

@@ -52,6 +52,7 @@ module Jumbotron
 
         def update_existing!(venue_id)
           venue = Venue.lock.find(venue_id)
+          material = false
           if venue.name != venue_input.name
             change_set.record(
               subject: venue,
@@ -60,8 +61,10 @@ module Jumbotron
               new_value: venue_input.name
             )
             venue.name = venue_input.name
-            venue.changed_at = observed_at
+            material = true
           end
+          material |= apply_location!(venue)
+          venue.changed_at = observed_at if material
           venue.observed_at = observed_at
           venue.save!
           venue
@@ -70,13 +73,42 @@ module Jumbotron
         def create_new!
           venue = Venue.create!(
             name: venue_input.name,
+            city: venue_input.city,
+            region: venue_input.region,
             observed_at: observed_at,
             changed_at: observed_at
           )
           change_set.record(subject: venue, attribute: "name", previous: nil, new_value: venue.name)
+          if venue.city.present?
+            change_set.record(subject: venue, attribute: "city", previous: nil, new_value: venue.city)
+          end
+          if venue.region.present?
+            change_set.record(subject: venue, attribute: "region", previous: nil, new_value: venue.region)
+          end
           venue
         end
 
+        def apply_location!(venue)
+          material = false
+          {
+            city: venue_input.city,
+            region: venue_input.region
+          }.each do |key, value|
+            next if value.nil?
+            next if venue.public_send(key) == value
+
+            change_set.record(
+              subject: venue,
+              attribute: key.to_s,
+              previous: venue.public_send(key),
+              new_value: value
+            )
+            venue.public_send("#{key}=", value)
+            material = true
+          end
+          material
+        end
+
         def recover_after_race!
           ref = venue_input.provider_identities.first
           identity = ProviderIdentity.find_by!(

data/app/services/jumbotron/services/public/assemble_public_game.rb

@@ -61,7 +61,12 @@ module Jumbotron
         def build_venue(venue)
           return if venue.nil?
 
-          Jumbotron::Public::Venue.new(id: venue.id, name: venue.name)
+          Jumbotron::Public::Venue.new(
+            id: venue.id,
+            name: venue.name,
+            city: venue.city,
+            region: venue.region
+          )
         end
 
         def build_participant(participant)
@@ -69,15 +74,28 @@ module Jumbotron
             role: participant.role,
             score: participant.score,
             result: participant.result,
+            record: resolve_presentation_record(participant),
             team: Jumbotron::Public::Team.new(
               id: participant.team.id,
               name: participant.team.name,
               nickname: participant.team.nickname,
-              key: participant.team.key
+              key: participant.team.key,
+              abbreviation: participant.team.abbreviation
             )
           )
         end
 
+        # Lifecycle-resolved game-time record for presentation. Never falls back to
+        # entering when completed post-game is missing.
+        def resolve_presentation_record(participant)
+          case game.lifecycle
+          when "scheduled", "in_progress", "postponed", "suspended"
+            participant.record_summary_entering
+          when "completed"
+            participant.record_summary_post_game
+          end
+        end
+
         def map_currents(lines)
           return [] unless Array(includes).include?(:current_lines)
 

data/db/migrate/20260828220001_add_game_presentation_contract_fields.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class AddGamePresentationContractFields < ActiveRecord::Migration[8.0]
+  def change
+    change_table :jumbotron_game_participants, bulk: true do |t|
+      t.string :record_summary_entering
+      t.string :record_summary_current
+      t.string :record_summary_post_game
+      t.datetime :record_observed_at
+    end
+
+    change_table :jumbotron_venues, bulk: true do |t|
+      t.string :city
+      t.string :region
+    end
+
+    add_column :jumbotron_teams, :abbreviation, :string
+  end
+end

data/lib/jumbotron/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Jumbotron
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jumbotron
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - matt-taylor
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-08-28 00:00:00.000000000 Z
+date: 2026-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: command_tower
@@ -91,6 +91,7 @@ files:
 - app/deserializers/jumbotron/deserializers/clients/espn/competition_odds/side_quote.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/competition_odds/team_odds.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/competitor.rb
+- app/deserializers/jumbotron/deserializers/clients/espn/competitor_record.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/event.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/scoreboard/get.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/season.rb
@@ -99,6 +100,7 @@ files:
 - app/deserializers/jumbotron/deserializers/clients/espn/team.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/teams/get.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/venue.rb
+- app/deserializers/jumbotron/deserializers/clients/espn/venue_address.rb
 - app/deserializers/jumbotron/deserializers/clients/espn/week.rb
 - app/deserializers/jumbotron/deserializers/public/game.rb
 - app/deserializers/jumbotron/deserializers/public/game_ids.rb
@@ -208,6 +210,7 @@ files:
 - db/migrate/20260820000001_add_progress_to_jumbotron_games.rb
 - db/migrate/20260827150001_add_key_to_jumbotron_teams.rb
 - db/migrate/20260828180001_add_nickname_to_jumbotron_teams.rb
+- db/migrate/20260828220001_add_game_presentation_contract_fields.rb
 - docs/testing.md
 - docs/upgrades/0.1.2.md
 - docs/upgrades/0.1.3.md