Início / coding / Perguntas / 77460372
Accepted
ohhh
Asked: 2023-11-10 21:30:08 +0800 CST

Como as substituições de método em nível de módulo funcionam em Ruby?

  • 772

Eu tenho algum código baseado nesta resposta do SO: https://stackoverflow.com/a/2136117/2158544 . Essencialmente, é assim (nota: no código real, eu não controlo o módulo A) :

module A
  def self.included(base)
    base.extend ClassMethods
  end
  module ClassMethods
    def singleton_test
    end
  end
end

module B
  def self.included(base)
    base.extend ClassMethods
  end

  module ClassMethods
    def self.extended(base)
      puts base.method(:singleton_test).owner
      define_method(:singleton_test) do |*args, &blk|
        super(*args, &blk)
      end
    end
  end
end

Primeira inclusão:

class C
  include A
  include B
end
A::ClassMethods # <- output

Segunda inclusão:

class D
  include A
  include B
end
B::ClassMethods # <- output

Embora a chamada para superainda seja roteada corretamente para module A, estou confuso por que singleton_testjá está "embrulhado" quando é incluído em class D(owner is B::ClassMethods). Minha teoria é que quando module Bredefines singleton_test, ele está redefinindo-o no nível do módulo incluído ( module A) e, portanto, toda vez que module Aé incluído posteriormente, o método já foi "embrulhado".

ruby

1 respostas

  1. Best Answer

    Quando você chama um método, Ruby sobe na cadeia ancestral procurando pelo método, se chegar ao topo (BasicObject) e não conseguir encontrar um método correspondente, gerará um erro (a menos que seja definido method_missing)

    Como isso funciona no seu exemplo

    Primeira Inclusão

    C.singleton_class.ancestors
#=> [#<Class:C>, B::ClassMethods, A::ClassMethods, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]

    Quando você pesquisa, singleton_testele verifica a cadeia ancestral

    • C - Nenhum método
    • B::ClassMethods - Nenhum método
    • A::ClassMethods - Encontradosingleton_test

    Agora no B::ClassMethods::extendedgancho você está definindo singleton_testusing define_method. Como você chamou esse método sem um receptor, o receptor implícito é selfe selfno contexto desse método é, B::ClassMethodsem essência, você está chamando

    module B 
  module ClassMethods 
    def singleton_test(*args,&blk) 
      super(*args, &blk)
    end 
  end 
end

    Você pode ver isso mais claramente como

    puts "Before B inclusion: #{B::ClassMethods.instance_methods(false)}"
class C
  include A
  include B 
end
puts "After B inclusion: #{B::ClassMethods.instance_methods(false)}"

    Saída:

    Before B inclusion: []
After B inclusion: [:singleton_test]

    Segunda Inclusão

    Acho que você pode ver onde isso está indo

    D.singleton_class.ancestors
#=> [#<Class:D>, B::ClassMethods, A::ClassMethods, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]

    Quando você pesquisa, singleton_testele verifica a cadeia ancestral

    • D - Nenhum método
    • B::ClassMethods - Encontradosingleton_test

    Portanto, não é que o método "já esteja empacotado" ou que o método esteja sendo redefinido nele, Aé que você definiu um novo método B::ClassMethodse uma vez que Bé incluído após Asua definição ter prioridade (substitui a de Aneste contexto).

    • 3

relate perguntas