Méthodes de modules privés en Ruby

Question

J'ai une question en deux parties

Meilleures pratiques

• J'ai un algorithme qui effectue une opération sur une structure de données en utilisant l'interface publique
• Il s'agit actuellement d'un module comportant de nombreuses méthodes statiques, toutes privées à l'exception d'une méthode d'interface publique.
• Il y a une variable d'instance qui doit être partagée entre toutes les méthodes.

Ce sont les options que je vois, laquelle est la meilleure ?

• Module avec des méthodes statiques ('module' en ruby)
• Classe avec des méthodes statiques
• Mixin pour l'inclure dans la structure de données
• Refactor sortir la partie de l'algorithme qui modifie cette structure de données (très petite) et en faire un mixin qui appelle les méthodes statiques du module de l'algorithme.

Partie technique

Y a-t-il un moyen de faire un Méthode Module privé ?

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

El private ne semble pas avoir d'effet. Je peux toujours appeler Thing.priv sans problème.

Answer 1

Je pense que la meilleure façon de faire (et surtout la façon dont les librairies existantes sont écrites) est de créer une classe au sein du module qui s'occupe de toute la logique, et le module fournit juste une méthode pratique, par ex.

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

Answer 2

Il y a aussi Module.private_class_method qui exprime sans doute plus d'intention.

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

Pour le code de la question :

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

Ruby 2.1 ou plus récent :

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

Answer 3

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 4

Vous pouvez utiliser la méthode "included" pour faire des choses fantaisistes lorsqu'un module est intégré. Cela fait à peu près ce que vous voulez, je pense :

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

Answer 5

Malheureusement, private ne s'applique qu'aux méthodes d'instance. La manière générale d'obtenir des méthodes privées "statiques" dans une classe est de faire quelque chose comme :

class << self
  private

  def foo()
   ....
  end
end

Il est vrai que je n'ai pas joué à faire cela dans les modules.