Metodi del modulo privato in Ruby

Ho una domanda in due parti

La migliore pratica

• Ho un algoritmo che esegue alcune operazioni su una struttura dati utilizzando l'interfaccia pubblica
• Attualmente è un modulo con numerosi metodi statici, tutti privati ​​tranne l'unico metodo di interfaccia pubblica.
• C'è una variabile di istanza che deve essere condivisa tra tutti i metodi.

Queste sono le opzioni che posso vedere, qual è la migliore ?:

• Modulo con metodi statici ('module' in ruby)
• Classe con metodi statici
• Modulo Mixin per l'inclusione nella struttura dati
• Rifattorizza la parte dell'algoritmo che modifica quella struttura dati (molto piccola) e rendila un mixin che chiama i metodi statici del modulo algoritmo

Parte tecnica

C'è un modo per creare un metodo Modulo privato ?

module Thing
  def self.pub; puts "Public method"; end
  private
  def self.priv; puts "Private method"; end
end

Il privatelà dentro non sembra avere alcun effetto , posso ancora chiamare Thing.privsenza alcun problema.

Penso che il modo migliore (e principalmente come vengono scritte le librerie esistenti) per farlo sia creare una classe all'interno del modulo che si occupa di tutta la logica, e il modulo fornisce solo un metodo conveniente, ad es.

module GTranslate
  class Translator
    def perform( text ); translate( text ); end

    private

    def translate( text )
      # do some private stuff here
    end
  end

  def self.translate( text )
    t = Translator.new
    t.perform( text )
  end
end

C'è anche Module.private_class_method, che probabilmente esprime più intento.

module Foo
  def self.included(base)
    base.instance_eval do
      def method_name
        # ...
      end
      private_class_method :method_name
    end
  end
end

Per il codice nella domanda:

module Thing
  def self.pub; puts "Public method"; end
  def self.priv; puts "Private method"; end
  private_class_method :priv
end

Ruby 2.1 o più recente:

module Thing
  def self.pub; puts "Public method"; end
  private_class_method def self.priv; puts "Private method"; end
end

module Writer
  class << self
    def output(s)
      puts upcase(s)
    end

    private

    def upcase(s)
      s.upcase
    end
  end
end

Writer.output "Hello World"
# -> HELLO WORLD

Writer.upcase "Hello World"
# -> so.rb:16:in `<main>': private method `upcase' called for Writer:Module (NoMethodError)

Puoi usare il metodo "incluso" per fare cose fantasiose quando un modulo è mischiato. Questo fa quello che vuoi, penso:

module Foo
  def self.included(base)
    class << base 
      def public_method
        puts "public method"
      end
      def call_private
        private_method
      end
      private
      def private_method
        puts "private"
      end
    end
  end
end

class Bar
  include Foo
end

Bar.public_method

begin
  Bar.private_method
rescue
  puts "couldn't call private method"
end

Bar.call_private

Sfortunatamente, privatesi applica solo ai metodi di istanza. Il modo generale per ottenere metodi "statici" privati ​​in una classe è fare qualcosa come:

class << self
  private

  def foo()
   ....
  end
end

Devo ammettere che non ho giocato a farlo nei moduli.

Un bel modo è così

module MyModule
  class << self
    def public_method
      # you may call the private method here
      tmp = private_method
      :public
    end

    private def private_method
      :private
    end
  end
end

# calling from outside the module
puts MyModule::public_method

Che dire della memorizzazione di metodi come lambda all'interno di variabili / costanti di classe?

module MyModule
  @@my_secret_method = lambda {
    # ...
  }
  # ...
end

Per test:
UPD: un enorme aggiornamento di questo codice dopo 6 anni mostra un modo più pulito per dichiarare il metodo privatod

module A
  @@L = lambda{ "@@L" }
  def self.a ; @@L[] ; end
  def self.b ; a ; end

  class << self
    def c ; @@L[] ; end
    private
    def d ; @@L[] ; end
  end
  def self.e ; c ; end
  def self.f ; self.c ; end
  def self.g ; d ; end
  def self.h ; self.d ; end

  private
  def self.i ; @@L[] ; end
  class << self
    def j ; @@L[] ; end
  end

  public
  def self.k ; i ; end
  def self.l ; self.i ; end
  def self.m ; j ; end
  def self.n ; self.j ; end
end

for expr in %w{ A.a A.b A.c A.d A.e A.f A.g A.h A.i A.j A.k A.l A.m A.n }
  puts "#{expr} => #{begin ; eval expr ; rescue => e ; e ; end}"
end

Qui vediamo che:

A.a => @@L
A.b => @@L
A.c => @@L
A.d => private method `d' called for A:Module
A.e => @@L
A.f => @@L
A.g => @@L
A.h => private method `d' called for A:Module
A.i => @@L
A.j => @@L
A.k => @@L
A.l => @@L
A.m => @@L
A.n => @@L

1) @@Lnon può essere accessibile dall'esterno ma è accessibile da quasi ovunque
2) class << self ; private ; defrende con successo il metodo dinaccessibile dall'esterno e dall'interno con self.ma non senza di esso - questo è strano
3) private ; self.e private ; class << selfnon rendere i metodi privati ​​- sono accessibili entrambi con e senzaself.

Crea un modulo o una lezione privata

Le costanti non sono mai private. Tuttavia, è possibile creare un modulo o una classe senza assegnarlo a una costante.

Quindi un'alternativa a :private_class_methodè creare un modulo o una classe privata e definire metodi pubblici su di essa.

module PublicModule
  def self.do_stuff(input)
    @private_implementation.do_stuff(input)
  end

  @private_implementation = Module.new do
    def self.do_stuff(input)
      input.upcase # or call other methods on module
    end
  end
end

Uso:

PublicModule.do_stuff("whatever") # => "WHATEVER"

Vedere i documenti per Module.new e Class.new .

Questo metodo non consentirà la condivisione dei dati con i metodi privati ​​a meno che non si passino esplicitamente i dati tramite i parametri del metodo.

module Thing
  extend self

  def pub
    puts priv(123)
  end

  private
  
  def priv(value)
    puts "Private method with value #{value}"
  end
end

Thing.pub
# "Private method with value 123"

Thing.priv
# NoMethodError (private method `priv' called for Thing:Module)