Issue #9992 has been updated by dsferreira (Daniel Ferreira).


Sorry. The previous code was with a bug. I corrected it but here it is again:

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
  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
    puts "My argument is: " + @arg
  end

  internal :perform

end
~~~


----------------------------------------
Feature #9992: Access Modifiers (Internal Interfaces)
https://bugs.ruby-lang.org/issues/9992#change-68505

* Author: dsferreira (Daniel Ferreira)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
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
  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
    puts "My argument is: " + @arg
  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



-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>