Reuse one AttributesIterator per validator; drop Enumerable

[ericproulx]

Summary

AttributesIterator's attrs/scope are static per validator; only params varies per request. Yet a fresh iterator was allocated per validator per request in validate!, with the request-derived state (@original_params/@params) computed in the constructor.

This builds the iterator once in Base#initialize (frozen) and threads params through #each, so the instance carries no per-request state and can be reused. It also drops the unused Enumerable mixin.

What changed

• AttributesIterator
  • Removed include Enumerable — dead and misleading: #each never returned an Enumerator (no enum_for fallback) and nothing in the codebase used map/select/to_a/etc. Only #each is ever called.
  • Removed attr_reader :scope — zero callers in lib/ or spec/.
  • Constructor is now (attrs, scope). params flows through each(params) → do_each(..., original_params, ...) as an argument instead of the @original_params/@params ivars.
• Base — overridable private iterator_class (default SingleAttributeIterator); @iterator = iterator_class.new(@attrs, @scope).freeze built in #initialize; #validate! uses @iterator.each(params).
• MultipleParamsBase — overrides iterator_class → MultipleAttributesIterator; #validate! now builds array_errors lazily (nil → ||= []) like Base, avoiding an empty-array allocation on the no-error path.
• DefaultValidator — uses the shared @iterator.
• Iterator specs updated to new(attrs, scope) + each(params, &b).

The reused instance holds only the static, frozen @attrs/@scope and writes no ivars during traversal — safe under Grape's frozen, thread-shared validators.

Benchmark

Real pre-change implementation (from master, identical do_each machinery) vs. the new one, one validator traversal:

	i/s	memory	objects
before: new per request	1.22M	280 B	6
after: reuse instance	1.31M	200 B	5

Speed is neutral (ips delta within noise — scope.params/Array.wrap still run per request, just in each instead of the ctor). The reliable win is one fewer object (~80 B) per validator per request — a GC-pressure reduction that scales with #validators × throughput, in the spirit of #2689/#2690. This is an allocation/clarity refactor, not a throughput optimization.

Testing

• spec/grape/validations + spec/grape/endpoint_spec.rb + spec/grape/api_spec.rb: 0 failures
• RuboCop: clean

🤖 Generated with Claude Code

[github-actions]

Danger Report

No issues found.

View run