# Le code

Réutiliser, ne rien dupliquer, écrire un code honnête, garder le dépôt lisible.


Ces règles valent pour toute personne ou tout agent qui écrit du code dans Ironlane. Une règle qu'un outil peut tenir est tenue par l'outil ; les autres se relisent.

:::note[En bref]
- **CODE-01** · [Réutilisez avant d'écrire](#code-01--réutilisez-avant-décrire)
- **CODE-02** · [Calculez une définition métier à un seul endroit, côté serveur](#code-02--calculez-une-définition-métier-à-un-seul-endroit-côté-serveur)
- **CODE-03** · [Prenez le vocabulaire dans une table](#code-03--prenez-le-vocabulaire-dans-une-table)
- **CODE-04** · [Faites venir un compteur et sa liste de la même définition](#code-04--faites-venir-un-compteur-et-sa-liste-de-la-même-définition)
- **CODE-05** · [Dites que vous ne savez pas](#code-05--dites-que-vous-ne-savez-pas)
- **CODE-06** · [Ne mettez rien en dur](#code-06--ne-mettez-rien-en-dur)
- **CODE-07** · [Écrivez un commentaire qui dit ce que le code ne dit pas](#code-07--écrivez-un-commentaire-qui-dit-ce-que-le-code-ne-dit-pas)
- **CODE-08** · [Faites un commit par chose](#code-08--faites-un-commit-par-chose)
- **CODE-09** · [Découpez un long fichier par déplacement pur](#code-09--découpez-un-long-fichier-par-déplacement-pur)
- **CODE-10** · [Supprimez le code mort](#code-10--supprimez-le-code-mort)
- **CODE-11** · [Générez les types de la base](#code-11--générez-les-types-de-la-base)
:::

## Réutiliser et ne rien dupliquer

### CODE-01 · Réutilisez avant d'écrire

:::tip[Règle]
Avant d'écrire un écran, un composant, une grille ou une fonction, cherchez celui qui fait déjà la chose et étendez-le.
:::

**Pourquoi.** Un double finit par diverger : le jour où l'un change, deux écrans montrent deux valeurs pour la même donnée.

<div class="avant-apres">

```ts title="À éviter"
// app/factures/liste.tsx
export function ListeFactures() {
  // tableau réécrit : tri, filtres, défilement
}
```

```ts title="À faire"
// app/factures/liste.tsx
import { TableauFiltrable } from "@/app/tableau-filtrable";

export function ListeFactures() {
  return <TableauFiltrable colonnes={colonnes} lignes={lignes} />;
}
```

</div>

<span class="puce outil">Outil</span> ESLint refuse de réécrire un composant partagé ; la détection des copies refuse un bloc de dix lignes écrit deux fois.

<span class="puce relecture">Relecture</span> Le compte rendu nomme ce qui a été réutilisé.

### CODE-02 · Calculez une définition métier à un seul endroit, côté serveur

:::tip[Règle]
« Facturé », « en retard », « actif » : une fonction côté serveur par notion. Les écrans lisent le résultat, ils ne le recalculent jamais.
:::

**Pourquoi.** Une règle écrite deux fois dit deux choses dès qu'on en change une.

<div class="avant-apres">

```ts title="À éviter"
// dans un écran
const enRetard = ligne.echeance < new Date() && ligne.statut !== "payee";
```

```ts title="À faire"
// l'écran lit ce que la base a calculé
const { en_retard } = ligne;
```

</div>

<span class="puce outil">Outil</span> Un contrôle compare deux écrans qui montrent le même chiffre.

<span class="puce relecture">Relecture</span> Ce qui trahit une copie : la même condition dans plusieurs fichiers.

### CODE-03 · Prenez le vocabulaire dans une table

:::tip[Règle]
Les états, statuts, rôles et natures vivent dans une table de référence (code, libellé, ordre, couleur). Ajouter une valeur, c'est ajouter une ligne.
:::

**Pourquoi.** Si ajouter une valeur demande de toucher cinq fichiers, le vocabulaire est écrit en dur.

<div class="avant-apres">

```ts title="À éviter"
const ETATS = ["a_demarrer", "en_cours", "a_facturer"]; // dans l'écran
```

```ts title="À faire"
const etats = await lireLesEtats(); // table etat_operation
```

</div>

<span class="puce relecture">Relecture</span> Une liste de codes ou de libellés écrite dans un écran est refusée.

### CODE-04 · Faites venir un compteur et sa liste de la même définition

:::tip[Règle]
Le serveur pose une marque sur chaque ligne ; le compteur la compte, la liste la filtre. Le chiffre d'une tuile égale le nombre de lignes de la liste qu'elle ouvre.
:::

<div class="avant-apres">

```ts title="À éviter"
const compteur = lignes.filter((l) => l.nouvelle).length;
const liste = lignes.filter((l) => l.date > hier); // une autre règle
```

```ts title="À faire"
const compteur = lignes.filter((l) => l.nouvelle).length;
const liste = lignes.filter((l) => l.nouvelle);
```

</div>

<span class="puce outil">Outil</span> Un contrôle compare les chiffres entre écrans.

<span class="puce relecture">Relecture</span> Le compteur touché égale la liste.

## Écrire un code honnête

### CODE-05 · Dites que vous ne savez pas

:::tip[Règle]
Quand le programme ne sait pas, il le dit, avec son motif. Pas de valeur par défaut silencieuse.
:::

**Pourquoi.** Une valeur par défaut est un mensonge silencieux : le problème reste caché jusqu'à ce qu'il coûte.

<div class="avant-apres">

```ts title="À éviter"
const delai = ligne.delai ?? 30; // personne ne saura qu'il manquait
```

```ts title="À faire"
if (ligne.delai == null) {
  return { erreur: "Le délai n'est pas renseigné pour cette ligne." };
}
```

</div>

<span class="puce outil">Outil</span> Les tests de refus rejouent les erreurs de la base.

<span class="puce relecture">Relecture</span> Une erreur se voit, avec son motif.

### CODE-06 · Ne mettez rien en dur

:::tip[Règle]
Ni adresse, ni clé, ni année, ni seuil. Un seuil est un réglage ; ce qui est propre à une société se règle ou s'importe.
:::

<div class="avant-apres">

```ts title="À éviter"
if (jours > 30) relancer(client);
```

```ts title="À faire"
if (jours > reglages.delaiDeRelance) relancer(client);
```

</div>

<span class="puce relecture">Relecture</span> Aucun outil ne voit un seuil écrit dans le code.

### CODE-07 · Écrivez un commentaire qui dit ce que le code ne dit pas

:::tip[Règle]
Un commentaire dit une contrainte qui ne se voit pas, un piège, un invariant, une unité ou un format. Il est court, au présent, sans date ni nom.
:::

**Pourquoi.** Le lecteur ne connaît ni l'histoire ni les gens du projet. L'histoire et la décision vont dans le message de commit.

<div class="avant-apres">

```ts title="À éviter"
// 12/10 : demandé par le bureau, passé à 30 jours
// incrémente i
i++;
```

```ts title="À faire"
// Les montants sont en centimes : le serveur ne reçoit jamais de décimales.
const centimes = Math.round(euros * 100);
```

</div>

<span class="puce outil">Outil</span> Une règle ESLint refuse date, nom de personne et pictogramme dans un commentaire ; un contrôle équivalent passe sur le SQL.

## Garder le dépôt lisible

### CODE-08 · Faites un commit par chose

:::tip[Règle]
Un commit fait une chose. Un déplacement de code, une passe de mise en forme et un correctif sont trois commits.
:::

**Pourquoi.** Un commit qui mélange tout ne se relit pas, ne se défait pas, et cache le vrai changement.

<div class="avant-apres">

```text title="À éviter"
fix(facturation): corrige le total, déplace trois fichiers, passe Prettier
```

```text title="À faire"
refactor(facturation): déplace le calcul du total dans lib/total.ts
style(facturation): passe Prettier sur lib/total.ts
fix(facturation): ne plus compter deux fois une facture partagée
```

</div>

<span class="puce outil">Outil</span> Un crochet vérifie la forme du message.

<span class="puce relecture">Relecture</span> « Un commit, une chose » n'est vérifié que par la relecture.

**Voir aussi.** [Les messages de commit](/regles/nommage-autres/)

### CODE-09 · Découpez un long fichier par déplacement pur

:::tip[Règle]
Un fichier de plus de sept cents lignes se découpe. On déplace sans changer une ligne, on compile, puis on améliore. Une fonction de plus de cinquante lignes se justifie ou se découpe.
:::

<div class="avant-apres">

```text title="À éviter"
commit 1 : découpe tableau.tsx ET corrige le tri
```

```text title="À faire"
commit 1 : déplace, sans changer une ligne, le tri dans tableau-tri.ts (compile, tests inchangés)
commit 2 : corrige le tri
```

</div>

<span class="puce outil">Outil</span> ESLint refuse un fichier de plus de sept cents lignes.

<span class="puce relecture">Relecture</span> La longueur d'une fonction se relit.

### CODE-10 · Supprimez le code mort

:::tip[Règle]
Ce que rien n'appelle disparaît. Ce qu'on retire de la base se garde dans un dossier à part.
:::

<div class="avant-apres">

```ts title="À éviter"
export function ancienCalcul() { /* gardé « au cas où » */ }
```

```ts title="À faire"
// supprimée ; son texte reste dans un dossier à part (sous-le-coude/) s'il vient de la base
```

</div>

<span class="puce outil">Outil</span> Knip refuse l'export que rien n'importe.

### CODE-11 · Générez les types de la base

:::tip[Règle]
Les types de la base ne s'écrivent jamais à la main. Après toute migration qui change une fonction, une table ou une colonne, on les régénère.
:::

**Pourquoi.** Une fonction renommée casse à la compilation, pas en production.

<div class="avant-apres">

```ts title="À éviter"
type Rappel = { id: string; echeance: string }; // copie écrite à la main
```

```ts title="À faire"
import type { Database } from "@/lib/base.types";
type Rappel = Database["public"]["Tables"]["rappel"]["Row"];
```

</div>

<span class="puce outil">Outil</span> La compilation (`tsc`) échoue si un type ne correspond plus.

## Référence rapide

| Règle | À retenir | Tenue par |
| --- | --- | --- |
| **CODE-01** | Réutilisez avant d'écrire | Outil, Relecture |
| **CODE-02** | Calculez une définition métier à un seul endroit, côté serveur | Outil, Relecture |
| **CODE-03** | Prenez le vocabulaire dans une table | Relecture |
| **CODE-04** | Faites venir un compteur et sa liste de la même définition | Outil, Relecture |
| **CODE-05** | Dites que vous ne savez pas | Outil, Relecture |
| **CODE-06** | Ne mettez rien en dur | Relecture |
| **CODE-07** | Écrivez un commentaire qui dit ce que le code ne dit pas | Outil |
| **CODE-08** | Faites un commit par chose | Outil, Relecture |
| **CODE-09** | Découpez un long fichier par déplacement pur | Outil, Relecture |
| **CODE-10** | Supprimez le code mort | Outil |
| **CODE-11** | Générez les types de la base | Outil |

## Voir aussi

- [Nommer les choses](/regles/nommage/)
- [Les lectures d'un écran](/regles/vitesse/)
