Nuevo en Ruby y ROR y me encanta cada día, así que aquí está mi pregunta ya que no tengo idea de cómo buscarlo en Google (y lo he intentado :))

tenemos método

def foo(first_name, last_name, age, sex, is_plumber)
    # some code
    # error happens here
    logger.error "Method has failed, here are all method arguments #{SOMETHING}"    
end

Entonces, lo que estoy buscando es la forma de pasar todos los argumentos al método, sin enumerar cada uno. Como esto es Ruby, supongo que hay una manera :) si fuera Java, simplemente los enumeraría :)

La salida sería:

Method has failed, here are all method arguments {"Mario", "Super", 40, true, true}

En Ruby 1.9.2 y versiones posteriores, puede usar el parametersmétodo en un método para obtener la lista de parámetros para ese método. Esto devolverá una lista de pares indicando el nombre del parámetro y si es necesario.

p.ej

Si lo haces

def foo(x, y)
end

luego

method(:foo).parameters # => [[:req, :x], [:req, :y]]

Puede utilizar la variable especial __method__para obtener el nombre del método actual. Entonces, dentro de un método, los nombres de sus parámetros se pueden obtener a través de

args = method(__method__).parameters.map { |arg| arg[1].to_s }

A continuación, puede mostrar el nombre y el valor de cada parámetro con

logger.error "Method failed with " + args.map { |arg| "#{arg} = #{eval arg}" }.join(', ')

Nota: dado que esta respuesta se escribió originalmente, en las versiones actuales de Ruby evalya no se puede llamar con un símbolo. Para abordar esto, se to_sha agregado un explícito al construir la lista de nombres de parámetros, es decirparameters.map { |arg| arg[1].to_s }

Desde Ruby 2.1, puede usar binding.local_variable_get para leer el valor de cualquier variable local, incluidos los parámetros del método (argumentos). Gracias a eso puedes mejorar la respuesta aceptada para evitarmal eval.

def foo(x, y)
  method(__method__).parameters.map do |_, name|
    binding.local_variable_get(name)
  end
end

foo(1, 2)  # => 1, 2

Una forma de manejar esto es:

def foo(*args)
    first_name, last_name, age, sex, is_plumber = *args
    # some code
    # error happens here
    logger.error "Method has failed, here are all method arguments #{args.inspect}"    
end

Esta es una pregunta interesante. ¿Quizás usando local_variables ? Pero debe haber una forma distinta de usar eval. Estoy buscando en Kernel doc

class Test
  def method(first, last)
    local_variables.each do |var|
      puts eval var.to_s
    end
  end
end

Test.new().method("aaa", 1) # outputs "aaa", 1

Esto puede ser útil ...

  def foo(x, y)
    args(binding)
  end

  def args(callers_binding)
    callers_name = caller[0][/`.*'/][1..-2]
    parameters = method(callers_name).parameters
    parameters.map { |_, arg_name|
      callers_binding.local_variable_get(arg_name)
    }    
  end

Puede definir una constante como:

ARGS_TO_HASH = "method(__method__).parameters.map { |arg| arg[1].to_s }.map { |arg| { arg.to_sym => eval(arg) } }.reduce Hash.new, :merge"

Y utilícelo en su código como:

args = eval(ARGS_TO_HASH)
another_method_that_takes_the_same_arguments(**args)

Antes de continuar, estás pasando demasiados argumentos a foo. Parece que todos esos argumentos son atributos de un modelo, ¿correcto? Realmente debería pasar el objeto en sí. Fin del discurso.

Podría utilizar un argumento "splat". Empuja todo en una matriz. Se vería así:

def foo(*bar)
  ...
  log.error "Error with arguments #{bar.joins(', ')}"
end

Si cambia la firma del método, puede hacer algo como esto:

def foo(*args)
  # some code
  # error happens here
  logger.error "Method has failed, here are all method arguments #{args}"    
end

O:

def foo(opts={})
  # some code
  # error happens here
  logger.error "Method has failed, here are all method arguments #{opts.values}"    
end

En este caso, interpolado args o opts.valuesserá una matriz, pero puede joinhacerlo si está en coma. Salud

Parece que lo que esta pregunta está tratando de lograr podría hacerse con una gema que acabo de lanzar, https://github.com/ericbeland/exception_details . Enumerará las variables y valores locales (y las variables de instancia) de las excepciones rescatadas. Vale la pena echarle un vistazo ...

Si necesita argumentos como Hash y no desea contaminar el cuerpo del método con una extracción complicada de parámetros, use esto:

def mymethod(firstarg, kw_arg1:, kw_arg2: :default)
  args = MethodArguments.(binding) # All arguments are in `args` hash now
  ...
end

Simplemente agregue esta clase a su proyecto:

class MethodArguments
  def self.call(ext_binding)
    raise ArgumentError, "Binding expected, #{ext_binding.class.name} given" unless ext_binding.is_a?(Binding)
    method_name = ext_binding.eval("__method__")
    ext_binding.receiver.method(method_name).parameters.map do |_, name|
      [name, ext_binding.local_variable_get(name)]
    end.to_h
  end
end

Si la función está dentro de alguna clase, puede hacer algo como esto:

class Car
  def drive(speed)
  end
end

car = Car.new
method = car.method(:drive)

p method.parameters #=> [[:req, :speed]]