Ruby: argumentos de las palabras clave: ¿puedes tratar todos los argumentos de palabras clave como un hash? ¿Cómo?

arguments keyword

Question

Tengo un método que se ve así:

def method(:name => nil, :color => nil, shoe_size => nil)
SomeOtherObject.some_other_method(THE HASH THAT THOSE KEYWORD ARGUMENTS WOULD MAKE)
end

Para cualquier llamada dada, puedo aceptar cualquier combinación de valores opcionales. Me gustan los argumentos nombrados, porque puedo mirar la firma del método para ver qué opciones están disponibles.

Lo que no sé es si hay un atajo para lo que he descrito en letras mayúsculas en el ejemplo de código anterior.

En los viejos tiempos, solía ser:

def method(opts)
SomeOtherObject.some_other_method(opts)
end

Elegante, simple, casi infiel.

¿Hay un atajo para esos argumentos clave o tengo que reconstituir mi hash de opciones en la llamada al método?

Answer 1

¡Por supuesto! Solo usa el operador double splat ( ** ).

def print_all(**keyword_arguments)
puts keyword_arguments
end
def mixed_signature(some: ''option'', **rest)
puts some
puts rest
end
print_all example: ''double splat (**)'', arbitrary: ''keyword arguments''
# {:example=>"double splat (**)", :arbitrary=>"keyword arguments"}
mixed_signature another: ''option''
# option
# {:another=>"option"}

Funciona igual que el splat normal ( * ), que se usa para recolectar parámetros. Incluso puede reenviar los argumentos de la palabra clave a otro método.

def forward_all(*arguments, **keyword_arguments, &block)
SomeOtherObject.some_other_method *arguments,
**keyword_arguments,
&block
end

Answer 2

¿Qué tal la sintaxis a continuación?

Para que funcione, trate los params como una palabra clave reservada en su método y coloque esta línea en la parte superior del método.

def method(:name => nil, :color => nil, shoe_size => nil)
params = params(binding)
# params now contains the hash you''re looking for
end
class Object
def params(parent_binding)
params = parent_binding.local_variables.reject { |s| s.to_s.start_with?(''_'') || s == :params }.map(&:to_sym)
return params.map { |p| [ p, parent_binding.local_variable_get(p) ] }.to_h
end
end

Answer 3

Me divertí un poco con esto, así que gracias por eso. Esto es lo que se me ocurrió:

describe "Argument Extraction Experiment" do
let(:experiment_class) do
Class.new do
def method_with_mixed_args(one, two = 2, three:, four: 4)
extract_args(binding)
end
def method_with_named_args(one:, two: 2, three: 3)
extract_named_args(binding)
end
def method_with_unnamed_args(one, two = 2, three = 3)
extract_unnamed_args(binding)
end
private
def extract_args(env, depth = 1)
caller_param_names = method(caller_locations(depth).first.label).parameters
caller_param_names.map do |(arg_type,arg_name)|
{ name: arg_name, value: eval(arg_name.to_s, env), type: arg_type }
end
end
def extract_named_args(env)
extract_args(env, 2).select {|arg| [:key, :keyreq].include?(arg[:type]) }
end
def extract_unnamed_args(env)
extract_args(env, 2).select {|arg| [:opt, :req].include?(arg[:type]) }
end
end
end
describe "#method_with_mixed_args" do
subject { experiment_class.new.method_with_mixed_args("uno", three: 3) }
it "should return a list of the args with values and types" do
expect(subject).to eq([
{ name: :one, value: "uno", type: :req },
{ name: :two, value: 2, type: :opt },
{ name: :three, value: 3, type: :keyreq },
{ name: :four, value: 4, type: :key }
])
end
end
describe "#method_with_named_args" do
subject { experiment_class.new.method_with_named_args(one: "one", two: 4) }
it "should return a list of the args with values and types" do
expect(subject).to eq([
{ name: :one, value: "one", type: :keyreq },
{ name: :two, value: 4, type: :key },
{ name: :three, value: 3, type: :key }
])
end
end
describe "#method_with_unnamed_args" do
subject { experiment_class.new.method_with_unnamed_args(2, 4, 6) }
it "should return a list of the args with values and types" do
expect(subject).to eq([
{ name: :one, value: 2, type: :req },
{ name: :two, value: 4, type: :opt },
{ name: :three, value: 6, type: :opt }
])
end
end
end

Elegí devolver una matriz, pero podría modificar esto fácilmente para devolver un hash en su lugar (por ejemplo, al no preocuparse por el tipo de argumento después de la detección inicial).

Answer 4

Sí, esto es posible, pero no es muy elegante.

Deberá usar el método de parameters , que devuelve una matriz de los parámetros del método y sus tipos (en este caso, solo tenemos argumentos de palabra clave).

def foo(one: 1, two: 2, three: 3)
method(__method__).parameters
end
#=> [[:key, :one], [:key, :two], [:key, :three]]

Sabiendo eso, hay varias formas de usar esa matriz para obtener un hash de todos los parámetros y sus valores proporcionados.

def foo(one: 1, two: 2, three: 3)
params = method(__method__).parameters.map(&:last)
opts = params.map { |p| [p, eval(p.to_s)] }.to_h
end
#=> {:one=>1, :two=>2, :three=>3}

Entonces tu ejemplo se vería

def method(name: nil, color: nil, shoe_size: nil)
opts = method(__method__).parameters.map(&:last).map { |p| [p, eval(p.to_s)] }.to_h
SomeOtherObject.some_other_method(opts)
end

Piense con cuidado acerca de usar esto. Es inteligente pero a costa de la legibilidad, a otros que leen tu código no les gustará.

Puedes hacerlo un poco más legible con un método de ayuda.

def params # Returns the parameters of the caller method.
caller_method = caller_locations(length=1).first.label
method(caller_method).parameters
end
def method(name: nil, color: nil, shoe_size: nil)
opts = params.map { |p| [p, eval(p.to_s)] }.to_h
SomeOtherObject.some_other_method(opts)
end

Actualización: Ruby 2.2 introdujo Binding#local_variables que se puede usar en lugar de los Method#parameters del Method#parameters . Tenga cuidado porque debe llamar a local_variables antes de definir cualquier variable local adicional dentro del método.

# Using Method#parameters
def foo(one: 1, two: 2, three: 3)
params = method(__method__).parameters.map(&:last)
opts = params.map { |p| [p, eval(p.to_s)] }.to_h
end
#=> {:one=>1, :two=>2, :three=>3}
# Using Binding#local_variables (Ruby 2.2+)
def bar(one: 1, two: 2, three: 3)
binding.local_variables.params.map { |p|
[p, binding.local_variable_get(p)]
}.to_h
end
#=> {:one=>1, :two=>2, :three=>3}