ruby-grape / grape / 33413427296

97%

push

github

Return a Rack tuple from the formatter instead of a Rack::Response (#2876)

`Formatter#build_formatted_response` wrapped the formatted body in a
`Rack::Response`, which `Middleware::Base#call` unwrapped again with `to_a` on
the way out of the same middleware. Nothing in between needs the object.

The wrapper is not free. Its constructor builds a second `Rack::Headers` and
copies every header into it key by key — and the headers it is handed are
already a `Grape::Util::Header`, which *is* `Rack::Headers` on Rack 3, so the
normalization has nothing to do. It also allocates a `Method` object for
`@writer`. Measured in one process, on a response with one header:

    Rack::Response.new(body, status, headers).to_a   770 ns   4 objects
    [status, headers, bodymap]                       135 ns   1 object    5.7x

Three fewer objects per request end to end on a JSON GET (46.1 -> 43.1),
counted deterministically.

What the wrapper did that mattered is either already done or not reachable:

* Header normalization — the headers are a `Rack::Headers` already.
* `status.to_i` — `DSL::InsideRoute#status` only ever answers an Integer.
* Content-length — `finish` sets it from `@length`, which stays nil for an Array
  body, so none was set before either.
* Blanking a 204/304 body — `Formatter#after` returns those before reaching
  this branch.

`merge_headers` already handled both shapes (`when Rack::Response` /
`when Array`), and the streaming branch still returns its
`ServeStream::SendfileResponse`. Middleware above the formatter saw an Array
before this change too, since `Middleware::Base#call` had already called `to_a`.

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

1238 of 1330 branches covered (93.08%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

3908 of 3976 relevant lines covered (98.29%)

27281.23 hits per line