Follow the Ruby styleguide! pt. 1

It is important to follow the Ruby styleguide. Some styles are controversial, but the most really make sense. Following them makes coding Ruby in a team a lot easier.

1. Indentation

Use two spaces per indentation level (aka soft tabs). No hard tabs:

# bad - four spaces
def some_method
    do_something
end

# good
def some_method
  do_something
end

it is one line in the VIM configuration file .vimrc:

set shiftwidth=2

and you are done.

2. Spaces

Use spaces around operators, after commas, colons and semicolons, around { and before }. Whitespace might be (mostly) irrelevant to the Ruby interpreter, but its proper use is the key to writing easily readable code:

# bad - missing whitespaces
sum=1+2
hash = {one:1,two:2,three:3}
a,b = 1,2
[1,2,3].each {|number| puts number}
class FooError<StandardError;end

# good
sum = 1 + 2
hash = { one: 1, two: 2, three: 3 }
a, b = 1, 2
[1, 2, 3].each { |e| puts e }
class FooError < StandardError; end

There are some exceptions:

# the exponent operator:
result = 2 ** 2 # instead of 2**2

# embedded expressions:
"string#{expr}" # instead of "string#{ expr }"

# array brackets:
[1, 2, 3] # instead of [ 1, 2, 3 ]

# method call:
do_something(:special) # instead of do_something( :special )

# negation:
!number? # instead of ! number?

# ranges:
1..5 # instead of 1 .. 5

3. Limited line length

Limit lines to 80 characters.

4. Parameter alignment

Align the parameters of a method call if they span more than one line. When aligning parameters is not appropriate due to line-length constraints, single indent for the lines after the first is also acceptable:

# starting point (line is too long)
def send_mail(source)
  Mailer.deliver(to: 'bob@example.com', from: 'us@example.com', subject: 'Important message', body: source.text)
end

# bad (double indent)
def send_mail(source)
  Mailer.deliver(
      to: 'bob@example.com',
      from: 'us@example.com',
      subject: 'Important message',
      body: source.text)
end

# good (normal indent)
def send_mail(source)
  Mailer.deliver(
    to: 'bob@example.com',
    from: 'us@example.com',
    subject: 'Important message',
    body: source.text
  )
end

5. Large numeric literals

Add underscores to large numeric literals to improve their readability:

# bad - how many 0s are there?
num = 1000000

# good - much easier to parse for the human brain
num = 1_000_000

6. Method arguments definition

Use def with parentheses when there are arguments. Omit the parentheses when the method doesn't accept any arguments:

# bad
def do_somthing()
 # do something
end

# good
def do_somthing
 # do something
end

# bad
def do_somthing_with_arguments arg1, arg2
 # do something
end

# good
def do_somthing_with_arguments(arg1, arg2)
 # do something
end

7. Expression result

Leverage the fact that if and case are expressions which return a result:

# bad
if condition
  result = x
else
  result = y
end

# good
result =
  if condition
    x
  else
    y
  end

8. Assignment operators

Use shorthand self assignment operators whenever applicable

# bad
x = x + y
x = x**y
x = x / y
x = x && y

# good
x += y
x **= y
x /= y
x &&= y

9. Variable initialization

Use ||= to initialize variables only if they are not already initialized:

# bad
language = language ? language : 'Ruby'
language = 'Ruby' unless language

# good - set language to Ruby, only if it's nil or false
language ||= 'Ruby'

But beware using ||= for initializing boolean variables. Consider what would happen if the current value happened to be false. Take a look:

# bad - would set enabled to true even if it was false
enabled ||= true

# good
enabled = true if enabled.nil?

10. Hashes

Use the Ruby 1.9 hash literal syntax when your hash keys are symbols:

# bad
hash = { :one => 1, :two => 2, :three => 3 }

# good
hash = { one: 1, two: 2, three: 3 }

Further articles of interest:

• Follow the Ruby styleguide entirely! pt. 2

Supported by Ruby 2.1.1