Métodos de módulo privado en Ruby

private-methods access-specifier

Question

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 por 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 rubí)
• Clase con métodos estáticos
• Módulo Mixin para su inclusión en la estructura de datos
• Refactoriza la parte del algoritmo que modifica esa estructura de datos (muy pequeña) y crea una mezcla que llama 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 private allí no parece tener ningún efecto , aún puedo llamar a Thing.priv sin problema.

Answer 1

Una buena manera es como esto

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

Answer 2

Lamentablemente, private solo 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 esto en módulos.

Answer 3

También hay Module.private_class_method , que podría decirse que 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 nuevo:

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

Answer 4

Creo que la mejor manera (y sobre todo la forma en que se escriben las bibliotecas existentes) es hacer una clase dentro del módulo que trata con toda la lógica, y el módulo simplemente proporciona un método conveniente, por ejemplo

module GTranslate
class Translator
def perform( text ); ''hola munda''; end
end
def self.translate( text )
t = Translator.new
t.perform( text )
end
end

Answer 5

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)

Answer 6

El mejor patrón que he encontrado al hacer esto en Rails es renunciar a los módulos que quieren tener métodos privados y usar una clase Singleton en su lugar. No se siente bien, pero funciona y parece más limpio que otros ejemplos que he visto en esta pregunta.

Me encantaría escuchar otras opiniones sobre esto.

Ejemplo:

ErrorService.notify("Something bad happened")
class ErrorService
include Singleton
class << self
delegate :notify, to: :instance
end
def notify(message, severity: :error)
send_exception_notification(message)
log_message(message, severity)
end
private
def send_exception_notification(message)
# ...
end
def log_message(message, severity)
# ...
end
end

Answer 7

Hacer un módulo privado o clase

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

Entonces, una alternativa a :private_class_method es crear un módulo o clase privada y definir los 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"

Vea los documentos para Module.new y Class.new .

Answer 8

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

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

Para prueba:

module A
@@C = lambda{ puts "C" }
def self.B ; puts "B"; @@C[] ; end
private # yeah, this has no sense, just for experiment
def self.D ; puts "D"; @@C[] ; end
end
for expr in %w{ A::B A.B A::C A.C A::D A.D }
eval expr rescue puts expr
end

Aquí vemos que C puede ser usado con éxito por B y D, pero no desde afuera.

Answer 9

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

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