• Prefer {...} over do...end for
      single-line blocks. Avoid using {...} for multi-line blocks (multiline
      chaining is always ugly). Always use do...end for “control flow” and
      “method definitions” (e.g. in Rakefiles and certain DSLs). Avoid do...end
      when chaining.[link]

      1.   names = ["Bozhidar", "Steve", "Sarah"]
      3.   # good
      4.   names.each { |name| puts name }
      6.   # bad
      7.   names.each do |name| puts name end
      9.   # good
      10.   names.each do |name|
      11.     puts name
      12.     puts 'yay!'
      13.   end
      15.   # bad
      16.   names.each { |name|
      17.     puts name
      18.     puts 'yay!'
      19.   }
      21.   # good
      22.   names.select { |name| name.start_with?("S") }.map { |name| name.upcase }
      24.   # bad
      25.   names.select do |name|
      26.     name.start_with?("S")
      27.   end.map { |name| name.upcase }

      Some will argue that multiline chaining would look okay with the use of
      {...}, but they should ask themselves if this code is really readable and
      whether the block’s content can be extracted into nifty methods.

    • Use shorthand self assignment operators
      whenever applicable.[link]

      1.   # bad
      2.   x = x + y
      3.   x = x * y
      4.   x = x**y
      5.   x = x / y
      7.   x = x && y
      9.   x += y
      10.   x *= y
      11.   x **= y
      12.   x /= y
      13.   x ||= y
      14.   x &&= y

    • Avoid semicolons except for in single line class
      definitions. When it is appropriate to use a semicolon, it should be
      directly adjacent to the statement it terminates: there should be no
      space before the semicolon.[link]

      1.   # bad
      2.   puts 'foobar'; # superfluous semicolon
      3.   puts 'foo'; puts 'bar' # two expressions on the same line
      5.   # good
      6.   puts 'foobar'
      8.   puts 'foo'
      9.   puts 'bar'
      11.   puts 'foo', 'bar' # this applies to puts in particular

    • Avoid return where not required.
      [link]

      1.   # bad
      2.   def some_method(some_arr)
      3.     return some_arr.size
      4.   end
      6.   # good
      7.   def some_method(some_arr)
      8.     some_arr.size
      9.   end

    • Don’t use the return value of = in
      conditionals[link]

      1.   # bad - shows intended use of assignment
      2.   if (v = array.grep(/foo/))
      3.     ...
      4.   end
      6.   # bad
      7.   if v = array.grep(/foo/)
      8.     ...
      10.   # good
      12.   if v
      13.     ...
      14.   end

    • Use ||= freely to initialize variables.
      [link]

      1.   # set name to Bozhidar, only if it's nil or false
      2.   name ||= 'Bozhidar'

    • Don’t use ||= to initialize boolean
      variables. (Consider what would happen if the current value happened to be
      false.)[link]

      1.   # bad
      2.   lambda.(x, y)
      4.   # good
      5.   lambda.call(x, y)

    • Avoid using Perl-style special variables (like
      $0-9, $, etc. ). They are quite cryptic and their use in anything but
      one-liner scripts is discouraged. Prefer long form versions such as
      $PROGRAM_NAME.[link]

    • When a method block takes only one
      argument, and the body consists solely of reading an attribute or calling
      one method with no arguments, use the &: shorthand.
      [link]

      1.   # bad
      2.   bluths.map { |bluth| bluth.occupation }
      3.   bluths.select { |bluth| bluth.blue_self? }
      5.   # good
      6.   bluths.map(&:occupation)
      7.   bluths.select(&:blue_self?)

    • Prefer some_method over self.some_method when
      calling a method on the current instance.[link]

      1.   # bad
      2.   def end_date
      3.     self.start_date + self.nights
      4.   end
      6.   # good
      7.   def end_date
      8.     start_date + nights
      9.   end

      In the following three common cases, self. is required by the language
      and is good to use:

      1. When defining a class method: def self.some_method.
      2. The left hand side when calling an assignment method, including assigning
        an attribute when self is an ActiveRecord model: self.guest = user.
      3. Referencing the current instance’s class: self.class.