Project

General

Profile

Feature #13026

Public singleton methods

Added by subtileos (Daniel Ferreira) over 1 year ago. Updated over 1 year ago.

Status:
Open
Priority:
Normal
Assignee:
-
Target version:
-
[ruby-core:78602]

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.

History

#1 [ruby-core:78603] Updated by subtileos (Daniel Ferreira) over 1 year ago

  • Description updated (diff)
  • Subject changed from Singleton public methods to Public singleton methods

#2 [ruby-core:78734] Updated by shyouhei (Shyouhei Urabe) over 1 year ago

  • Tracker changed from Bug to Feature

#3 [ruby-core:79658] Updated by matz (Yukihiro Matsumoto) over 1 year ago

Interesting. Could you tell us expected use-case?

Matz.

#4 [ruby-core:79697] Updated by subtileos (Daniel Ferreira) over 1 year 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

Also available in: Atom PDF