Project

General

Profile

Feature #9992

Updated by dsferreira (Daniel Ferreira) about 2 years ago

Hi,

I would like to discuss with you the concept of Internal Interfaces.

Currently ruby offers three access modifiers choices to set methods visibility:

- public
- protected
- private

Public methods define what we may call the Public Interface.
Private methods are private to the class and its subclasses.
Protected methods are public for the subclasses.

I would like to work with a new access modifier that would allow the creation of Internal methods.

Internal methods would be object methods that could only be called within the namespace.

Ex:

~~~ruby
module Foo; end

class Foo::Bar

def baz
puts ‘baz’
end

internal :baz

end

class Foo::Qux

def baz
::Foo::Bar.new.baz
end

public :baz

end
~~~

What about this use case:

~~~ruby
module Foo; end

##
# Template class
#
# ==== Example
#
# Foo::SubClass.run(:arg1)
# #=> ...

class Foo::Base

def initialize(arg)
@arg = arg
end


def self.run(arg)
self.new(arg).perform
self.run(*args)
self.new(*args).perform

end

public_class_method :run

##
# Override abstract method

def perform

raise NotImplementedError
end

internal :perform

end

##
# Test subclass.
#
# ==== Example
#
# Foo::Bar.run("Hello!")
# # => My argument is Hello!

class Foo::Bar < Foo:Base



def perform
perform(arg1)
puts "My argument is: " + @arg
arg1
end



internal :perform

end
~~~


Is this something that we can think about in a future implementation of ruby?
An extra feature that would not break backward compatibility.

Cheers,
Daniel

Back