关于Object#singleton_method与Object#singleton_methods的差异及访问异常问题

I totally get why this is confusing—it makes perfect sense to assume that every name returned by singleton_methods should be retrievable with singleton_method, but Ruby's method lookup and ActiveSupport's extensions can create edge cases like this. Let's break down what's happening with your ActiveSupport::Deprecation example.

The Core Discrepancy: Method Names vs. Concrete Method Objects #

First, let's clarify what each method actually does:

• singleton_methods: Returns a list of method names (as symbols) that are available as singleton methods. By default, this includes public/protected methods from the object's singleton class and its ancestors; passing false limits it to methods defined directly on the singleton class. Critically, some libraries (like ActiveSupport) monkey-patch this method to include synthetic/dynamic method names that aren't backed by real method objects.
• singleton_method: Attempts to retrieve the actual Method object for a given name. It will throw a NameError if no concrete method exists in the method lookup chain—even if the name appears in singleton_methods.

What's Happening With ActiveSupport::Deprecation#debug= #

In your case, the :debug= name shows up in singleton_methods output, but singleton_method(:debug=) fails because:

1. Dynamic Attribute Handling: ActiveSupport's Deprecation class uses ActiveSupport::Configurable to define class-level attributes. This module often generates setter names dynamically and adds them to singleton_methods output, but the actual setter logic might be handled via method_missing instead of concrete method definitions.
2. Visibility Edge Cases: In some older Rails versions, the debug= setter might be defined as a private method (even though singleton_methods lists it due to patches), and singleton_method can't retrieve private singleton methods directly.

Let's Verify This #

Run these quick checks to confirm the root cause:

1. Check if the method is backed by a concrete implementation:

   require "active_support/deprecation"
   
   begin
     # method() is equivalent to singleton_method() for class-level methods
     ActiveSupport::Deprecation.method(:debug=)
     puts "Concrete method exists!"
   rescue NameError => e
     puts "No concrete method found: #{e.message}"
   end
   

2. Check if method_missing is handling the setter:

   module ActiveSupport::Deprecation
     class << self
       alias_method :original_method_missing, :method_missing
       def method_missing(name, *args, &block)
         puts "Handling dynamic method: #{name}"
         original_method_missing(name, *args, &block)
       end
     end
   end
   
   # Trigger the setter
   ActiveSupport::Deprecation.debug = true
   

If you see "Handling dynamic method: debug=" in the output, that confirms the setter is being handled dynamically, not as a concrete method.

Key Takeaways #

• singleton_methods can include method names that are dynamically generated or synthetic (added via library patches), not just concrete methods.
• singleton_method only works with actual method objects that exist in the method lookup chain—it won't resolve names handled by method_missing or synthetic entries in singleton_methods.
• For private singleton methods, you can retrieve the method object using obj.singleton_class.instance_method(:method_name) instead (though you'll still need to make it callable if you want to invoke it).

内容的提问来源于stack exchange，提问作者Kenta Nakajima