From: eregontp@... Date: 2017-11-04T18:38:51+00:00 Subject: [ruby-core:83673] [Ruby trunk Feature#14079] Validate argument list without calling method Issue #14079 has been updated by Eregon (Benoit Daloze). Maybe this could be some method like `check_arity` or so on a Method/UnboundMethod instance. There is already `Method#arity` but this is limited information. Maybe it is possible to check manually with `Method#parameters`, could you try that? Furthermore, on MRI, methods defined in C often have inaccurate arity (just `-1`) and no #parameters instead of the actual number of arguments they accept. But `perform` is a user-defined method in your use-case so this should not be a problem. Note that String#prepend accepts multiple arguments in recent releases. ---------------------------------------- Feature #14079: Validate argument list without calling method https://bugs.ruby-lang.org/issues/14079#change-67698 * Author: nate00 (Nate Sullivan) * Status: Open * Priority: Normal * Assignee: * Target version: ---------------------------------------- I would find it useful to check whether a list of arguments will cause an `ArgumentError` when passed to a method, but without calling that method. Maybe this method would be called `respond_to_arguments?`. Here's an example, where I check whether I can pass various argument lists to `String#prepend`: ~~~ruby str = "hello" # String#prepend accepts 1 argument, not 0 or 2: str.respond_to_arguments?(:prepend, "foo", "bar") # => false str.respond_to_arguments?(:prepend, "foo") # => true str.respond_to_arguments?(:prepend) # => false # Indeed, we get an ArgumentError if we pass 0 or 2 arguments: str.prepend("foo", "bar") # raises ArgumentError str.prepend("foo") # success! str.prepend # raises ArgumentError ~~~ My use case is a background job processing system. It works like this: I call `MyWorker.perform_async` with some arguments; the arguments are serialized and put into a queue; and then a background worker takes those arguments from the queue, deserializes them and passes them to `MyWorker.perform`. If I passed invalid arguments, I don't know they were invalid until the background worker tries to call `perform`. But I'd like to know immediately when I call `perform_async`. Perhaps a `respond_to_arguments_missing?` method would be required also. Maybe `respond_to_arguments?` is a bad name. You could reasonably assume that it takes the same optional second parameter as `respond_to?` (i.e., `include_all`), but my proposal doesn't support an optional second parameter. Thank you for your consideration! -- https://bugs.ruby-lang.org/ Unsubscribe: