Reapply "Extract modeling ViewerData class into new Pet::ModelingSnapshot file"

This change was modified a bit after cherry-picking, to no longer
include the broken changes to item modeling in 9eaee4a.

(cherry picked from commit 90407403ba)

app/controllers/pets_controller.rb

@@ -1,12 +1,10 @@
 class PetsController < ApplicationController
   rescue_from Neopets::CustomPets::PetNotFound, with: :pet_not_found
   rescue_from Neopets::CustomPets::DownloadError, with: :pet_download_error
+  rescue_from Pet::ModelingDisabled, with: :modeling_disabled
   rescue_from Pet::UnexpectedDataFormat, with: :unexpected_data_format
 
   def load
-    # Uncomment this to temporarily disable modeling for most users.
-    # return modeling_disabled unless user_signed_in? && current_user.admin?
-
     raise Neopets::CustomPets::PetNotFound unless params[:name]
     @pet = Pet.load(params[:name])
     points = contribute(current_user, @pet)

app/models/alt_style.rb

@@ -74,15 +74,6 @@ class AltStyle < ApplicationRecord
     Item.appearances_for(items, self, ...)
   end
 
-  def biology=(biology)
-    # TODO: This is very similar to what `PetState` does, but like… much much
-    # more compact? Idk if I'm missing something, or if I was just that much
-    # more clueless back when I wrote it, lol 😅
-    self.swf_assets = biology.values.map do |asset_data|
-      SwfAsset.from_biology_data(self.body_id, asset_data)
-    end
-  end
-
   # At time of writing, most batches of Alt Styles thumbnails used a simple
   # pattern for the item thumbnail URL, but that's not always the case anymore.
   # For now, let's keep using this format as the default value when creating a

app/models/pet.rb

@@ -4,66 +4,17 @@ class Pet < ApplicationRecord
   attr_reader :items, :pet_state, :alt_style
 
   def load!(timeout: nil)
-    viewer_data = Neopets::CustomPets.fetch_viewer_data(name, timeout:)
+    raise ModelingDisabled unless Rails.configuration.modeling_enabled
-    use_viewer_data(viewer_data)
+
+    viewer_data_hash = Neopets::CustomPets.fetch_viewer_data(name, timeout:)
+    use_modeling_snapshot(ModelingSnapshot.new(viewer_data_hash))
   end
 
-  def use_viewer_data(viewer_data)
+  def use_modeling_snapshot(snapshot)
-    pet_data = viewer_data[:custom_pet]
+    self.pet_type = snapshot.pet_type
-
+    @pet_state = snapshot.pet_state
-    raise UnexpectedDataFormat unless pet_data[:species_id]
+    @alt_style = snapshot.alt_style
-    raise UnexpectedDataFormat unless pet_data[:color_id]
+    @items = snapshot.items
-    raise UnexpectedDataFormat unless pet_data[:body_id]
-
-    has_alt_style = pet_data[:alt_style].present?
-
-    self.pet_type = PetType.find_or_initialize_by(
-      species_id: pet_data[:species_id].to_i,
-      color_id: pet_data[:color_id].to_i
-    )
-
-    begin
-      new_image_hash = Neopets::CustomPets.fetch_image_hash(self.name)
-    rescue => error
-      Rails.logger.warn "Failed to load image hash: #{error.full_message}"
-    end
-    self.pet_type.image_hash = new_image_hash if new_image_hash.present?
-
-    # With an alt style, `body_id` in the biology data refers to the body ID of
-    # the *alt* style, not the usual pet type. (We have `original_biology` for
-    # *some* of the pet type's situation, but not it's body ID!)
-    #
-    # So, in the alt style case, don't update `body_id` - but if this is our
-    # first time seeing this pet type and it doesn't *have* a `body_id` yet,
-    # let's not be creating it without one. We'll need to model it without the
-    # alt style first. (I don't bother with a clear error message though 😅)
-    self.pet_type.body_id = pet_data[:body_id] unless has_alt_style
-    if self.pet_type.body_id.nil?
-      raise UnexpectedDataFormat,
-        "can't process alt style on first occurrence of pet type"
-    end
-
-    pet_state_biology = has_alt_style ? pet_data[:original_biology] :
-      pet_data[:biology_by_zone]
-    raise UnexpectedDataFormat if pet_state_biology.empty?
-    pet_state_biology[0] = nil # remove effects if present
-    @pet_state = self.pet_type.add_pet_state_from_biology! pet_state_biology
-
-    if has_alt_style
-      raise UnexpectedDataFormat unless pet_data[:alt_color]
-      raise UnexpectedDataFormat if pet_data[:biology_by_zone].empty?
-
-      @alt_style = AltStyle.find_or_initialize_by(id: pet_data[:alt_style].to_i)
-      @alt_style.assign_attributes(
-        color_id: pet_data[:alt_color].to_i,
-        species_id: pet_data[:species_id].to_i,
-        body_id: pet_data[:body_id].to_i,
-        biology: pet_data[:biology_by_zone],
-      )
-    end
-
-    @items = Item.collection_from_pet_type_and_registries(self.pet_type,
-      viewer_data[:object_info_registry], viewer_data[:object_asset_registry])
   end
 
   def wardrobe_query
@@ -89,11 +40,8 @@ class Pet < ApplicationRecord
 
   before_validation do
     pet_type.save!
-    if @pet_state
+    @pet_state.save! if @pet_state
-      @pet_state.save!
+
-      @pet_state.handle_assets!
-    end
-    
     if @items
       @items.each do |item|
         item.save! if item.changed?
@@ -113,5 +61,5 @@ class Pet < ApplicationRecord
   end
 
   class UnexpectedDataFormat < RuntimeError;end
+  class ModelingDisabled < RuntimeError;end
 end
-

app/models/pet/modeling_snapshot.rb

@@ -0,0 +1,104 @@
+# A representation of a Neopets::CustomPets viewer data response, translated
+# to DTI's database models!
+class Pet::ModelingSnapshot
+  def initialize(viewer_data_hash)
+    @custom_pet = viewer_data_hash[:custom_pet]
+    @object_info_registry = viewer_data_hash[:object_info_registry]
+    @object_asset_registry = viewer_data_hash[:object_asset_registry]
+  end
+
+  def pet_type
+    @pet_type ||= begin
+      raise Pet::UnexpectedDataFormat unless @custom_pet[:species_id]
+      raise Pet::UnexpectedDataFormat unless @custom_pet[:color_id]
+      raise Pet::UnexpectedDataFormat unless @custom_pet[:body_id]
+
+      @custom_pet => {species_id:, color_id:}
+      PetType.find_or_initialize_by(species_id:, color_id:).tap do |pet_type|
+        # Apply the pet's body ID to the pet type, unless it's wearing an alt
+        # style, in which case ignore it, because it's the *alt style*'s body ID.
+        # (This can theoretically cause a problem saving a new pet type when
+        # there's an alt style too!)
+        pet_type.body_id = @custom_pet[:body_id] unless @custom_pet[:alt_style]
+        if pet_type.body_id.nil?
+          raise Pet::UnexpectedDataFormat,
+            "can't process alt style on first occurrence of pet type"
+        end
+
+        # Try using this pet for the pet type's thumbnail, but don't worry
+        # if it fails.
+        begin
+          pet_type.consider_pet_image(@custom_pet[:name])
+        rescue => error
+          Rails.logger.warn "Failed to load pet image: #{error.full_message}"
+        end
+      end
+    end
+  end
+
+  def pet_state
+    @pet_state ||= begin
+      swf_asset_ids = biology_assets.map(&:remote_id)
+      pet_type.pet_states.find_or_initialize_by(swf_asset_ids:).tap do |pet_state|
+        pet_state.swf_assets = biology_assets
+      end
+    end
+  end
+
+  def alt_style
+    @alt_style ||= begin
+      return nil unless @custom_pet[:alt_style]
+      raise Pet::UnexpectedDataFormat unless @custom_pet[:alt_color]
+
+      id = @custom_pet[:alt_style].to_i
+      AltStyle.find_or_initialize_by(id:).tap do |alt_style|
+        alt_style.assign_attributes(
+          color_id: @custom_pet[:alt_color].to_i,
+          species_id: @custom_pet[:species_id].to_i,
+          body_id: @custom_pet[:body_id].to_i,
+          swf_assets: alt_style_assets,
+        )
+      end
+    end
+  end
+
+  def items
+    @items ||= Item.collection_from_pet_type_and_registries(
+      pet_type, @object_info_registry, @object_asset_registry
+    )
+  end
+
+  private
+
+  def biology_assets
+    @biology_assets ||= begin
+      biology = @custom_pet[:alt_style].present? ?
+        @custom_pet[:original_biology] :
+        @custom_pet[:biology_by_zone]
+      assets_from_biology(biology)
+    end
+  end
+
+  def item_assets_for(item_id)
+    all_infos = @object_asset_registry.values
+    infos = all_infos.select { |a| a[:obj_info_id].to_i == item_id.to_i }
+    infos.map do |asset_data|
+      remote_id = asset_data[:asset_id].to_i
+      SwfAsset.find_or_initialize_by(type: "object", remote_id:).tap do |swf_asset|
+        swf_asset.origin_pet_type = pet_type
+        swf_asset.origin_object_data = asset_data
+      end
+    end
+  end
+
+  def alt_style_assets
+    raise Pet::UnexpectedDataFormat if @custom_pet[:biology_by_zone].empty?
+    assets_from_biology(@custom_pet[:biology_by_zone])
+  end
+
+  def assets_from_biology(biology)
+    raise Pet::UnexpectedDataFormat if biology.empty?
+    body_id = @custom_pet[:body_id].to_i
+    biology.values.map { |b| SwfAsset.from_biology_data(body_id, b) }
+  end
+end

app/models/pet_state.rb

@@ -6,17 +6,16 @@ class PetState < ApplicationRecord
   has_many :contributions, :as => :contributed,
     :inverse_of => :contributed # in case of duplicates being merged
   has_many :outfits
-  has_many :parent_swf_asset_relationships, :as => :parent,
+  has_many :parent_swf_asset_relationships, :as => :parent
-    :autosave => false
   has_many :swf_assets, :through => :parent_swf_asset_relationships
 
+  serialize :swf_asset_ids, coder: Serializers::IntegerSet, type: Array
+
   belongs_to :pet_type
 
   delegate :species_id, :species, :color_id, :color, to: :pet_type
 
   alias_method :swf_asset_ids_from_association, :swf_asset_ids
-  
-  attr_writer :parent_swf_asset_relationships_to_update
 
   # A simple ordering that tries to bring reliable pet states to the front.
   scope :emotion_order, -> {
@@ -95,85 +94,16 @@ class PetState < ApplicationRecord
     end
   end
 
-  def sort_swf_asset_ids!
-    self.swf_asset_ids = swf_asset_ids_array.sort.join(',')
-  end
-
-  def swf_asset_ids
-    self['swf_asset_ids']
-  end
-
-  def swf_asset_ids_array
-    swf_asset_ids.split(',').map(&:to_i)
-  end
-
-  def swf_asset_ids=(ids)
-    self['swf_asset_ids'] = ids
-  end
-
-  def handle_assets!
-    @parent_swf_asset_relationships_to_update.each do |rel|
-      rel.swf_asset.save!
-      rel.save!
-    end
-  end
-
   def to_param
     "#{id}-#{pose.split('_').map(&:capitalize).join('-')}"
   end
 
-  def self.from_pet_type_and_biology_info(pet_type, info)
+  # Because our column is named `swf_asset_ids`, we need to ensure writes to
-    swf_asset_ids = []
+  # it go to the attribute, and not the thing ActiveRecord does of finding the
-    info.each do |zone_id, asset_info|
+  # relevant `swf_assets`.
-      if zone_id.present? && asset_info
+  # TODO: Consider renaming the column to `cached_swf_asset_ids`?
-        swf_asset_ids << asset_info[:part_id].to_i
+  def swf_asset_ids=(new_swf_asset_ids)
-      end
+    write_attribute(:swf_asset_ids, new_swf_asset_ids)
-    end
-    swf_asset_ids_str = swf_asset_ids.sort.join(',')
-    if pet_type.new_record?
-      pet_state = self.new :swf_asset_ids => swf_asset_ids_str
-    else
-      pet_state = self.find_or_initialize_by(
-        pet_type_id: pet_type.id,
-        swf_asset_ids: swf_asset_ids_str
-      )
-    end
-    existing_swf_assets = SwfAsset.biology_assets.includes(:zone).
-      where(remote_id: swf_asset_ids)
-    existing_swf_assets_by_id = {}
-    existing_swf_assets.each do |swf_asset|
-      existing_swf_assets_by_id[swf_asset.remote_id] = swf_asset
-    end
-    existing_relationships_by_swf_asset_id = {}
-    unless pet_state.new_record?
-      pet_state.parent_swf_asset_relationships.each do |relationship|
-        existing_relationships_by_swf_asset_id[relationship.swf_asset_id] = relationship
-      end
-    end
-    pet_state.pet_type = pet_type # save the second case from having to look it up by ID
-    relationships = []
-    info.each do |zone_id, asset_info|
-      if zone_id.present? && asset_info
-        swf_asset_id = asset_info[:part_id].to_i
-        swf_asset = existing_swf_assets_by_id[swf_asset_id]
-        unless swf_asset
-          swf_asset = SwfAsset.new
-          swf_asset.remote_id = swf_asset_id
-        end
-        swf_asset.origin_biology_data = asset_info
-        swf_asset.origin_pet_type = pet_type
-        relationship = existing_relationships_by_swf_asset_id[swf_asset.id]
-        unless relationship
-          relationship ||= ParentSwfAssetRelationship.new
-          relationship.parent = pet_state
-          relationship.swf_asset_id = swf_asset.id
-        end
-        relationship.swf_asset = swf_asset
-        relationships << relationship
-      end
-    end
-    pet_state.parent_swf_asset_relationships_to_update = relationships
-    pet_state
   end
 
   private

app/models/pet_type.rb

@@ -57,6 +57,14 @@ class PetType < ApplicationRecord
     basic_image_hash || self['image_hash'] || 'deadbeef'
   end
 
+  def consider_pet_image(pet_name)
+    # If we already have a basic image hash, don't worry about it!
+    return if basic_image_hash?
+
+    # Otherwise, use this as the new image hash for this pet type.
+    self.image_hash = Neopets::CustomPets.fetch_image_hash(pet_name)
+  end
+
   def possibly_new_color
     self.color || Color.new(id: self.color_id)
   end
@@ -71,11 +79,6 @@ class PetType < ApplicationRecord
                    species_human_name: possibly_new_species.human_name)
   end
 
-  def add_pet_state_from_biology!(biology)
-    pet_state = PetState.from_pet_type_and_biology_info(self, biology)
-    pet_state
-  end
-
   def canonical_pet_state
     # For consistency (randomness is always scary!), we use the PetType ID to
     # determine which gender to prefer, if it's not built into the color. That

config/environments/development.rb

@@ -103,6 +103,10 @@ Rails.application.configure do
   # Allow connections on Vagrant's private network.
   config.web_console.permissions = '10.0.2.2'
 
+  # Allow pets to model new data. (If modeling is ever broken, disable this in
+  # production while we fix it!)
+  config.modeling_enabled = true
+
   # Use a local copy of Impress 2020, presumably running on port 4000. (Can
   # override this with the IMPRESS_2020_ORIGIN environment variable!)
   config.impress_2020_origin = ENV.fetch("IMPRESS_2020_ORIGIN",

config/environments/production.rb

@@ -122,6 +122,10 @@ Rails.application.configure do
   # Skip DNS rebinding protection for the default health check endpoint.
   # config.host_authorization = { exclude: ->(request) { request.path == "/up" } }
 
+  # Allow pets to model new data. (If modeling is ever broken, disable this
+  # here while we fix it!)
+  config.modeling_enabled = false
+
   # Use the live copy of Impress 2020. (Can override this with the
   # IMPRESS_2020_ORIGIN environment variable!)
   config.impress_2020_origin = ENV.fetch("IMPRESS_2020_ORIGIN",

config/environments/test.rb

@@ -62,6 +62,10 @@ Rails.application.configure do
   # Raise error when a before_action's only/except options reference missing actions
   config.action_controller.raise_on_missing_callback_actions = true
 
+  # Allow pets to model new data. (If modeling is ever broken, disable this in
+  # production while we fix it!)
+  config.modeling_enabled = true
+
   # Use a local copy of Impress 2020, presumably running on port 4000. (Can
   # override this with the IMPRESS_2020_ORIGIN environment variable!)
   config.impress_2020_origin = ENV.fetch("IMPRESS_2020_ORIGIN",

spec/models/pet_spec.rb

@@ -36,7 +36,7 @@ RSpec.describe Pet, type: :model do
           let(:asset_ids) { biology_assets.map(&:remote_id) }
 
           they("are all new") { should all be_new_record }
-          pending("match the expected IDs (before saving)") do
+          they("match the expected IDs (before saving)") do
             expect(asset_ids).to contain_exactly(10083, 11613, 14187, 14189)
           end
           they("match the expected IDs (after saving)") do
@@ -44,7 +44,7 @@ RSpec.describe Pet, type: :model do
             expect(asset_ids).to contain_exactly(10083, 11613, 14187, 14189)
           end
           they("are saved when saving the pet") { pet.save!; should all be_persisted }
-          pending("have the expected asset metadata (before saving)") do
+          they("have the expected asset metadata (before saving)") do
             should contain_exactly(
               a_record_matching(
                 type: "biology",
@@ -187,11 +187,11 @@ RSpec.describe Pet, type: :model do
               biology_assets.select(&:new_record?).map(&:remote_id)
             }
 
-            pending("are partially new, partially existing") do
+            they("are partially new, partially existing") do
               expect(persisted_asset_ids).to contain_exactly(10083, 11613)
               expect(new_asset_ids).to contain_exactly(10448, 10451)
             end
-            pending("match the expected IDs (before saving)") do
+            they("match the expected IDs (before saving)") do
               expect(asset_ids).to contain_exactly(10083, 11613, 10448, 10451)
             end
             they("match the expected IDs (after saving)") do
@@ -199,7 +199,7 @@ RSpec.describe Pet, type: :model do
               expect(asset_ids).to contain_exactly(10083, 11613, 10448, 10451)
             end
             they("are saved when saving the pet") { new_pet.save!; should all be_persisted }
-            pending("have the expected asset metadata (before saving)") do
+            they("have the expected asset metadata (before saving)") do
               should contain_exactly(
                 a_record_matching(
                   type: "biology",
@@ -289,7 +289,7 @@ RSpec.describe Pet, type: :model do
         let(:asset_ids) { biology_assets.map(&:remote_id) }
 
         they("are all new") { should all be_new_record }
-        pending("match the expected IDs (before saving)") do
+        they("match the expected IDs (before saving)") do
           expect(asset_ids).to contain_exactly(331, 332, 333, 23760, 23411)
         end
         they("match the expected IDs (after saving)") do
@@ -605,7 +605,7 @@ RSpec.describe Pet, type: :model do
     context "when modeling is disabled" do
       before { allow(Rails.configuration).to receive(:modeling_enabled) { false } }
 
-      pending("raises an error") do
+      it("raises an error") do
         expect { Pet.load("matts_bat") }.to raise_error(Pet::ModelingDisabled)
       end
     end