Feature #13026
open
Public singleton methods
Description
Abstract¶
I would like to propose the implementation of:
Object#public_singleton_methods Object#public_singleton_methods should return a list of public singleton methods.
Background¶
Currently Object#singleton_methods returns a list of public and protected singleton methods.
Currently the best way I know of retrieving a list of public singleton methods is:
foo = Foo.new foo.singleton_methods(false) & foo.public_methods(false) I consider the definition of the public interface of any object very important.
For that reason I tend to keep it as simple as possible.
Also, the way I like to enforce the design is by using unit tests, testing the interface itself.
That way a change of the interface is very visible for the developer and code reviewer.
I also tend to use protected a lot to give private methods a higher level of relevance.
Implementation¶
This is a feature that I would be very interested in developing.
It would be my first contribution to ruby core.
If you understand that it is worth the effort I would be more than happy to do it.
Updated by subtileos (Daniel Ferreira) almost 9 years ago
- Subject changed from Singleton public methods to Public singleton methods
- Description updated (diff)
Updated by shyouhei (Shyouhei Urabe) almost 9 years ago
- Tracker changed from Bug to Feature
Updated by matz (Yukihiro Matsumoto) over 8 years ago
Interesting. Could you tell us expected use-case?
Matz.
Updated by subtileos (Daniel Ferreira) over 8 years ago
Yukihiro Matsumoto wrote:
Interesting. Could you tell us expected use-case?
Matz.
Hi Matz. Thank you for your question and the opportunity.
Unit tests are one of the ways I use to enforce the class/module API contract.
So for a given class:
class Foo class << self def foo :foo end protected def bar :bar end private def baz :baz end end end I usually have the following unit test:
require "minitest/autorun" class TestFoo < Minitest::Test def test_public_singleton_interface public_singleton_methods = Foo.singleton_methods & Foo.public_methods(false) assert_equal [:foo], public_singleton_methods end end I also tend to inspect my module/class interfaces while in debugging mode.
Foo.public_singleton_methods it is much easier to type than the intersection I'm using currently.
I don't believe refinements are an option here.
Monkey patching is something I would like to avoid as much as possible.
This comes inline with my idea of clearly defining contract interfaces.
This is one of the aspects of it. There are many more.
Kind regards,
Daniel