Posso invocare un metodo di istanza su un modulo Ruby senza includerlo?

Sfondo:

Ho un modulo che dichiara una serie di metodi di istanza

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

  def format_text(x); ...
end

E voglio chiamare alcuni di questi metodi all'interno di una classe. Come si fa normalmente in ruby ​​è così:

class UsefulWorker
  include UsefulThings

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

Problema

include UsefulThingsporta tutti i metodi da UsefulThings. In questo caso voglio solo format_texted esplicitamente non voglio get_filee delete_file.

Vedo diverse possibili soluzioni a questo:

1. In qualche modo invocare il metodo direttamente sul modulo senza includerlo ovunque
   • Non so come / se ciò può essere fatto. (Da qui questa domanda)
2. In qualche modo includi Usefulthingse porti solo alcuni dei suoi metodi
   • Inoltre non so come / se ciò può essere fatto
3. Creare una classe proxy, includerla UsefulThings, quindi delegare format_texta tale istanza proxy
   • Funzionerebbe, ma le classi proxy anonime sono un hack. Che schifo.
4. Suddividere il modulo in 2 o più moduli più piccoli
   • Funzionerebbe anche questa, ed è probabilmente la migliore soluzione a cui riesco a pensare, ma preferirei evitarlo dato che finirei con una proliferazione di dozzine e dozzine di moduli - gestire questo sarebbe gravoso

Perché ci sono molte funzioni non correlate in un singolo modulo? Viene ApplicationHelperda un'app di binari, che il nostro team ha di fatto deciso come discarica per qualsiasi cosa non abbastanza specifica da appartenere a nessun'altra parte. Principalmente metodi di utilità autonomi che vengono utilizzati ovunque. Potrei dividerlo in aiutanti separati, ma ce ne sarebbero 30, tutti con 1 metodo ciascuno ... questo sembra improduttivo

Se un metodo su un modulo viene trasformato in una funzione di modulo, puoi semplicemente richiamarlo da Mods come se fosse stato dichiarato come

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

L'approccio module_function di seguito eviterà di interrompere qualsiasi classe che includa tutte le Mod.

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  

Tuttavia, sono curioso di sapere perché un insieme di funzioni non correlate sono tutte contenute nello stesso modulo in primo luogo?

Modificato per mostrare che include ancora il lavoro se public :fooviene chiamato dopomodule_function :foo

Penso che il modo più breve per effettuare una chiamata singola a eliminazione diretta (senza alterare i moduli esistenti o crearne di nuovi) sarebbe il seguente:

Class.new.extend(UsefulThings).get_file

Un altro modo per farlo se "possiedi" il modulo è usare 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

Se si desidera chiamare questi metodi senza includere il modulo in un'altra classe, è necessario definirli come metodi del modulo:

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

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

e poi puoi chiamarli con

UsefulThings.format_text("xxx")

o

UsefulThings::format_text("xxx")

Ma comunque consiglierei di inserire solo metodi correlati in un modulo o in una classe. Se hai problemi che vuoi includere solo un metodo dal modulo, allora suona come un cattivo odore di codice e non è un buon stile Ruby mettere insieme metodi non correlati.

Per invocare un metodo di istanza del modulo senza includere il modulo (e senza creare oggetti intermedi):

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

In primo luogo, consiglierei di suddividere il modulo in cose utili di cui hai bisogno. Ma puoi sempre creare una classe che la estende per la tua invocazione:

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

R. Nel caso tu voglia sempre chiamarli in modo "qualificato", autonomo (UsefulThings.get_file), quindi rendili statici come altri hanno sottolineato,

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. Se vuoi ancora mantenere l'approccio mixin negli stessi casi, così come l'invocazione stand-alone una tantum, puoi avere un modulo one-liner che si estende con il mixin:

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

  def format_text(x); ...
end

module UsefulThings
  extend UsefulThingsMixin
end

Quindi entrambi funzionano quindi:

  UsefulThings.get_file()       # one off

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

IMHO è più pulito che module_functionper ogni singolo metodo, nel caso volessero tutti.

Quando capisco la domanda, vuoi mescolare alcuni dei metodi di istanza di un modulo in una classe.

Cominciamo considerando come funziona Module # include . Supponiamo di avere un modulo UsefulThingsche contiene due metodi di istanza:

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

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

e Fixnum includequel modulo:

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

Lo vediamo:

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

Ti aspettavi UsefulThings#add3di scavalcare Fixnum#add3, in modo che 1.add3tornasse 4? Considera questo:

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

Quando la classe includeè il modulo, il modulo diventa la superclasse della classe. Quindi, a causa del modo in cui funziona l'eredità, l'invio add3a un'istanza di Fixnumfarà sì Fixnum#add3che venga invocato, ritornando dog.

Ora aggiungiamo un metodo :add2a UsefulThings:

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

Ora desideriamo Fixnumper includesolo i metodi add1e add3. Sta facendo così, ci aspettiamo di ottenere gli stessi risultati di cui sopra.

Supponiamo che, come sopra, eseguiamo:

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

Qual'è il risultato? :add2Viene aggiunto il metodo indesiderato Fixnum, :add1viene aggiunto e, per motivi che ho spiegato sopra, :add3non viene aggiunto. Quindi tutto ciò che dobbiamo fare è undef :add2. Possiamo farlo con un semplice metodo di supporto:

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

che invochiamo così:

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

Poi:

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

quale è il risultato che vogliamo.

Non sono sicuro che qualcuno ne abbia ancora bisogno dopo 10 anni, ma l'ho risolto usando la eigenclass.

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"

Dopo quasi 9 anni ecco una soluzione generica:

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

Lo sfortunato trucco che devi applicare è quello di includere il modulo dopo aver definito i metodi. In alternativa puoi anche includerlo dopo aver definito il contesto comeModuleIncluded.send(:include, CreateModuleFunctions) .

Oppure puoi usarlo tramite la gemma reflection_utils .

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

require 'reflection_utils'
include ReflectionUtils::CreateModuleFunctions