¿Puedo invocar un método de instancia en un módulo Ruby sin incluirlo?

Creo que la forma más corta de hacer solo una llamada desechable (sin alterar los módulos existentes o crear otros nuevos) sería la siguiente:

Class.new.extend(UsefulThings).get_file

Otra forma de hacerlo si "posees" el módulo es 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

Si desea llamar a estos métodos sin incluir módulo en otra clase, debe definirlos como métodos de módulo:

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

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

Y luego puedes llamarlos con

UsefulThings.format_text("xxx")

O

UsefulThings::format_text("xxx")

Pero de todos modos le recomendaría que ponga solo métodos relacionados en un módulo o en una clase. Si tiene un problema que desea incluir solo un método desde el módulo, entonces suena como un mal olor a código y no es un buen estilo Ruby juntar métodos no relacionados.

Para invocar un método de instancia de módulo sin incluir el módulo (y sin crear objetos intermedios):

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

En primer lugar, recomiendo dividir el módulo en las cosas útiles que necesita. Pero siempre puedes crear una clase que extienda eso para tu invocación:

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

A. En caso de que usted, siempre quiera llamarlos de una manera "calificada", independiente (UsefulThings.get_file), luego simplemente hazlos estáticos como otros señalaron,

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. Si aún desea mantener el enfoque mixin en los mismos casos, así como la invocación independiente única, puede tener un módulo de un solo revestimiento que se extiende con el mixin:

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

  def format_text(x); ...
end

module UsefulThings
  extend UsefulThingsMixin
end

Así que ambos funcionan entonces:

  UsefulThings.get_file()       # one off

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

En mi humilde opinión es más limpio que module_function para cada método - en caso de querer todos ellos.

Como entiendo la pregunta, desea mezclar algunos de los métodos de instancia de un módulo en una clase.

Comencemos considerando cómo funciona El módulo#include. Supongamos que tenemos un módulo UsefulThings que contiene dos métodos de instancia:

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

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

Y Fixnum includes ese módulo:

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

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

¿Esperabas que UsefulThings#add3 anulara Fixnum#add3, para que 1.add3 volviera 4? Considere esto:

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

Cuando la clase include es la módulo, el módulo se convierte en la superclase de la clase. Por lo tanto, debido a cómo funciona la herencia, enviar add3 a una instancia de Fixnum hará que se invoque Fixnum#add3, devolviendo dog.

Ahora vamos a añadir un método :add2 a UsefulThings:

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

Ahora deseamos Fixnum a include solo los métodos add1 y add3. Si lo hace, esperamos obtener los mismos resultados que los anteriores.

Supongamos, como arriba, que ejecutamos:

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

¿Cuál es el resultado? El método no deseado :add2 se añade a Fixnum, :add1 se añade y, por las razones que he explicado anteriormente, :add3 no se añade. Así que todo lo que tenemos que hacer es undef :add2. Podemos hacer eso con un simple método de ayuda:

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 así: {[34]]}

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

Entonces:

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

Que es el resultado que queremos.

Después de casi 9 años aquí hay una solución 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

El desafortunado truco que necesita aplicar es incluir el módulo después de que se hayan definido los métodos. Alternativamente, también puede incluirlo después de que el contexto se defina como ModuleIncluded.send(:include, CreateModuleFunctions).

O puede usarlo a través de la gema reflection_utils.

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

require 'reflection_utils'
include ReflectionUtils::CreateModuleFunctions