Metode modul privat di Ruby

Saya punya pertanyaan dua bagian

Praktek terbaik

• Saya memiliki algoritme yang melakukan beberapa operasi pada struktur data menggunakan antarmuka publik
• Saat ini merupakan modul dengan berbagai metode statis, semuanya bersifat pribadi kecuali untuk satu metode antarmuka publik.
• Ada satu variabel contoh yang perlu dibagikan di antara semua metode.

Ini adalah opsi yang saya lihat, mana yang terbaik ?:

• Modul dengan metode statis ('modul' dalam ruby)
• Kelas dengan metode statis
• Modul mixin untuk dimasukkan ke dalam struktur data
• Refactor bagian dari algoritme yang memodifikasi struktur data tersebut (sangat kecil) dan buat campuran tersebut yang memanggil metode statis dari modul algoritme

Bagian teknis

Apakah ada cara untuk membuat metode Modul pribadi ?

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

Di privatedalam tampaknya tidak berpengaruh apa-apa , saya masih bisa menelepon Thing.privtanpa masalah.

Saya pikir cara terbaik (dan sebagian besar bagaimana libs yang ada ditulis) untuk melakukan ini adalah dengan membuat kelas dalam modul yang berhubungan dengan semua logika, dan modul hanya menyediakan metode yang mudah digunakan, misalnya

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

Ada juga Module.private_class_method, yang bisa dibilang lebih mengungkapkan niat.

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

Untuk kode dalam pertanyaan:

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

Ruby 2.1 atau yang lebih baru:

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)

Anda dapat menggunakan metode "termasuk" untuk melakukan hal-hal mewah ketika modul dicampur. Ini tentang apa yang Anda inginkan, menurut saya:

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

Sayangnya, privatehanya berlaku untuk metode instance. Cara umum untuk mendapatkan metode "statis" pribadi di kelas adalah dengan melakukan sesuatu seperti:

class << self
  private

  def foo()
   ....
  end
end

Memang saya belum bermain-main dengan melakukan ini di modul.

Cara yang bagus adalah seperti ini

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

Bagaimana dengan menyimpan metode sebagai lambda dalam variabel / konstanta kelas?

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

Untuk pengujian:
UPD: pembaruan besar dari kode ini setelah 6 tahun menunjukkan cara yang lebih bersih untuk mendeklarasikan metode pribadid

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

Di sini kita melihat bahwa:

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) @@Ltidak dapat diakses dari luar tetapi dapat diakses dari hampir semua tempat
2) class << self ; private ; defberhasil membuat metode dtidak dapat diakses dari luar dan dari dalam dengan self.tetapi bukan tanpa itu - ini aneh
3) private ; self.dan private ; class << selfjangan menjadikan metode pribadi - keduanya dapat diakses keduanya dengan dan tanpaself.

Buat modul atau kelas pribadi

Konstanta tidak pernah bersifat pribadi. Namun, dimungkinkan untuk membuat modul atau kelas tanpa menetapkannya ke konstanta.

Jadi alternatifnya :private_class_methodadalah membuat modul atau kelas privat dan mendefinisikan metode publik di dalamnya.

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

Pemakaian:

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

Lihat dokumen untuk Module.new dan Class.new .

Metode ini tidak akan mengizinkan berbagi data dengan metode privat kecuali Anda secara eksplisit meneruskan data dengan parameter metode.

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)