How to list the methods only from the included modules - ruby

Question

I include and extend some modules into my class.
I put binding.pry then step into it. Use self.methods to list all methods I have.
But the list is too long , How could I list the methods only in the modules I include. Excepts the methods in my self.class and the methods from ancestors like inspect to_s , ...
include SnapshotsHelper
extend SnapshotsHelper
Thanks

Answer 1

I think something like below you are looking for :
when you will include modules
module A
def meth1;end
def meth2;end
end
module B
def meth11;end
def meth21;end
end
class C
include A,B
end
list = C.included_modules.each_with_object({}) do |m,ob|
module_arry = m.instance_methods
ob[m]=C.instance_methods.select{|e| module_arry.include?(e)} if m != Kernel
end
p list
# >> {A=>[:meth1, :meth2], B=>[:meth11, :meth21]}
when you will extend modules
module A
def meth1;end
def meth2;end
end
module B
def meth11;end
def meth21;end
end
class C
extend A,B
end
list = C.singleton_class.included_modules.each_with_object({}) do |m,ob|
module_arry = m.instance_methods
class_methods = C.methods - C.instance_methods
ob[m]= class_methods.select{|e| module_arry.include?(e)} if m != Kernel
end
p list
# >> {A=>[:meth1, :meth2], B=>[:meth11, :meth21]}

Answer 2

I suppose you want only methods from modules included in the very child you're in, filtering out methods from modules included in parents. If you also want modules included from parents, #Arup answer is the good one.
There's no provided core method to do what you want, but you can create one if you need this often.
Prerequisite knowledge
There are three sources of methods for a given class :
methods defined in the class itself and its monkey patches
methods from parent
methods from modules
Method from modules may be inserted in class itself or from parents (or even by hook in modules, but let's keep that aside).
Note also that Class inherits from Module, so a Class is a Module.
How to retrieve modules
Now, having all of that, what you want to do is to get all modules included in your current class, remove parent modules and get methods. The basic formula is thus :
methods_from_module_included_in_current_class = ( modules_in_class - modules_in_parent ).methods
To get all module in class, you can use the #ancestors method. It will list all classes and modules which has been mixed in current class (remember : a class is just a module).
modules_in_class = MyClass.ancestors.reject { |ancestor| Class === ancestor }
Here, we reject what is a Class from the list (Class === ancestor is the same than doing ancestor.is_a? Class), so we know we only have modules. Again, we can't just select modules, since Class are Module.
Finally, we can apply the same pattern to get modules from parent :
module_in_parent = MyClass.superclass.ancestors.reject { |ancestor| Class === ancestor }
Getting methods
So, to get all your methods from modules included in current class :
( MyClass.ancestors.reject { |ancestor| Class === ancestor } - MyClass.superclass.ancestors.reject { |ancestor| Class === ancestor } ).map( &:instance_methods ).flatten
To get class methods (thus methods added using #extend) rather, replace instance_methods with methods.
Note you may still have a few unfamiliar methods here if some anonymous module is declared on class initialization, like rails does on ActiveRecord::Base.
Factoring that
If you find yourself using this frequently, you can factorize it in a method :
class Object
def inner_module_methods
( self.class.ancestors.reject { |ancestor| Class === ancestor } - self.class.superclass.ancestors.reject { |ancestor| Class === ancestor } ).map( &:instance_methods ).flatten
end
end
You can now do :
obj.inner_module_methods
Or within pry :
inner_module_methods
Alternative
You may also want to filter methods by source file. If find this being more effective and volatile, in the long run.