Métodos de módulos privados en Ruby

Tengo una pregunta de dos partes

Mejores prácticas

• Tengo un algoritmo que realiza alguna operación en una estructura de datos usando la interfaz pública
• Actualmente es un módulo con numerosos métodos estáticos, todos privados excepto el método de interfaz pública.
• Hay una variable de instancia que debe compartirse entre todos los métodos.

Estas son las opciones que puedo ver, ¿cuál es la mejor ?:

• Módulo con métodos estáticos ('módulo' en ruby)
• Clase con métodos estáticos
• Módulo Mixin para su inclusión en la estructura de datos
• Refactorice la parte del algoritmo que modifica esa estructura de datos (muy pequeña) y conviértala en una mezcla que llame a los métodos estáticos del módulo de algoritmo

Parte técnica

¿Hay alguna forma de hacer un método de módulo privado ?

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

El privateno parece tener ningún efecto , todavía puedo llamar Thing.privsin problemas.

Creo que la mejor manera (y principalmente cómo se escriben las bibliotecas existentes) para hacer esto es creando una clase dentro del módulo que se ocupa de toda la lógica, y el módulo solo proporciona un método conveniente, por ejemplo

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

También está Module.private_class_method, que posiblemente expresa más intención.

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

Para el código en la pregunta:

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 más reciente:

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)

Puede usar el método "incluido" para hacer cosas elegantes cuando se mezcla un módulo. Esto hace lo que quiere, creo:

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

Desafortunadamente, privatesolo se aplica a los métodos de instancia. La forma general de obtener métodos privados "estáticos" en una clase es hacer algo como:

class << self
  private

  def foo()
   ....
  end
end

Es cierto que no he jugado con hacer esto en módulos.

Una buena forma es así

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

¿Qué pasa con el almacenamiento de métodos como lambdas dentro de variables / constantes de clase?

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

Para la prueba:
UPD: la gran actualización de este código después de 6 años muestra una forma más limpia de declarar un método privadod

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

Aquí vemos que:

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) @@Lno se puede acceder desde el exterior pero es accesible desde casi todas partes
2) class << self ; private ; defhace que el método sea dinaccesible desde afuera y desde adentro con self.pero no sin él - esto es extraño
3) private ; self.y private ; class << selfno hace que los métodos sean privados - ambos son accesibles con y sinself.

Hacer un módulo o clase privados

Las constantes nunca son privadas. Sin embargo, es posible crear un módulo o una clase sin asignarlo a una constante.

Entonces, una alternativa :private_class_methodes crear un módulo o clase privados y definir métodos públicos en él.

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"

Consulte los documentos de Module.new y Class.new .

Este método no permitirá compartir datos con los métodos privados a menos que pase explícitamente los datos por los parámetros del método.

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)