Issue #19617 has been updated by nevans (Nicholas Evans). Perhaps I shouldn't have given the Regexp use-case, since there are many other approaches we can (and should) use to audit our regexps. Although that was the immediate trigger for this ticket, it wasn't the first or the most common reason I've wanted this feature. I think this (or something like it) should be added for all of the same reasons that `Proc#binding` was added. The most common use-case (for me) is simply debugging and exploring through run-time inspection on the console. The only way I know of to get captured local variables at the moment is to use TracePoint or a debug breakpoint and execute the code. But that shouldn't be required. Besides this and data that is managed by native extensions, what other forms of ruby state require either tracepoint or a debug breakpoint to inspect? There's already a ticket for #15778. ---------------------------------------- Feature #19617: Add Method#binding and UnboundMethod#binding, similar to Proc#binding https://bugs.ruby-lang.org/issues/19617#change-102931 * Author: nevans (Nicholas Evans) * Status: Open * Priority: Normal ---------------------------------------- When a method is defined dynamically with `define_method`, it would be useful to obtain access to the defining block's binding and the local variables it has captured, based on the defining block's binding. For methods defined using the `def` keyword, the binding's local variables might be empty or might be all of the names in the method's locals table, with all values set to `nil`. For UnboundMethod, it is unclear (to me) what the appropriate receiver for the binding would be, so perhaps `unbound.binding.receiver` should raise an exception. Alternatively (or additionally), something like `Method#defining_proc` and `UnboundMethod#defining_proc` might be added and return `nil` for `def` definitions and the proc for `define_method` definitions. This would be a useful tool when debugging from the console. As another example, it might be used to scan a code base for dynamically generated regexps which are only reachable via the enclosed local variables and test that they are all linear time (see https://github.com/ruby/net-imap/blob/92db350b24c388d2a2104f36cac9caa49a1044...). -- https://bugs.ruby-lang.org/