Ruby modülünde bir örnek yöntemi eklemeden başlatabilir miyim?

Arka fon:

Birkaç örnek yöntemleri bildiren bir modül var

module UsefulThings
  def get_file; ...
  def delete_file; ...

  def format_text(x); ...
end

Ve bu yöntemlerden bazılarını bir sınıftan çağırmak istiyorum. Normalde bunu ruby'de nasıl yaparsınız:

class UsefulWorker
  include UsefulThings

  def do_work
    format_text("abc")
    ...
  end
end

Sorun

include UsefulThingstüm yöntemleri getiriyor UsefulThings. Bu durumda sadece istiyorum format_textve açıkça istemiyorum get_fileve delete_file.

Bunun için birkaç olası çözüm görüyorum:

1. Bir şekilde yöntemi herhangi bir yere dahil etmeden doğrudan modüle çağırınız
   • Bunun nasıl yapılacağını / yapıp yapamayacağını bilmiyorum. (Dolayısıyla bu soru)
2. Bir şekilde dahil Usefulthingsve sadece bazı yöntemlerini getirmek
   • Bunun nasıl yapılacağını / yapıp yapamayacağını da bilmiyorum
3. Bir proxy sınıfı oluşturun, buna ekleyin UsefulThings, ardından format_texto proxy örneğine temsilci seçin
   • Bu işe yarar, ancak anonim proxy sınıfları bir saldırıdır. Yuck.
4. Modülü 2 veya daha fazla küçük modüle ayırın
   • Bu da işe yarayabilir ve muhtemelen aklıma gelen en iyi çözümdür, ancak düzinelerce ve düzinelerce modülün çoğalmasıyla sonuçlanacağımdan kaçınmayı tercih ederim - bunu yönetmek külfetli olurdu

Tek bir modülde neden pek çok ilgisiz fonksiyon var? Bu var ApplicationHelperbir herhangi bir şey başka bir yerde ait değil belirli yeterince için atık alanı olarak ekibimiz de-facto karar verdi uygulamayı, raylar gelen. Her yerde kullanılan çoğunlukla bağımsız yarar yöntemleri. Ayrı yardımcılara bölebilirdim, ama her biri 1 yöntemle 30 tane olurdu ... bu verimsiz görünüyor

Bir modüldeki bir yöntem bir modül fonksiyonuna dönüştürülürse, bunu Mods olarak açıklanmış gibi modlardan çağırabilirsiniz.

module Mods
  def self.foo
     puts "Mods.foo(self)"
  end
end

Aşağıdaki module_function yaklaşımı, tüm Modları içeren sınıfları kırmayı önleyecektir.

module Mods
  def foo
    puts "Mods.foo"
  end
end

class Includer
  include Mods
end

Includer.new.foo

Mods.module_eval do
  module_function(:foo)
  public :foo
end

Includer.new.foo # this would break without public :foo above

class Thing
  def bar
    Mods.foo
  end
end

Thing.new.bar  

Ancak, neden bir takım ilgisiz fonksiyonların hepsinin aynı modülde ilk başta yer aldığını merak ediyorum?

Şundanpublic :foo sonra çağrılırsa hala çalışmayı içeren gösterilecek şekilde düzenlenmiştirmodule_function :foo

Sadece mevcut aramaları (mevcut modülleri değiştirmeden veya yenilerini oluşturmadan) atmanın en kısa yolunun aşağıdaki gibi olacağını düşünüyorum:

Class.new.extend(UsefulThings).get_file

Modüle "sahipseniz" bunu yapmanın başka bir yolu da kullanmaktır module_function.

module UsefulThings
  def a
    puts "aaay"
  end
  module_function :a

  def b
    puts "beee"
  end
end

def test
  UsefulThings.a
  UsefulThings.b # Fails!  Not a module method
end

test

Bu yöntemleri başka bir sınıfa modül eklemeden çağırmak istiyorsanız, bunları modül yöntemleri olarak tanımlamanız gerekir:

module UsefulThings
  def self.get_file; ...
  def self.delete_file; ...

  def self.format_text(x); ...
end

ve sonra onları

UsefulThings.format_text("xxx")

veya

UsefulThings::format_text("xxx")

Her neyse, sadece ilgili yöntemleri bir modüle veya bir sınıfa koymanızı tavsiye ederim. Modülden sadece bir yöntem eklemek istediğiniz bir sorun varsa, o zaman kötü bir kod kokusu gibi geliyor ve ilgisiz yöntemleri bir araya getirmek iyi Ruby tarzı değil.

Modülü dahil etmeden (ve ara nesneler oluşturmadan) bir modül örneği yöntemini çağırmak için:

class UsefulWorker
  def do_work
    UsefulThings.instance_method(:format_text).bind(self).call("abc")
    ...
  end
end

İlk olarak, modülü ihtiyacınız olan faydalı şeylere ayırmanızı tavsiye ederim. Ancak her zaman çağrınız için bunu genişleten bir sınıf oluşturabilirsiniz:

module UsefulThings
  def a
    puts "aaay"
  end
  def b
    puts "beee"
  end
end

def test
  ob = Class.new.send(:include, UsefulThings).new
  ob.a
end

test

C. Bunları her zaman "nitelikli", bağımsız bir şekilde (UsefulThings.get_file) olarak çağırmak istiyorsanız, diğerlerinin işaret ettiği gibi sabit hale getirin,

module UsefulThings
  def self.get_file; ...
  def self.delete_file; ...

  def self.format_text(x); ...

  # Or.. make all of the "static"
  class << self
     def write_file; ...
     def commit_file; ...
  end

end

B.Karşılama yaklaşımını hala aynı durumlarda ve tek seferlik bağımsız çağırmada tutmak istiyorsanız, mixin ile kendini genişleten tek katmanlı bir modülünüz olabilir :

module UsefulThingsMixin
  def get_file; ...
  def delete_file; ...

  def format_text(x); ...
end

module UsefulThings
  extend UsefulThingsMixin
end

Yani her ikisi de çalışır:

  UsefulThings.get_file()       # one off

   class MyUser
      include UsefulThingsMixin  
      def f
         format_text             # all useful things available directly
      end
   end 

IMHO module_function, her bir yönteme göre daha temiz - hepsini istemeniz durumunda.

Soruyu anladığım gibi, bir modülün örnek yöntemlerinden bazılarını bir sınıfa karıştırmak istiyorsunuz.

Modül # içerme işlevinin nasıl çalıştığını düşünerek başlayalım . UsefulThingsİki örnekleme yöntemi içeren bir modülümüz olduğunu varsayın :

module UsefulThings
  def add1
    self + 1
  end
  def add3
    self + 3
  end
end

UsefulThings.instance_methods
  #=> [:add1, :add3]

ve Fixnum includebu modül:

class Fixnum
  def add2
    puts "cat"
  end
  def add3
    puts "dog"
  end
  include UsefulThings
end

Görüyoruz ki:

Fixnum.instance_methods.select { |m| m.to_s.start_with? "add" }
  #=> [:add2, :add3, :add1] 
1.add1
2 
1.add2
cat
1.add3
dog

UsefulThings#add3Geçersiz kılmayı bekliyordunuz Fixnum#add3, böylece 1.add3geri dönecek 4mi? Bunu düşün:

Fixnum.ancestors
  #=> [Fixnum, UsefulThings, Integer, Numeric, Comparable,
  #    Object, Kernel, BasicObject] 

Sınıf includemodül olduğunda, modül sınıfın üst sınıfı olur. Bu nedenle, mirasın nasıl çalıştığı nedeniyle, add3bir örneğine göndermek çağrılmaya ve geri dönmeye Fixnumneden olacaktır .Fixnum#add3dog

Şimdi bir yöntem ekleyelim :add2için UsefulThings:

module UsefulThings
  def add1
    self + 1
  end
  def add2
    self + 2
  end
  def add3
    self + 3
  end
end

Artık isteyen Fixnumiçin includesadece yöntemlerle add1ve add3. Böyle yapıyorsa, yukarıdakiyle aynı sonuçları almayı umuyoruz.

Yukarıdaki gibi yürüttüğümüzü varsayalım:

class Fixnum
  def add2
    puts "cat"
  end
  def add3
    puts "dog"
  end
  include UsefulThings
end

Sonuç nedir? İstenmeyen bir yöntem :add2eklenir Fixnum, :add1yukarıda izah edilen nedenlerden ötürü, ilave edilir ve :add3ilave edilmez. Yani tek yapmamız gereken undef :add2. Bunu basit bir yardımcı yöntemle yapabiliriz:

module Helpers
  def self.include_some(mod, klass, *args)
    klass.send(:include, mod)
    (mod.instance_methods - args - klass.instance_methods).each do |m|
      klass.send(:undef_method, m)
    end
  end
end

ki böyle çağırıyoruz:

class Fixnum
  def add2
    puts "cat"
  end
  def add3
    puts "dog"
  end
  Helpers.include_some(UsefulThings, self, :add1, :add3)
end

Sonra:

Fixnum.instance_methods.select { |m| m.to_s.start_with? "add" }
  #=> [:add2, :add3, :add1] 
1.add1
2 
1.add2
cat
1.add3
dog

istediğimiz sonuç bu.

Birinin hala 10 yıl sonra ihtiyacı olup olmadığından emin değilim ama eigenclass kullanarak çözdüm.

module UsefulThings
  def useful_thing_1
    "thing_1"
  end

  class << self
    include UsefulThings
  end
end

class A
  include UsefulThings
end

class B
  extend UsefulThings
end

UsefulThings.useful_thing_1 # => "thing_1"
A.new.useful_thing_1 # => "thing_1"
B.useful_thing_1 # => "thing_1"

Neredeyse 9 yıl sonra genel bir çözüm:

module CreateModuleFunctions
  def self.included(base)
    base.instance_methods.each do |method|
      base.module_eval do
        module_function(method)
        public(method)
      end
    end
  end
end

RSpec.describe CreateModuleFunctions do
  context "when included into a Module" do
    it "makes the Module's methods invokable via the Module" do
      module ModuleIncluded
        def instance_method_1;end
        def instance_method_2;end

        include CreateModuleFunctions
      end

      expect { ModuleIncluded.instance_method_1 }.to_not raise_error
    end
  end
end

Uygulamanız gereken talihsiz numara, yöntemler tanımlandıktan sonra modülü dahil etmektir. Alternatif olarak, bağlam olarak tanımlandıktan sonra da ekleyebilirsiniz ModuleIncluded.send(:include, CreateModuleFunctions).

Ya da refleks_utils taşını kullanarak kullanabilirsiniz .

spec.add_dependency "reflection_utils", ">= 0.3.0"

require 'reflection_utils'
include ReflectionUtils::CreateModuleFunctions