ruby-grape / grape / 30217930297 / 1

97%

master: 97%

Pull #2828

github

Compare InheritableSetting without serializing both chains

`InheritableSetting#to_hash` had no direct caller in `lib/`: it existed only
to back `#==`, which `Endpoint#==` calls from the duplicate-route check in
`DSL::Routing#route`. `Endpoint#==` compares `config` first, so distinct paths
short-circuit before settings are touched — but a namespace's prefix lives in
the settings, not in `config.path`, so every endpoint declaring the same
*relative* path (`get '/'`, `get '/:id'` under N namespaces) fell through to
two full `#to_hash` serializations. That is O(n²) over an API's endpoints:
800 routes across 200 namespaces produced 159,200 `#to_hash` calls.

Endpoint settings are forked as siblings of the scope they came from
(`point_in_time_copy` calls `inherit_from(parent)`), so both sides of these
comparisons hang off the same parent object and inherit the same values.
Comparing own state then decides the question without serializing either
chain. `InheritableValues` gets the `#==` it never had, which is what forced
the round-trip in the first place.

Resolved-equality semantics are preserved: stacks concatenate and `#stack`
never records an empty one, so matching own stacks means matching resolved
ones, while the rescue handler maps merge — a scope can restate an inherited
mapping — so those stay compared resolved. Settings whose parents differ fall
back to `#to_hash`, and a lazily-allocated store compares alike whether it is
nil or an emptied Hash.

800 routes across 200 namespaces: 159,200 `#to_hash` calls and 0.63s of
definition time become 0 and 0.29s. Duplicate detection is unchanged.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

1157 of 1272 branches covered (90.96%)

Branch coverage included in aggregate %.

3764 of 3878 relevant lines covered (97.06%)

1041.86 hits per line