modulos - operador modulo en ruby

Extender un módulo de Ruby en otro módulo, incluidos los métodos del módulo

Question

Cada vez que trato de extender un módulo de ruby, pierdo los métodos del módulo. Ni incluir ni extender hará esto. Considera el fragmento:

module A
def self.say_hi
puts "hi"
end
end
module B
include A
end
B.say_hi #undefined_method

Ya sea que B incluya o extienda A, say_hi no estará definido.

¿Hay alguna manera de lograr algo como esto?

Answer 1

No creo que haya una forma simple de hacerlo.

Entonces, aquí hay una forma compleja:

module B
class << self
A.singleton_methods.each do |m|
define_method m, A.method(m).to_proc
end
end
end

Puedes ponerlo en un método de ayuda como este:

class Module
def include_module_methods(mod)
mod.singleton_methods.each do |m|
(class << self; self; end).send :define_method, m, mod.method(m).to_proc
end
end
end
module B
include_module_methods A
end

Answer 2

Si usted es el autor del module A y lo necesitará con frecuencia, puede volver a crear A así:

module A
module ClassMethods
def say_hi
puts "hi"
end
end
extend ClassMethods
def self.included( other )
other.extend( ClassMethods )
end
end
module B
include A
end
A.say_hi #=> "hi"
B.say_hi #=> "hi" 

Answer 3

Use include_complete

gem install include_complete

module A
def self.say_hi
puts "hi"
end
end
module B
include_complete A
end
B.say_hi #=> "hi"

Answer 4

Johnathan, no estoy seguro si todavía te estás preguntando sobre esto, pero hay dos formas diferentes de usar módulos en ruby. A.) usa módulos en su forma autónoma Base :: Tree.entity (params) directamente en su código, o B.) usa módulos como mixins o métodos auxiliares.

A. Le permitirá usar módulos como un patrón de espacio de nombres. Esto es bueno para proyectos más grandes donde existe la posibilidad de conflictos de nombres de métodos

module Base
module Tree
def self.entity(params={},&block)
# some great code goes here
end
end
end

Ahora puede usar esto para crear algún tipo de estructura de árbol en su código, sin tener que instanciar una nueva clase para cada llamada a Base :: Tree.entity.

Otra forma de hacer Namespace-ing es en una clase por clase.

module Session
module Live
class Actor
attr_accessor :type, :uuid, :name, :status
def initialize(params={},&block)
# check params, insert init values for vars..etc
# save your callback as a class variable, and use it sometime later
@block = block
end
def hit_rock_bottom
end
def has_hit_rock_bottom?
end
...
end
end
class Actor
attr_accessor :id,:scope,:callback
def initialize(params={},&block)
self.callback = block if block_given?
end
def respond
if self.callback.is_a? Proc
# do some real crazy things...
end
end
end
end

Ahora tenemos el potencial de superposición en nuestras clases. Queremos saber que cuando creamos una clase Actor es la clase correcta, así que aquí es donde los espacios de nombres son útiles.

Session::Live::Actor.new(params) do |res|...
Session::Actor.new(params) 

B. Mix-Ins Estos son tus amigos. Úselos cada vez que crea que tendrá que hacer algo más de una vez en su código.

module Friendly
module Formatter
def to_hash(xmlstring)
#parsing methods
return hash
end
def remove_trailing_whitespace(string,&block)
# remove trailing white space from that idiot who pasted from textmate
end
end
end

Ahora, cada vez que necesite formatear un xmlstring como un hash, o eliminar los espacios en blanco al final en cualquiera de sus códigos futuros, simplemente mezcle.

module Fun
class Ruby
include Friendly::Formatter
attr_accessor :string
def initialize(params={})
end
end
end

Ahora puedes formatear la cadena en tu clase.

fun_ruby = Fun::Ruby.new(params)
fun_ruby.string = "<xml><why><do>most</do><people></people><use>this</use><it>sucks</it></why></xml>"
fun_ruby_hash = fun_ruby.to_hash(fun_ruby.string)

Espero que esta sea una buena explicación. Los puntos planteados anteriormente son buenos ejemplos de formas de extender clases, pero con los módulos, la parte difícil es cuándo usar la palabra clave self . Se refiere al alcance del objeto dentro de la jerarquía de objetos de ruby. Entonces, si desea usar un módulo como mezcla y no desea declarar nada solo, no use la palabra clave auto, sin embargo, si desea mantener el estado dentro del objeto, simplemente use una clase y mezcle. en los módulos que quieras.

Answer 5

No me gusta que todos usen self.included . Tengo una solución más simple:

module A
module ClassMethods
def a
''a1''
end
end
def a
''a2''
end
end
module B
include A
module ClassMethods
include A::ClassMethods
def b
''b1''
end
end
def b
''b2''
end
end
class C
include B
extend B::ClassMethods
end
class D < C; end
puts D.a
puts D.b
puts D.new.a
puts D.new.b