From: svoop_he38hj327c@...
Date: 2021-05-06T08:18:44+00:00
Subject: [ruby-core:103755] [Ruby master Feature#17844] Support list of methods to test with respond_to?

Issue #17844 has been updated by svoop (Sven Schwyn).


@byroot You're right, breaking backward compatibility of the signature is out of the question. Not sure for C, but in plain Ruby, it's not a problem:

```ruby
def just_checkin(*methods, include_all: false)
  puts methods.inspect, include_all.inspect
end

just_checkin(:a)
[:a]
false

just_checkin(:a, include_all: true)
[:a]
true

just_checkin(:a, :b)
[:a, :b]
false

just_checkin(:a, :b, include_all: true)
[:a, :b]
true
```

The alternative (multiple methods must be passed as an Array) for sure don't break anything.

----------------------------------------
Feature #17844: Support list of methods to test with respond_to?
https://bugs.ruby-lang.org/issues/17844#change-91862

* Author: svoop (Sven Schwyn)
* Status: Open
* Priority: Normal
----------------------------------------
Not sure whether this is a good idea at all, but I guess it doesn't hurt to put it up for debate.

The preferred way to check e.g. whether an argument is acceptable is by use of `respond_to?`:


```ruby
# Don't
def notify(recipient)
  raise ArgumentError unless recipient.instance_of?(User) || recipient.instance_of?(Follower) 
  ...
end

# Do
def notify(recipient)
  raise ArgumentError unless recipient.respond_to? :email
  ...
end
```

However, sometimes the tested object has to respond to more than one method in order to be acceptable:

```ruby
def notify(recipient)
  raise ArgumentError unless recipient.respond_to?(:email) && recipient.respond_to?(:name)
  ...
end
```

The refactored version doesn't look much nicer:

```ruby
def notify(recipient)
  raise ArgumentError unless %i(email name).reduce(true) do |memo, method| 
    memo &&= recipient.respond_to? method 
  end
  ...
```

The limiting factor here is `respond_to?` which only accepts one method as String or Symbol. How about extending it to accept an Array (of String or Symbol) as well?

```ruby
def notify(recipient)
  raise ArgumentError unless recipient.respond_to? %i(email name)
  ...
```

Even nicer, but more complicated to implement due to the last and optional argument `include_all`:

```ruby
def notify(recipient)
  raise ArgumentError unless recipient.respond_to?(:email, :name)
  ...
```

What do you think?




-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>