Trying to find all classes that include a module

Question

Before I dive into question I m gonna try to explain the structure of my codebase. This question is different from the linked question in the comments because it's concerning the list of includding modules within module classes. Not directly on the classes or in a 1 level module

1) There might be a class X which definition would be :

module ParentModule
   class X
   end
 end

2) Also there might be a nested class under different module :

module ParentModule
   module ChildModule
     class Y
     end
   end
 end

3) Also there might be just a module with some classes inside:

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

I m trying to get a list of classes within my ParentModule that include OtherModule. Here is what I have so far, working well :

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
      }

So if I do ParentModule.constants.find_all(&include_resources) I get the list of classes that include OtherModule, great! BUT unfortunately it is not able to find a class nested under child module as shown in the #2 example. So I tried doing this :

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
  } 

Unfortunately this returns the same list.

Answer 1

[Note: @engineersmnky illustrates a way to do this using flat_map eliminating the need for the matching_classes parameter. I found it more difficult to understand, but it's a perfectly sound use of flat_map and a worthy solution. The code is posted at https://repl.it/@engineersmnky/IllinformedMountainousAnkole ]

The following code uses recursion to descend the inverted tree of modules. The result (printed at the very end) is correct, and includes classes in two modules. (I've coded a minimal module and class hierarchy to use as an example.)

#!/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]