Issue #15049 has been updated by zverok (Victor Shepelev). @duerst > Maybe I'm totally confused, but what's wrong with using `**keyword_arguments`? I am not the ticket's authors, but I understand the demand and met with the same requirement in some real-life projects. The most expressive example would be something like this: ```ruby def get(path:, accept: :json, headers: {}, **options) _request(method: :get, __all the rest of what have passed to this method___) end def post(path:, body:, accept: :json, headers: {}, **options) _request(method: :post, __all the rest of what have passed to this method___) end # ...and so on ``` Two of currently available options: 1. Accept just `**arguments`, and make checking what was mandatory, what should have default value and so on manually (also making auto-generated docs less expressive) 2. Accept everything as in my example, and then just do ``` _request(method: :get, path: path, body: body, accept: accept, headers: headers, **options) ``` ...that looks not DRY at all. So... ---------------------------------------- Feature #15049: [Request] Easily access all keyword arguments within a method https://bugs.ruby-lang.org/issues/15049#change-73845 * Author: bherms (Bradley Herman) * Status: Feedback * Priority: Normal * Assignee: * Target version: ---------------------------------------- As a developer, I'd like to leverage the power of keyword arguments (requirements, defaults, etc) and then be able to access a hash of all the arguments supplied. ~~~ ruby def foo(bar:, baz: 1, qux: 2...) post('/', body: kargs) end ~~~ This is currently possible by leveraging the RubyVM debug inspector and some meta programming to retrieve the binding and name of the calling method. There is a gem https://github.com/banister/binding_of_caller that abstracts away the logic of crawling through the frame bindings in the debug inspector to find the binding of the caller, but I feel like this functionality would be useful in Ruby. With the binding_of_caller gem, you can hack together a kargs method like so: ~~~ ruby def kargs method(caller_locations(1,1)[0].label).parameters.map do |(_type, name)| [name, binding.of_caller(2).local_variable_get(name)] end.to_h end ~~~ This gets the name of the calling method, pulls the local variables from the method, retrieves the binding, and then retrieves the variables from the binding. By exposing a simpler API to retrieve the caller binding, a `kargs` method could be added to Ruby fairly easily I would think. -- https://bugs.ruby-lang.org/ Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe> <http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>