Nuovo su Ruby e ROR e lo adoro ogni giorno, quindi ecco la mia domanda poiché non ho idea di come cercarlo su Google (e ho provato :))

abbiamo metodo

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

Quindi quello che sto cercando è un modo per ottenere tutti gli argomenti passati al metodo, senza elencarli tutti. Dato che questo è Ruby, presumo che ci sia un modo :) se fosse java li avrei semplicemente elencati :)

L'output sarebbe:

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

In Ruby 1.9.2 e versioni successive è possibile utilizzare il parametersmetodo su un metodo per ottenere l'elenco dei parametri per quel metodo. Ciò restituirà un elenco di coppie che indicano il nome del parametro e se è richiesto.

per esempio

Se fate

def foo(x, y)
end

poi

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

È possibile utilizzare la variabile speciale __method__per ottenere il nome del metodo corrente. Quindi all'interno di un metodo i nomi dei suoi parametri possono essere ottenuti tramite

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

È quindi possibile visualizzare il nome e il valore di ogni parametro con

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

Nota: poiché questa risposta è stata scritta originariamente, nelle versioni correnti di Ruby evalnon può più essere chiamata con un simbolo. Per risolvere questo problema, to_sè stato aggiunto un esplicito durante la creazione dell'elenco dei nomi dei parametri, ad esparameters.map { |arg| arg[1].to_s }

A partire da Ruby 2.1 puoi usare binding.local_variable_get per leggere il valore di qualsiasi variabile locale, inclusi i parametri del metodo (argomenti). Grazie a ciò puoi migliorare la risposta accettata da evitareil male eval.

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

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

Un modo per gestirlo è:

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

Questa è una domanda interessante. Forse usando local_variables ? Ma ci deve essere un modo diverso dall'usare eval. Sto cercando nel documento del 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

Questo può essere utile ...

  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

Puoi definire una costante come:

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

E usalo nel tuo codice come:

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

Prima di andare oltre, stai passando troppi argomenti in foo. Sembra che tutti questi argomenti siano attributi su un modello, giusto? Dovresti davvero passare l'oggetto stesso. Fine del discorso.

Potresti usare un argomento "splat". Spinge tutto in una matrice. Sarebbe come:

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

Se desideri modificare la firma del metodo, puoi fare qualcosa del genere:

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

In questo caso, interpolato argso opts.valuessarà un array, ma puoi farlo joinse su virgola. Saluti

Sembra che ciò che questa domanda sta cercando di ottenere possa essere fatto con una gemma che ho appena rilasciato, https://github.com/ericbeland/exception_details . Elencherà le variabili e le variabili locali (e le variabili di istanza) dalle eccezioni salvate. Potrebbe meritare un'occhiata...

Se hai bisogno di argomenti come hash e non vuoi inquinare il corpo del metodo con un'estrazione complicata dei parametri, usa questo:

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

Basta aggiungere questa classe al tuo progetto:

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 la funzione è all'interno di una classe, puoi fare qualcosa del genere:

class Car
  def drive(speed)
  end
end

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

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