试图找到包含模块的所有类

Question

在深入探讨之前，我将尝试解释我的代码库的结构。 这个问题与 cmets 中的链接问题不同，因为它涉及模块类中包含的模块列表。不直接在类或 1 级模块中

1) 可能有一个 X 类，其定义如下：

module ParentModule
   class X
   end
 end

2) 不同模块下也可能有嵌套类：

module ParentModule
   module ChildModule
     class Y
     end
   end
 end

3) 也可能只有一个模块，里面有一些类：

module ParentModule
   module OtherModule
     def some_awesome_method
       ..does something
     end
   end  
 end

我试图在我的ParentModule 中获取包含OtherModule 的类列表。这是我到目前为止所拥有的，运行良好：

include_resources = ->(klass) {
        begin
          klass_string = klass.to_s
          klass_resource = klass_string.constantize
          klass_string if klass_resource.included_modules.include?(OtherModule)
        rescue NameError # skip all bad naming and other irrelevant constant loading mishaps
          next
        end
      }

所以如果我执行ParentModule.constants.find_all(&include_resources)，我会得到包含OtherModule 的类列表，太好了！但不幸的是，它无法找到嵌套在子模块下的类，如 #2 示例所示。所以我尝试这样做：

include_resources = ->(klass) {
        begin
          klass_string = klass.to_s
          klass_resource = klass_string.constantize
          if klass_resource.class == Module
            return "ParentModule::#{klass_string}".constants.find_all do |module_klass|
              module_klass.constantize.included_modules.include?(OtherModule)
            end
          end
          klass_string if klass_resource.included_modules.include?(OtherModule)
        rescue NameError # skip all bad naming and other irrelevant constant loading mishaps
          next
        end
  } 

不幸的是，这会返回相同的列表。

Answer 1

[注意：@engineersmnky 说明了一种使用flat_map 实现此目的的方法，无需使用matching_classes 参数。我发现它更难理解，但这是对flat_map 的完美使用，也是一个有价值的解决方案。代码贴在https://repl.it/@engineersmnky/IllinformedMountainousAnkole]

以下代码使用递归来降低模块的倒置树。结果（在最后打印）是正确的，并且包括两个模块中的类。 （我编写了一个最小的模块和类层次结构以用作示例。）

#!/usr/bin/env ruby

module ParentModule
  module OtherModule; end
  class ParentClassYes; include OtherModule; end
  class ParentClassNo;  end

  module ChildModule
    class ChildClassYes; include OtherModule; end
    class ChildClassNo;  end
  end
end


def classes_for_module_tree(the_module, matching_classes = [])
  the_module.constants.each_with_object(matching_classes) \
        do |const, matching_classes|
    value = the_module.const_get(const)
    if value.is_a?(Class)
      if value.included_modules.include?(ParentModule::OtherModule)
        matching_classes << value
      end
    elsif value.is_a?(Module)
      # Here is where we call this method recursively. We suspend collecting
      # matches for this module, call the method to process the newly found
      # (sub)module, then use the array returned by that invocation to resume
      # processing this module.
      matching_classes = classes_for_module_tree(value, matching_classes)
    end
  end
  matching_classes
end


p classes_for_module_tree(ParentModule)
# prints: [ParentModule::ParentClassYes, ParentModule::ChildModule::ChildClassYes]