Exemple : corriger des offenses simples remontées par RuboCop

Le code de départ : un exemple fonctionnel mais imparfait

La meilleure façon de comprendre l'utilité de RuboCop est de le voir en action. Prenons un morceau de code Ruby qui fonctionne parfaitement, mais qui ne respecte pas plusieurs conventions de style. C'est une situation très courante, surtout quand on débute.

Imaginez que nous ayons le fichier `greeter.rb` suivant. Son objectif est de créer un message de salutation et d'afficher un avertissement si le nom est trop long.

# greeter.rb
class Greeter
  def say_hello( name )
    message = "Hello " + name

    if message.length > 20 then puts "C'est un nom plutôt long !" end

    return message
  end
end

A première vue, ce code semble correct. Il ne génère aucune erreur et fait ce qu'on lui demande. Cependant, un développeur Ruby expérimenté y verrait plusieurs points d'amélioration stylistique. Voyons ce qu'en pense notre expert automatisé, RuboCop.

Lancer l'analyse et déchiffrer le rapport de RuboCop

Plaçons-nous dans notre terminal à la racine du projet et lançons la commande que nous avons apprise précédemment :

bundle exec rubocop greeter.rb

RuboCop analyse le fichier et nous retourne un rapport détaillé. Ne soyez pas intimidé par la sortie ; chaque ligne est une instruction claire pour nous guider.

Inspecting 1 file
C

Offenses:

greeter.rb:2:17: C: Layout/SpaceInsideParens: Do not use space inside parentheses.
  def say_hello( name )
                ^^^^^^^
greeter.rb:3:15: C: Style/StringConcatenation: Prefer string interpolation to string concatenation.
    message = "Hello " + name
              ^^^^^^^^^^^^^^
greeter.rb:5:31: C: Style/Then: Do not use `then` for multi-line `if`.
    if message.length > 20 then puts "C'est un nom plutôt long !" end
                              ^^^^
greeter.rb:7:5: C: Style/RedundantReturn: Redundant `return` detected.
    return message
    ^^^^^^^

1 file inspected, 4 offenses detected

Ce rapport est notre feuille de route. Il a identifié 4 "offenses" (infractions aux règles de style) et nous indique précisément où elles se trouvent et comment les corriger.

La correction guidée : une offense après l'autre

Corrigeons maintenant chaque offense en suivant les recommandations de RuboCop. C'est un excellent exercice pour intégrer les bonnes pratiques.

1. `Layout/SpaceInsideParens` à la ligne 2 :

RuboCop nous dit de ne pas mettre d'espaces à l'intérieur des parenthèses d'une définition de méthode. C'est une règle de pure lisibilité. La correction est simple :

Avant : def say_hello( name )

Après : def say_hello(name)

2. `Style/StringConcatenation` à la ligne 3 :

L'opérateur `+` pour assembler des chaînes de caractères est fonctionnel, mais en Ruby, la manière idiomatique et souvent plus performante est d'utiliser l'interpolation avec `"#{...}"`. Cela rend aussi le code plus lisible quand plusieurs variables sont impliquées.

Avant : message = "Hello " + name

Après : message = "Hello #{name}"

3. `Style/Then` à la ligne 5 :

Le mot-clé `then` est généralement considéré comme superflu en Ruby moderne pour des conditions `if`. Il alourdit la ligne sans apporter de clarté.

Avant : if message.length > 20 then puts ... end

Après : if message.length > 20; puts ... end (notez que RuboCop pourrait même suggérer une autre forme, comme le modificateur `if`).

4. `Style/RedundantReturn` à la ligne 7 :

C'est une caractéristique clé de Ruby que nous avons déjà vue : la dernière expression évaluée dans une méthode est automatiquement sa valeur de retour. Le mot-clé `return` est donc inutile ici.

Avant : return message

Après : message

Le résultat final : un code propre, lisible et idiomatique

Après avoir appliqué toutes les corrections, notre fichier `greeter.rb` ressemble maintenant à ceci :

# greeter.rb
class Greeter
  def say_hello(name)
    message = "Hello #{name}"

    puts "C'est un nom plutôt long !" if message.length > 20

    message
  end
end

Notez que nous avons même amélioré la condition `if` en utilisant un modificateur en fin de ligne, une forme très courante et appréciée en Ruby pour sa concision. Le comportement du code est strictement identique à l'original, mais sa qualité s'est nettement améliorée. Il est plus court, plus clair et suit les conventions que n'importe quel autre développeur Ruby s'attendrait à voir.

Cet exercice démontre parfaitement le rôle de RuboCop : il n'est pas seulement un contrôleur, mais un véritable mentor qui vous enseigne activement à écrire un meilleur code.