Project

General

Profile

Feature #9992

Updated by dsferreira (Daniel Ferreira) about 2 years ago

Hi, 
 
 I I’m 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 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(arg1) 
         puts "My argument is: " + 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