Ruby 获取实现方法继承顺序/super的实例方法的类/模块的有序列表

我在一个Ruby类（Ruby 2.0.0p247）中包含了几个模块，其中一些模块定义了相同的实例方法，并且都包含在同一个类中。我想要一些代码来为实现该方法的继承层次结构中的类列表生成每个方法名称符号的哈希，以便执行它们。我该怎么做

（这样我就知道当我调用每个

x

方法时，如果每个方法都要执行

super（如果已定义）（super）

，我就知道方法执行的顺序。）

例如，给定实现实例方法x的类C，其中C包括同时实现实例方法x的模块A和模块B，那么我可以使用一些代码来检查C，从而得出如下结果：

=> {:x=>[C, A, B], ...}

为了澄清，我想知道通过模块和类继承继承的所有方法，而不仅仅是那些在C上定义的方法

另一个例子显示我在寻找什么：

模块A
def v
结束
def x
结束
结束
模块B
def x
结束
DEFY
结束
结束
模块D
定义a
结束
结束
E类
包括A、B
def x
结束
DEFY
结束
def z
结束
结束
C类

因此，C的结果应为：

[代码>>>><代码>>>>[代码>>>>[代码>>>>[代码>>[代码>>>[代码>>>[代码>>>[代码>>>>[代码>>>[代码>>[代码]中，，，，，，，，，，，，，，，，，，，，，，，，，，，，：y=>[E，y>[E，y>[E，B]，，，，：z=>[E，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，，不可信？=>[Kernel]，：trust=>[Kernel]，：freeze=>[Kernel]，：to_s=>[Kernel]，：inspect=>[Kernel]，：methods=>[Kernel]，：singleton_methods=>[Kernel]，：protected_methods=>[Kernel]，：private_methods=>[Kernel]，：instance_variables=>[Kernel]，：instance_variable_=>[Kernel]，：instance_-get=>[Kernel]，：instance_-get=>，：instance\u variable\u defined？=>[内核]，：remove\u instance\u variable=>[内核]，：instance\u of？=>[内核]，：is\u a？=>[内核]，：tap=>[内核]，：send=>[内核]，：public\u send=>[内核]，：respond\u to？=>[内核]，：extend=>[内核]，：display=>[内核]，：method=>[内核]，：public\u方法=>[内核]，：define\u=>[内核]，：singleton内核方法]，：object_id=>[Kernel]，：to_enum=>[Kernel]，：enum_for=>[Kernel]，：===>[BasicObject]，：equal？=>[BasicObject]，：！=>[BasicObject]，：instance_eval=>[BasicObject]，：instance_exec=>[BasicObject]，：：\u send=>[BasicObject]，：\uu id=>[BasicObject]} 我的第一次尝试是：

instance_method_inheritance_chain = {}

C.instance_methods(false).each do |m|
  (instance_method_inheritance_chain[m] ||= []) << C
end

C.ancestors.each do |a|
  a.instance_methods(false).each do |m|
    (instance_method_inheritance_chain[m] ||= []) << a unless instance_method_inheritance_chain[m] && instance_method_inheritance_chain[m].include?(a)
  end
end

instance_method_inheritance_chain

实例\方法\继承\链={}
C.instance_方法（false）。每个方法|
（instance_method_inheritation_chain[m]| |=[]）很好！我应该更清楚地回答这个问题，我希望能够包括所有继承的方法，不仅仅是类C中定义的方法，而是您的解决方案：
Hash[C.instance_methods（false）。map{m |[m，C.concenters.select{a | a.instance_方法（false）。include？（m）}]
在类C中定义所有方法时效果非常好。只需删除第一个
false
。几乎可以，但这会在继承链中添加C，即使它没有定义方法本身。我将在问题中提供一个更好的示例，以便您了解我的意思。
 => {:a=>[D], :x=>[E, A, B], :y=>[E, B], :z=>[E], :v=>[A], :nil?=>[Kernel], :====>[Kernel], :=~=>[Kernel], :!~=>[Kernel], :eql?=>[Kernel], :hash=>[Kernel], :<=>=>[Kernel], :class=>[Kernel], :singleton_class=>[Kernel], :clone=>[Kernel], :dup=>[Kernel], :taint=>[Kernel], :tainted?=>[Kernel], :untaint=>[Kernel], :untrust=>[Kernel], :untrusted?=>[Kernel], :trust=>[Kernel], :freeze=>[Kernel], :frozen?=>[Kernel], :to_s=>[Kernel], :inspect=>[Kernel], :methods=>[Kernel], :singleton_methods=>[Kernel], :protected_methods=>[Kernel], :private_methods=>[Kernel], :public_methods=>[Kernel], :instance_variables=>[Kernel], :instance_variable_get=>[Kernel], :instance_variable_set=>[Kernel], :instance_variable_defined?=>[Kernel], :remove_instance_variable=>[Kernel], :instance_of?=>[Kernel], :kind_of?=>[Kernel], :is_a?=>[Kernel], :tap=>[Kernel], :send=>[Kernel], :public_send=>[Kernel], :respond_to?=>[Kernel], :extend=>[Kernel], :display=>[Kernel], :method=>[Kernel], :public_method=>[Kernel], :define_singleton_method=>[Kernel], :object_id=>[Kernel], :to_enum=>[Kernel], :enum_for=>[Kernel], :===>[BasicObject], :equal?=>[BasicObject], :!=>[BasicObject], :!==>[BasicObject], :instance_eval=>[BasicObject], :instance_exec=>[BasicObject], :__send__=>[BasicObject], :__id__=>[BasicObject]} 

instance_method_inheritance_chain = {}

C.instance_methods(false).each do |m|
  (instance_method_inheritance_chain[m] ||= []) << C
end

C.ancestors.each do |a|
  a.instance_methods(false).each do |m|
    (instance_method_inheritance_chain[m] ||= []) << a unless instance_method_inheritance_chain[m] && instance_method_inheritance_chain[m].include?(a)
  end
end

instance_method_inheritance_chain

result = Hash[C.instance_methods(false).map {|m| [m, [C]]}]
C.ancestors.each {|a| a.instance_methods(false).each {|m| (result[m] ||= []) << a } }
result

def method_inheritance(klass)
  result = Hash[klass.instance_methods(false).map {|m| [m, [klass]]}]
  klass.ancestors.each {|a| a.instance_methods(false).each {|m| (result[m] ||= []) << a } }
  result # and maybe .reject{|m| m == :method_inheritance} if needed
end

method_inheritance(C)

Hash[
  C.instance_methods.map {|m|
    [m, C.ancestors.select {|a| a.instance_methods(false).include?(m)}]}]
# => { x: [C, A, B] }