Nowy w Ruby i ROR i uwielbiam to każdego dnia, więc oto moje pytanie, ponieważ nie mam pojęcia, jak to wygooglować (i próbowałem :))

mamy metodę

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

Więc czego szukam sposobu, aby uzyskać wszystkie argumenty przekazane do metody, bez wymieniania każdego z nich. Ponieważ to jest Ruby, zakładam, że jest sposób :) Gdyby to była java, po prostu je wymieniłbym :)

Wynik byłby:

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

W Rubim 1.9.2 i nowszych wersjach możesz użyć tej parametersmetody na metodzie, aby uzyskać listę parametrów tej metody. To zwróci listę par wskazujących nazwę parametru i czy jest on wymagany.

na przykład

Jeśli zrobisz

def foo(x, y)
end

następnie

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

Możesz użyć specjalnej zmiennej, __method__aby uzyskać nazwę bieżącej metody. Tak więc w ramach metody nazwy jej parametrów można uzyskać za pośrednictwem

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

Następnie możesz wyświetlić nazwę i wartość każdego parametru za pomocą

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

Uwaga: ponieważ ta odpowiedź została pierwotnie napisana, w obecnych wersjach Rubiego evalnie można już wywołać za pomocą symbolu. Aby rozwiązać ten problem, to_spodczas budowania listy nazw parametrów, tjparameters.map { |arg| arg[1].to_s }

Od Ruby 2.1 możesz używać binding.local_variable_get do odczytywania wartości dowolnej zmiennej lokalnej, w tym parametrów metody (argumentów). Dzięki temu możesz poprawić zaakceptowaną odpowiedź, której chcesz uniknąćzło eval.

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

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

Jednym ze sposobów rozwiązania tego problemu jest:

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

To ciekawe pytanie. Może używając local_variables ? Ale musi być inny sposób niż użycie eval. Szukam w dokumencie 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

To może być pomocne ...

  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

Możesz zdefiniować stałą, taką jak:

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

I użyj go w swoim kodzie, na przykład:

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

Zanim przejdę dalej, przekazujesz zbyt wiele argumentów do foo. Wygląda na to, że wszystkie te argumenty są atrybutami modelu, prawda? Naprawdę powinieneś mijać sam obiekt. Koniec wypowiedzi.

Możesz użyć argumentu „splat”. Wsuwa wszystko do tablicy. Wyglądałoby to tak:

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

Jeśli chcesz zmienić sygnaturę metody, możesz zrobić coś takiego:

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

Lub:

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

W tym przypadku interpolowana argslub opts.valuesbędzie tablicą, ale możesz, joinjeśli na przecinku. Twoje zdrowie

Wygląda na to, że to, co próbuje osiągnąć to pytanie, można zrobić za pomocą klejnotu, który właśnie wydałem, https://github.com/ericbeland/exception_details . Wyświetli zmienne lokalne i wartości (i zmienne instancji) z uratowanych wyjątków. Może warto rzucić na to okiem...

Jeśli potrzebujesz argumentów jako skrótu i ​​nie chcesz zanieczyszczać treści metody trudnym wyodrębnianiem parametrów, użyj tego:

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

Po prostu dodaj tę klasę do swojego projektu:

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

Jeśli funkcja znajduje się wewnątrz jakiejś klasy, możesz zrobić coś takiego:

class Car
  def drive(speed)
  end
end

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

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