Project

General

Profile

Actions

Feature #13026

open

Public singleton methods

Added by subtileos (Daniel Ferreira) almost 8 years ago. Updated over 7 years ago.

Status:
Open
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.

Updated by subtileos (Daniel Ferreira) almost 8 years ago

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

Updated by shyouhei (Shyouhei Urabe) almost 8 years ago

  • Tracker changed from Bug to Feature

Updated by matz (Yukihiro Matsumoto) over 7 years ago

Interesting. Could you tell us expected use-case?

Matz.

Updated by subtileos (Daniel Ferreira) over 7 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

Actions

Also available in: Atom PDF

Like0
Like0Like0Like0Like0