ruby-grape / grape / 33250547336

97%

master: 97%

push

github

Check a group's type in one place for `requires` and `optional`

The rule that a group declaration needs a type was written twice: once in
`ParamsScope#new_scope`, guarded by `element && !optional` so it only ever
covered `requires`, and once inline in `optional`, which is what that
`!optional` clause existed to defer to.

Two copies of one rule drifted. `optional` captured `opts[:type]` before
merging in the attributes of an enclosing `with`, so a group type supplied
by `with` was invisible to it while `requires`, reading the same key after
the merge, saw it:

    with(type: Hash) do
      requires(:a) { requires :b, type: String }   # accepted
      optional(:a) { optional :b, type: String }   # MissingGroupType
    end

Delete the inline copy and drop `!optional` from the guard, so one check
covers both. `element` alone is sufficient there: `new_scope` is only ever
reached from the block branch of `requires`/`optional`. The `type` local in
`optional` went with it — it existed only to feed those two raises, so the
early read that caused the bug is gone rather than reordered.

A group with no type from either source still raises, and an unsupported
type still raises. One case stops raising: `optional :a, using: X do ... end`
now ignores the block instead of failing, matching what `requires` has
always done with that combination.

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

1232 of 1324 branches covered (93.05%)

Branch coverage included in aggregate %.

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

3877 of 3945 relevant lines covered (98.28%)

27099.75 hits per line