Issue #20999 has been updated by kddnewton (Kevin Newton). Proc, Method, and UnboundMethod all respond to `#source_location` already, so there is prior art here we can lean on. Personally I'd rather see that method expanded to include columns and end line, because that simplifies this whole discussion. Further enhancing `RubyVM` when it is primarily meant for debugging seems like not a great direction. If you _do_ have the columns and end line, then it's possible to read the file and extract that source you're talking about. If `RubyVM` isn't defined, you can use Prism to do a slightly better educated guess. Here's a script that combines both, so that it's portable to other Ruby implementations: ```ruby def prism_callable(callable, absolute_path, lineno) require "prism" root = Prism.parse_file(absolute_path).value case callable when Method, UnboundMethod root.breadth_first_search do |node| node.start_line == lineno && node.is_a?(Prism::DefNode) && node.name == callable.name end when Proc root.breadth_first_search do |node| node.start_line == lineno && ( (node.is_a?(Prism::CallNode) && node.name == :proc) || node.is_a?(Prism::LambdaNode) ) end end end def source_location(callable) if defined?(RubyVM::InstructionSequence) iseq = RubyVM::InstructionSequence.of(callable) [iseq.absolute_path, *iseq.to_a[4][:code_location]] else absolute_path, lineno = callable.source_location found = prism_callable(callable, absolute_path, lineno) [absolute_path, found.start_line, found.start_column, found.end_line, found.end_column] if found end end def source(callable) location = source_location(callable) return nil unless location filepath, start_line, start_column, end_line, end_column = location lines = File.read(filepath).lines[(start_line - 1)..(end_line - 1)] lines[-1] = lines[-1].byteslice(0...end_column) lines[0] = lines[0].byteslice(start_column..-1) lines.join end class Foo def bar; end end p source(-> { Object.new }) p source(proc { Object.new }) p source(Foo.new.method(:bar)) p source(Foo.instance_method(:bar)) ``` The Prism part won't work in weird edge cases like defining a method with the same name on the same line, like `def foo; end; def foo; end`, but those cases should be few and far between. Note that if `#source_location` were to be enhanced, it wouldn't be necessary to pull in Prism at all here ---------------------------------------- Feature #20999: Add RubyVM object source support https://bugs.ruby-lang.org/issues/20999#change-111254 * Author: bkuhlmann (Brooke Kuhlmann) * Status: Open ---------------------------------------- Hello. 👋 I'd like to propose adding the ability to acquire the source of any object within memory via the RubyVM. A couple use cases come to mind: - This would simplify the [Method Source](https://github.com/banister/method_source) gem implementation and possibly eliminate the need for the gem. - Another use case is this allows DSLs, like [Initable](https://alchemists.io/projects/initable), to elegantly acquire the source code of objects and/or functions (in my case, I'm most interested in the lazy evaluation of function bodies). ⚠️ I'm also aware that the [RubyVM](https://docs.ruby-lang.org/en/master/RubyVM.html) documentation clearly stats this isn't meant for production use:
This module is for very limited purposes, such as debugging, prototyping, and research. Normal users must not use it. This module is not portable between Ruby implementations.
...but I'd like to entertain this proposed feature request, regardless. Here's an example, using the aforementioned [Initable](https://alchemists.io/projects/initable) gem, where I use the RubyVM to obtain the source of a `Proc`: ``` ruby class Demo include Initable[%i[req name], [:key, :default, proc { Object.new }]] end puts Demo.new("demo").inspect #<Demo:0x000000014349a400 @name="demo", @default=#<Object:0x000000014349a360>> ``` With the above, I'm lazily obtaining the source code of the `Proc` in order to dynamically define the `#initialize` method (essentially a `module_eval` on `Demo`, simply speaking) using a nested array as specified by [Method#parameters](https://docs.ruby-lang.org/en/master/Method.html#method-i-parameters) because I don't want an instance of `Object` until initialization is necessary. ## Context Prior to the release of Ruby 3.4.0, you could do this: ``` ruby function = proc { Object.new } ast = RubyVM::AbstractSyntaxTree.of function ast.children.last.source # "Object.new" ``` Unfortunately, with the release of Ruby 3.4.0 -- which defaults to the [Prism](https://ruby.github.io/prism/rb/index.html) parser -- the ability to acquire source code is a bit more complicated. For example, to achieve what is shown above, you have to do this: ``` ruby function = proc { Object.new } RubyVM::InstructionSequence.of(function).script_lines # [ # "function = proc { Object.new }\n", # "RubyVM::InstructionSequence.of(function).script_lines\n", # "\n", # "" # ] ``` Definitely doable, but now requires more work to pluck `"Object.new"` from the body of the `Proc`. One solution is to use a regular expression to find and extract the first line of the result. Example: ``` ruby / proc # Proc statement. \s* # Optional space. \{ # Block open. (?<body>.*?) # Source code body. \} # Block close. /x ``` Definitely doesn't account for all use cases (like when a `Proc` spans multiple lines or uses `do...end` syntax) but will get you close. ## How I think there are a couple of paths that might be nice to support this use case. ### Option A Teach `RubyVM::InstructionSequence` to respond to `#source` which would be similar to what was possible prior to Ruby 3.4.0. Example: ``` ruby function = proc { Object.new } RubyVM::InstructionSequence.of(function).source # "Object.new" ``` ### Option B This is something that Samuel Williams [mentioned](https://bugs.ruby-lang.org/issues/6012#note-13) in [Feature 6012](https://bugs.ruby-lang.org/issues/6012) which would be to provide a `Source` object as answered by `Method#source` and `Proc#source`. Example (using a `Proc`): ``` ruby # Implementation # Method#source (i.e. Source.new path, line_number, line_count, body) # Usage: function = proc { Object.new } method.source.code # "Object.new" method.source.path # "$HOME/demo.rb" method.source.location # [2, 0, 3, 3] ``` ### Option C It could be nice to support both Option A and B. -- https://bugs.ruby-lang.org/