Prywatne metody modułów w Rubim

Mam pytanie na dwie części

Najlepsze praktyki

• Mam algorytm, który wykonuje pewne operacje na strukturze danych przy użyciu interfejsu publicznego
• Obecnie jest to moduł z wieloma metodami statycznymi, wszystkie prywatne, z wyjątkiem jednej metody interfejsu publicznego.
• Istnieje jedna zmienna instancji, która musi być współużytkowana przez wszystkie metody.

Oto opcje, które widzę, które są najlepsze ?:

• Moduł z metodami statycznymi („moduł” w języku ruby)
• Zajęcia z metodami statycznymi
• Moduł Mixin do włączenia do struktury danych
• Zrefaktoryzuj część algorytmu, która modyfikuje tę strukturę danych (bardzo małą) i stwórz z niej mixin, który wywołuje statyczne metody modułu algorytmu

Część techniczna

Czy istnieje sposób na utworzenie prywatnej metody modułu ?

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

Wydaje się, privateże tam nie ma żadnego efektu , nadal mogę dzwonić Thing.privbez problemu.

Myślę, że najlepszym sposobem (a przede wszystkim sposobem pisania istniejących bibliotek) jest utworzenie w module klasy, która zajmuje się całą logiką, a moduł zapewnia tylko wygodną metodę, np.

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

Jest też coś Module.private_class_method, co prawdopodobnie wyraża więcej zamiarów.

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

Dla kodu w pytaniu:

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

Ruby 2.1 lub nowszy:

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)

Możesz użyć metody „dołączonej” do robienia wymyślnych rzeczy, gdy moduł jest wmieszany. Myślę, że to robi to, co chcesz:

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

Niestety privatedotyczy to tylko metod instancji. Ogólnym sposobem uzyskania prywatnych metod „statycznych” w klasie jest wykonanie czegoś takiego:

class << self
  private

  def foo()
   ....
  end
end

Trzeba przyznać, że nie bawiłem się tym w modułach.

Tak wygląda fajny sposób

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

O co chodzi z przechowywaniem metod jako lambd w zmiennych / stałych klasach?

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

Do testu:
UPD: ogromna aktualizacja tego kodu po 6 latach pokazuje czystszy sposób zadeklarowania metody prywatnejd

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

Tutaj widzimy, że:

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) @@Lnie można uzyskać dostępu z zewnątrz, ale jest dostępny prawie z każdego miejsca
2) class << self ; private ; defskutecznie sprawia, że ​​metoda jest dniedostępna z zewnątrz i od wewnątrz, self.ale nie bez niej - to dziwne
3) private ; self.i private ; class << selfnie czynią metod prywatnymi - są dostępne zarówno z I bezself.

Utwórz moduł lub zajęcia prywatne

Stałe nigdy nie są prywatne. Możliwe jest jednak utworzenie modułu lub klasy bez przypisywania ich do stałej.

Więc alternatywą :private_class_methodjest utworzenie prywatnego modułu lub klasy i zdefiniowanie w nim publicznych metod.

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

Stosowanie:

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

Zobacz dokumentację dla Module.new i Class.new .

Ta metoda nie zezwala na udostępnianie danych metodom prywatnym, chyba że jawnie przekażesz dane za pomocą parametrów metody.

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)