Sintassi

• Usare :: solo per fare riferimento a costanti (incluse classi e moduli) e costruttori (come Array() o Nokogiri::HTML()).

• Evitare :: per le normali invocazioni di metodi.

• Evitare l'uso di :: per definire classi e moduli o per l'ereditarietà, poiché la ricerca delle costanti non viene effettuata nelle classi/moduli padre.

# bad
module A
  FOO = "test"
end

class A::B
  puts FOO  # this will raise a NameError exception
end

# good
module A
  FOO = "test"

  class B
    puts FOO
  end
end

• Usare def con le parentesi quando ci sono dei parametri.

• Omettere le parentesi quando il metodo non accetta alcun parametro.

• Evitare il metodo for.

• Evitare then.

• Preferite l'operatore ternario(?:) ai costrutti if/then/else/end.

# bad
result = if some_condition then something else something_else end

# good
result = some_condition ? something : something_else

• In un operatore ternario si usa un'espressione per ramo. Questo significa anche che gli operatori ternari non devono essere annidati. In questi casi, preferire i costrutti if/else.

• Evitate gli operatori ternari multilinea ?:; usate invece if/unless.

• Usare when x then ... per i casi a una riga.

• Usare ! invece di not.

• Preferire &&/|| a and/or.

• Preferire unless a if per le condizioni negative.

• Evitare l'uso di unless con else. Riscrivere le condizioni con il caso positivo per primo.

• Usare le parentesi intorno agli argomenti delle invocazioni di metodi.

• Omettere le parentesi quando non si forniscono argomenti. Omettere le parentesi anche quando l'invocazione è a riga singola e il metodo:

  • è una chiamata a un metodo di classe con ricevitore implicito.

  • è uno dei seguenti metodi:

    • require

    • require_relative

    • require_dependency

    • yield

    • raise

    • puts

  • è chiamato da uno "zucchero sintattico" (ad esempio: 1 + 1 chiama il metodo +, foo[bar] chiama il metodo [], ecc.)

# bad
class User
  include(Bar)
  has_many(:posts)
end

# good
class User
  include Bar
  has_many :posts
  SomeClass.some_method(:foo)
end

• Omettere le parentesi graffe esterne intorno a un hash implicito di opzioni.

• Utilizzare l'abbreviazione di invocazione proc quando il metodo invocato è l'unica operazione di un blocco.

# bad
names.map { |name| name.upcase }

# good
names.map(&:upcase)

• Preferire {...} a do...end per i blocchi a riga singola.

• Preferire do...end a {...} per i blocchi a più righe.

• Omettere return quando possibile.

• Omettere self quando possibile.

# bad
self.my_method

# good
my_method

# also good
attr_writer :name

def my_method
  self.name = "Rafael" # `self` is needed to reference the attribute writer.
end

• Avvolgere l'assegnazione tra parentesi quando si utilizza il suo valore di ritorno in un'istruzione condizionale.

if (value = /foo/.match(string))

• Usare ||= per inizializzare le variabili solo se non sono già inizializzate.

• Evitare di usare ||= per inizializzare variabili booleane.

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

# good
@enabled = true if @enabled.nil?

# also valid - defined? workaround
@enabled = true unless defined?(@enabled)

• Evitare gli spazi tra il nome di un metodo e la parentesi di apertura.

• Preferire la sintassi lambda literal a lambda.

# bad
l = lambda { |a, b| a + b }
l.call(1, 2)

l = lambda do |a, b|
  tmp = a * 7
  tmp * b / 50
end

# good
l = ->(a, b) { a + b }
l.call(1, 2)

l = ->(a, b) do
  tmp = a * 7
  tmp * b / 50
end

• Preferire proc a Proc.new.

• Prefissare i parametri di blocco non utilizzati con _. È accettabile anche usare solo _.

• Preferite una clausola di guardia quando potete affermare dati non validi. Una clausola di guardia è una dichiarazione condizionale all'inizio di una funzione che permette di uscire dal metodo il prima possibile.

# bad
def compute_thing(thing)
  if thing[:foo]
    update_with_bar(thing)
    if thing[:foo][:bar]
      partial_compute(thing)
    else
      re_compute(thing)
    end
  end
end

# good
def compute_thing(thing)
  return unless thing[:foo]
  update_with_bar(thing[:foo])
  return re_compute(thing) unless thing[:foo][:bar]
  partial_compute(thing)
end

• Preferire gli argomenti tramite parole chiave a quelli delle opzioni hash.

• Preferire map a collect, find a detect, select a find_all, size a length.

• Preferire Time a DateTime.

• Preferisce Time.iso8601(foo) invece di Time.parse(foo) quando si aspettano stringhe di tempo formattate ISO8601 come "2018-03-20T11:16:39-04:00".