Methods

Method definitions

  • Use def with parentheses when there are
    parameters. Omit the parentheses when the method doesn’t accept any
    parameters.[link]

    1.    def some_method
    2.      # body omitted
    3.    end
    5.    def some_method_with_parameters(arg1, arg2)
    6.      # body omitted
    7.    end

  • Do not use default positional arguments.
    Use keyword arguments (if available - in Ruby 2.0 or later) or an options
    hash instead.[link]

    1.   # bad
    2.   def obliterate(things, gently = true, except = [], at = Time.now)
    3.     ...
    4.   end
    6.   # good
    7.   def obliterate(things, gently: true, except: [], at: Time.now)
    8.     ...
    9.   end
    11.   # good
    12.   def obliterate(things, options = {})
    13.     options = {
    14.       :gently => true, # obliterate with soft-delete
    15.       :except => [], # skip obliterating these things
    16.       :at => Time.now, # don't obliterate them until later
    17.     }.merge(options)
    19.     ...
    20.   end

  • Avoid single-line methods. Although
    they are somewhat popular in the wild, there are a few peculiarities about
    their definition syntax that make their use undesirable.
    [link]

    1.   # bad
    2.   def too_much; something; something_else; end
    4.   # good
    5.   def some_method
    6.     # body
    7.   end

Method calls

Use parentheses for a method call:

  • If the method returns a value.
    [link]

    1.   # bad
    2.   @current_user = User.find_by_id 1964192
    4.   # good
    5.   @current_user = User.find_by_id(1964192)

  • If the first argument to the method uses
    parentheses.[link]

    1.   # bad
    2.   put! (x + y) % len, value
    4.   # good
    5.   put!((x + y) % len, value)

  • Never put a space between a method name and
    the opening parenthesis.[link]

    1.   # bad
    2.   f (3 + 2) + 1
    4.   # good
    5.   f(3 + 2) + 1

  • Omit parentheses for a method call if the
    method accepts no arguments.[link]

    1.   # bad
    2.   nil?()
    4.   # good
    5.   nil?

  • If the method doesn’t return a value (or we
    don’t care about the return), parentheses are optional. (Especially if the
    arguments overflow to multiple lines, parentheses may add readability.)
    [link]

    1.   # okay
    2.   render(:partial => 'foo')
    4.   # okay
    5.   render :partial => 'foo'

In either case:

  • If a method accepts an options hash as the
    last argument, do not use { } during invocation.
    [link]

    1.   # bad
    2.   get '/v1/reservations', { :id => 54875 }
    4.   # good
    5.   get '/v1/reservations', :id => 54875