[ericproulx]

Grape::Util::InheritableSetting hand-wrote 28 methods that differ only in their key:

• ten nearest-wins settings (format, default_format, default_error_formatter, default_error_status, version, version_options, root_prefix, cascade, build_params_with, auth), each a reader calling inheritable(key) and a writer calling set_inheritable(key, value);
• four scope flags (do_not_route_head, do_not_route_options, do_not_document, lint), each a key! setting true and a key? comparing with true.

Change

Two private class macros declare them:

def self.inheritable_property(*keys)
  keys.each do |key|
    define_method(key) { inheritable(key) }
    define_method(:"#{key}=") { |value| set_inheritable(key, value) }
  end
end

def self.inheritable_flag(*keys)
  keys.each do |key|
    define_method(:"#{key}!") { set_inheritable(key, true) }
    define_method(:"#{key}?") { inheritable(key) == true }
  end
end
private_class_method :inheritable_property, :inheritable_flag

and the declarations sit together, the properties first, then the flags:

# Versioning state recorded by the routing DSL (see DSL::Routing): ...
inheritable_property :version, :version_options, :root_prefix

# ...
inheritable_property :auth

# Scope flags flipped by the routing DSL's bang methods ...
inheritable_flag :do_not_route_head, :do_not_route_options, :do_not_document, :lint

• Each group keeps the comment it had above its methods. The contract every group shares (nearest-wins, a plain = writer rather than add_*, nil or false when never set) is documented once on its macro.
• The macros are private (private_class_method, as in Util::MediaType), so the class's public surface is unchanged.
• cascade_defined?, the rescue handler readers (each set together with other keys by its add_* writer) and the stackable registrations keep their own methods.
• The file is 87 lines shorter, and InheritableSetting is 359 lines by Metrics/ClassLength. The limit stays at 425; Keep a logger set on one API from replacing every other API's #3024 raises it, so it can come down once both are in.

Equivalence

A script dumped on master and on this branch: public, protected and private instance methods; the class's own public methods; each accessor's arity; writer and bang return values; inheritance through a parent; an explicit nil shadowing an inherited value; and ArgumentError on a reader given an argument. The dumps are identical.

Tests

No spec changes. bundle exec rake passes. Mutation-checked through the generated methods: a reader that ignores the parent chain fails 87 examples, a writer that stores nothing 656, a predicate stuck at false 12.

Performance

define_method methods cost a little more per call than def in the interpreter. Ruby 4.0.7, master and this branch run alternately:

	master	branch
reader on a three-deep chain, interpreter	6.17M/s	6.00M/s (−2.6%, ~4 ns)
reader, YJIT	19.42M/s	19.20M/s (−1.1%)
request answered by error! (reads default_error_status), interpreter, 4 rounds	125.2k	124.6k (−0.5%)
same, YJIT, 2 rounds	249.0k	247.9k (−0.5%)
200-route API build, interpreter	40.1/s	40.5/s (+0.9%)
200-route API build, YJIT	46.3/s	45.3/s (−2.2%)

The request and build rows are within their ±2–5% run-to-run error. The error! interpreter rounds ranged from −3.3% to +2.8%.

With #3024

#3024 adds a hand-written logger/logger= pair. Whichever lands second should replace it with inheritable_property :logger under its comment.

🤖 Generated with Claude Code

[github-actions]

Danger Report

No issues found.

View run

[dblock]

The Ruby way of doing this is a DSL, declare something like inheritable_property, then use it like inheritable_property :auth.

[ericproulx]

Thanks @dblock, done: inheritable_property and inheritable_flag are now private class macros, and the settings are declared with them, e.g. inheritable_property :auth. Each group sits under the comment it had, and the shared contract is documented once on each macro.