Novo em Ruby e ROR e amando isso a cada dia, então aqui está minha pergunta, já que não tenho ideia de como pesquisar no Google (e tentei :))

nós temos 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

Portanto, o que estou procurando é uma maneira de obter todos os argumentos passados ​​para o método, sem listar cada um. Como se trata de Ruby, presumo que haja uma maneira :) se fosse java, eu apenas os listaria :)

A saída seria:

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

No Ruby 1.9.2 e posterior, você pode usar o parametersmétodo em um método para obter a lista de parâmetros para aquele método. Isso retornará uma lista de pares indicando o nome do parâmetro e se ele é obrigatório.

por exemplo

Se você fizer

def foo(x, y)
end

então

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

Você pode usar a variável especial __method__para obter o nome do método atual. Portanto, dentro de um método, os nomes de seus parâmetros podem ser obtidos via

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

Você pode então exibir o nome e o valor de cada parâmetro com

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

Nota: uma vez que esta resposta foi escrita originalmente, nas versões atuais do Ruby evalnão pode mais ser chamada com um símbolo. Para resolver isso, um explícito to_sfoi adicionado ao construir a lista de nomes de parâmetros, ou seja,parameters.map { |arg| arg[1].to_s }

Desde o Ruby 2.1, você pode usar binding.local_variable_get para ler o valor de qualquer variável local, incluindo parâmetros de método (argumentos). Graças a isso, você pode melhorar a resposta aceita 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

Uma maneira de lidar com isso é:

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 é uma pergunta interessante. Talvez usando local_variables ? Mas deve haver uma maneira diferente de usar eval. Estou procurando no documento do kernel

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

Isso pode 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

Você pode definir uma 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"

E use-o em seu código como:

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

Antes de prosseguir, você está passando muitos argumentos para foo. Parece que todos esses argumentos são atributos de um modelo, correto? Você realmente deveria estar passando o próprio objeto. Fim do discurso.

Você pode usar um argumento "splat". Ele coloca tudo em uma série. Seria parecido com:

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

Se você quiser alterar a assinatura do método, poderá fazer algo assim:

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

Ou:

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

Neste caso, interpolado argsou opts.valuesserá uma matriz, mas você pode joinse na vírgula. Felicidades

Parece que o que essa pergunta está tentando fazer poderia ser feito com uma joia que acabei de lançar, https://github.com/ericbeland/exception_details . Ele irá listar variáveis ​​locais e valores (e variáveis ​​de instância) de exceções resgatadas. Pode valer a pena dar uma olhada...

Se você precisar de argumentos como um Hash e não quiser poluir o corpo do método com extração complicada de parâmetros, use isto:

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

Basta adicionar esta classe ao seu projeto:

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

Se a função estiver dentro de alguma classe, você pode fazer algo assim:

class Car
  def drive(speed)
  end
end

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

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