There still an issue with inferring for a given function call / constant reference where that thing is defined. We're currently generating the forest of references from the call graph by calculating a spanning forest. There's a problem with that. Consider the following map of call-sites: { a: [b] b: [] } The following is a spanning tree: { a: [] b: [] } Here it looks like `a` doesn't call `b`. We should also store all the call-sites. These will end up as leaves in the call tree. { "K": {}, "A": {}, "f": { "f": "__cycle__" }, "A.f": { "K.g": {} } } The above problem is sort of fixed by just writing DOT output as it takes care of cycles. # Instance methods Instance methods are a common occurrence in Ruby code. However they aren't really resolved in a nice way. E.g.: def f person.name end Will produce: {"f":["name"]} Which is misleading. What we could do it try and find out what `person` is referring to and then "inline" it. For example. Assume that we have `"person": ["Person.new"]` in our references then we could add an entry for `f` like so: `"f": ["Person.name"]`.