Posso invocar um método de instância em um módulo Ruby sem incluí-lo?

Fundo:

Eu tenho um módulo que declara vários métodos de instância

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

  def format_text(x); ...
end

E eu quero chamar alguns desses métodos de dentro de uma classe. Como você normalmente faz isso em ruby ​​é assim:

class UsefulWorker
  include UsefulThings

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

Problema

include UsefulThingstraz todos os métodos de UsefulThings. Neste caso, eu só quero format_texte explicitamente não quero get_filee delete_file.

Eu posso ver várias soluções possíveis para isso:

1. De alguma forma, invoque o método diretamente no módulo sem incluí-lo em nenhum lugar
   • Não sei como / se isso pode ser feito. (Daí esta pergunta)
2. De alguma forma, inclua Usefulthingse apenas traga alguns métodos
   • Também não sei como / se isso pode ser feito
3. Crie uma classe de proxy, inclua nela e, UsefulThingsem seguida, delegue format_textpara essa instância de proxy
   • Isso funcionaria, mas classes proxy anônimas são um hack. Que nojo.
4. Divida o módulo em 2 ou mais módulos menores
   • Isso também funcionaria, e é provavelmente a melhor solução em que consigo pensar, mas prefiro evitá-la, pois acabo com uma proliferação de dezenas e dezenas de módulos - gerenciar isso seria oneroso

Por que existem muitas funções não relacionadas em um único módulo? É ApplicationHelperde um aplicativo de trilhos, que nossa equipe decidiu de fato como o depósito de lixo para qualquer coisa não específica o suficiente para pertencer a qualquer outro lugar. Métodos utilitários principalmente independentes que são usados ​​em qualquer lugar. Eu poderia dividi-lo em ajudantes separados, mas haveria 30 deles, todos com 1 método cada ... isso parece improdutivo

Se um método em um módulo é transformado em uma função de módulo, você pode simplesmente chamá-lo de Mods como se tivesse sido declarado como

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

A abordagem module_function abaixo evitará quebrar todas as classes que incluem todos os Mods.

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  

No entanto, estou curioso para saber por que um conjunto de funções não relacionadas está contido no mesmo módulo em primeiro lugar?

Editado para mostrar que ainda inclui trabalho se public :foofor chamado apósmodule_function :foo

Eu acho que a maneira mais curta de fazer uma única chamada descartável (sem alterar os módulos existentes ou criar novos) seria a seguinte:

Class.new.extend(UsefulThings).get_file

Outra maneira de fazer isso se você "possuir" o módulo é usar 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 você quiser chamar esses métodos sem incluir o módulo em outra classe, precisará defini-los como métodos do módulo:

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

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

e então você pode chamá-los com

UsefulThings.format_text("xxx")

ou

UsefulThings::format_text("xxx")

De qualquer forma, eu recomendaria que você colocasse apenas métodos relacionados em um módulo ou em uma classe. Se você tiver um problema que deseja incluir apenas um método do módulo, isso soa como um mau cheiro de código e não é bom estilo Ruby reunir métodos não relacionados.

Para chamar um método de instância do módulo sem incluir o módulo (e sem criar objetos intermediários):

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

Em primeiro lugar, eu recomendo dividir o módulo nas coisas úteis que você precisa. Mas você sempre pode criar uma classe estendendo isso para sua chamada:

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. Caso você queira sempre chamá-los de uma maneira "qualificada" e autônoma (UsefulThings.get_file), basta torná-los estáticos, conforme indicado por outros,

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 você ainda deseja manter a abordagem de mixin nos mesmos casos, bem como a invocação independente, você pode ter um módulo de uma linha que se estenda com o mixin:

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

  def format_text(x); ...
end

module UsefulThings
  extend UsefulThingsMixin
end

Então, ambos funcionam então:

  UsefulThings.get_file()       # one off

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

IMHO é mais limpo do que module_functionpara todos os métodos - caso deseje todos eles.

Pelo que entendi a pergunta, você deseja misturar alguns dos métodos de instância de um módulo em uma classe.

Vamos começar considerando como o Módulo # include funciona. Suponha que tenhamos um módulo UsefulThingsque contém dois métodos de instância:

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

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

e Fixnum includeesse módulo:

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

Nós vemos que:

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

Você esperava UsefulThings#add3substituir Fixnum#add3, para que 1.add3retornasse 4? Considere isto:

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

Quando a classe includeé o módulo, o módulo se torna a superclasse da classe. Portanto, por causa de como a herança funciona, o envio add3para uma instância de Fixnumfará com Fixnum#add3que seja invocado, retornando dog.

Agora vamos adicionar um método :add2para UsefulThings:

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

Agora queremos Fixnumque includeapenas os métodos add1e add3. Com isso, esperamos obter os mesmos resultados acima.

Suponha que, como acima, executamos:

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

Qual é o resultado? O método indesejado :add2é adicionado a Fixnum, :add1é adicionado e, pelas razões que expliquei acima, :add3não é adicionado. Então, tudo o que precisamos fazer é undef :add2. Podemos fazer isso com um método auxiliar simples:

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

que invocamos assim:

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

Então:

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

qual é o resultado que queremos.

Não tenho certeza se alguém ainda precisa disso depois de 10 anos, mas eu resolvi usando a classe própria.

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"

Depois de quase 9 anos, aqui está uma solução genérica:

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

O truque infeliz que você precisa aplicar é incluir o módulo após a definição dos métodos. Como alternativa, você também pode incluí-lo após o contexto ser definido como ModuleIncluded.send(:include, CreateModuleFunctions).

Ou você pode usá-lo através da gema reflection_utils .

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

require 'reflection_utils'
include ReflectionUtils::CreateModuleFunctions