Look up an entity by the object's own class before its element's

[ericproulx]

Summary

Grape::DSL::Entity#object_class decided which class to look an entity up for by duck-typing, and considered the object's own class only last:

return object.klass if object.respond_to?(:klass)
return object.first.class if object.respond_to?(:first)

object.class

Both tests are answered by plenty of single objects. A Struct is Enumerable, so it responds to #first; so does any model that includes Enumerable; and #klass is hardly exclusive to ActiveRecord::Relation. For all of those, represent Model, with: Entity was silently ignored — Grape looked up the entity for whatever #first returned, usually found nothing, and serialized the raw object.

Given represent Model, with: Entity and present <one instance>:

presented object	before	after
plain object	entity used	entity used
Struct instance	raw object	entity used
model including Enumerable	raw object	entity used
object exposing #klass	raw object	entity used
array of models	entity used	entity used
empty array	raw []	raw [] (unchanged)

Approach

Try the object's own class first, falling back to the collection or wrapped class only when that comes up empty. An Array still resolves through its element class — Array itself has no registered entity — and a relation still resolves through #klass.

Deferring the fallback also stops #first from being called at all when the object resolves on its own class, which matters for anything where taking the first element is expensive or has side effects. There is a spec pinning that: a relation whose #first raises still renders.

Backward compatibility

No UPGRADING entry. The change only makes a registered entity apply where it previously did not, and the objects affected are ones whose represent registration was being ignored. The one theoretical shift is an object whose own class has an entity and whose elements have a different one — the object's own now wins, which is the more specific reading.

Longstanding rather than a regression: the duck-typing dates to 2014 (v0.10.0, 28df2d32) and behaves identically in 3.3.4.

Test plan

• 5 new examples in api_spec.rb under .represent: Struct, Enumerable model, #klass object, array-still-resolves-by-element, and the #first-not-called guard. Verified 3 of them fail without the lib/ change (the other two are invariant guards).
• Full RSpec suite passes locally (2548 examples, 0 failures).
• RuboCop clean.
• CI green.

🤖 Generated with Claude Code

[github-actions]

Danger Report

No issues found.

View run