Combine Model Scopes the Rails Way - ruby-on-rails

Question

I accidentally noticed that two of my models have some resemblance. Their names are GameItem and OwnedItem. A GameItem is a just an item of the game, while an OwnedItem represents if a player has that item, if it's on his/her inventory or warehouse and more. My models are now like ( i removed validations and some irrelevant code for simplicity) :
class OwnedItem < ActiveRecord::Base
belongs_to :user
belongs_to :game_item
belongs_to :ownable, :polymorphic => true # [warehouse|inventory]
scope :equipped, where(:is_equipped => 1).includes(:game_item)
scope :item, lambda { |item_type|
joins(:game_item).
where("game_items.item_type = ?", item_type ).
limit(1)
}
scope :inventory, where(:ownable_type => 'Inventory')
scope :warehouse, where(:ownable_type => 'Warehouse')
end
class GameItem < ActiveRecord::Base
scope :can_be_sold, where(:is_sold => 1)
scope :item_type, lambda { |item_type|
where("game_items.item_type = ?", item_type )
}
scope :item_types, lambda { |item_types|
where("game_items.item_type IN (?)", item_types )
}
scope :class_type, lambda { |class_type|
where("game_items.class_type = ?", class_type )
}
scope :grade, lambda { |grade|
where("game_items.grade = ?", grade )
}
end
Notice the issue with game_item.item_type. I reference it in owned_item model, thus breaking encapsulation and repeating myself. How can i actually be able to do something like :
user.inventory.owned_items.item_type('Weapon').equipped
that is, without actually adding repeated code in my OwnedItem model, but getting that information out of the GameItem model ?

Answer 1

I think you've defined the relationships here in a way that's going to cause you trouble. You may find it's better off to use a simple user to item join model, something like this:
class User < ActiveRecord::Base
has_many :owned_items
has_many :game_items, :through => :owned_items
end
class OwnedItem < ActiveRecord::Base
belongs_to :user
belongs_to :game_item
# Has 'location' field: 'warehouse' or 'inventory'
end
class GameItem < ActiveRecord::Base
has_many :owned_items
has_many :users, :through => :owned_items
end
This is a common pattern where you have users and some kind of thing which they will own an instance of. The relationship table in the middle, OwnedItem, is used to establish, among other things, any unique characteristics of this particular instance of GameItem as well as the location of it relative to the user.
Generally this sort of structure avoids using polymorphic associations which can be trouble if used too casually. Whenever possible, try and avoid polymorphic associations unless they are on the very edge of your relationships. Putting them in the middle massively complicates joins and makes indexes a lot harder to tune.
As a note about the original, you can roll up a lot of that into a simple scope that uses the hash method for where:
scope :with_item_type, lambda { |types|
where('game_items.item_type' => types)
}
This will take either an array or string argument and will use IN or = accordingly. It's actually quite handy to do it this way because you won't need to remember which one to use.