# Référence : le numéro de version

> Description neutre de l'origine de la version que Turbo Go annonce, et de ce que produit chaque façon de le construire.

## D'où vient le numéro

Trois sources, consultées dans cet ordre. La première qui répond l'emporte.

| Ordre | Source | Renseignée par |
| --- | --- | --- |
| 1 | Estampilles de l'éditeur de liens | `make build`, `make install`, `scripts/install.sh` |
| 2 | Informations de build de Go | L'outil Go, automatiquement |
| 3 | `unknown` | Rien — la valeur annoncée quand aucune source n'a pu nommer le build |

Il n'y a **aucune constante de version dans les sources**. Un numéro écrit dans un fichier `.go` doit être modifié dans le cadre d'une release, et devient faux dès que quelqu'un l'oublie.

## Estampilles de l'éditeur de liens

Trois variables de paquet dans le paquet `version` de turbo-core, renseignées par `-ldflags -X`.

| Variable | Remplie depuis | Exemple |
| --- | --- | --- |
| `stamp` | `git describe --tags --dirty` | `v0.1.0-14-g88a4c38` |
| `commit` | `git rev-parse --short HEAD` | `88a4c38` |
| `built` | `date -u +%Y-%m-%dT%H:%M:%SZ` | `2026-08-31T18:04:05Z` |

```sh
go build -ldflags "\
  -X 'rickub.com/turbo-editors/turbo-core/version.stamp=v0.2.0' \
  -X 'rickub.com/turbo-editors/turbo-core/version.commit=88a4c38' \
  -X 'rickub.com/turbo-editors/turbo-core/version.built=2026-08-31T18:04:05Z'" .
```

Un `v` initial est retiré à l'affichage : le tag est `v0.2.0`, la boîte About affiche `0.2.0`.

## Informations de build de Go

Lues via `runtime/debug.ReadBuildInfo()` quand rien n'a été estampillé.

| Champ lu | Sert à |
| --- | --- |
| `Main.Version` | Le numéro, sauf s'il est vide, `(devel)`, ou une pseudo-version |
| `vcs.revision` | Le commit, abrégé à sept caractères |
| `vcs.modified` | L'ajout ou non du suffixe `-dirty` |

`vcs.time` n'est **pas** utilisé. Il enregistre la date du commit, pas celle de l'édition de liens ; l'annoncer comme date de build serait faux sur tout binaire construit après son propre commit.

Une **pseudo-version** — `v0.1.1-0.20260831165958-88a4c3859bf3` — est la façon dont l'outil Go nomme un commit qu'aucun tag ne nomme. Elle est rapportée comme `devel`, et non affichée telle quelle : son `0.1.1` est un correctif qui n'existe pas.

## Ce qu'annonce chaque build

| Construit par | Numéro | Commit | Date |
| --- | --- | --- | --- |
| `make build`, `make install`, `scripts/install.sh` | `0.1.0-14-g88a4c38` | oui | oui |
| Les mêmes, sur un commit tagué | `0.2.0` | oui | oui |
| Les mêmes, avec des modifications non validées | `0.1.0-14-g88a4c38-dirty` | oui | oui |
| `go install rickub.com/turbo-editors/turbo-go@v0.2.0` | `0.2.0` | non | non |
| `go build .` dans un dépôt cloné | `devel` | oui | non |
| `go build .` dans un dépôt cloné avec des modifications | `devel-dirty` | oui | non |
| `go run .` | `unknown` | non | non |
| Un dossier sans git, et sans estampille | `unknown` | non | non |

Seules les lignes estampillées peuvent annoncer un tag : le système de build de Go ne lit pas les tags git.

## Vérifié au moment du build

Une estampille d'édition de liens est une chaîne de caractères, et une mauvaise n'est pas une erreur. Un `-X` qui nomme un symbole inexistant s'édite sans se plaindre et n'estampille rien ; le binaire retombe alors sur les informations de build de Go et annonce une version que le build n'a jamais voulue — souvent `devel`, sur un binaire attaché à une release. Rien d'autre que l'exécution du binaire ne le détecte : chaque build qui en produit un l'exécute donc.

C'est `scripts/check-version.sh` qui s'en charge.

| Appelé par | Sur | Un échec fait échouer |
| --- | --- | --- |
| `make build` | `bin/turbo-go`, avec `$(VERSION)` et `$(COMMIT)` | le build |
| `scripts/install.sh` | le binaire en attente, **avant** son installation | l'installation, en laissant intact celui qui est déjà là |
| `02-build-releases.sh` | le seul artefact en attente que cette machine sait exécuter, avec le tag | la construction de la release |

```sh
scripts/check-version.sh bin/turbo-go v0.2.0 88a4c38   # un build estampillé
scripts/check-version.sh bin/turbo-go                  # rien à attendre
```

| Arguments | Réussit si |
| --- | --- |
| binaire, version, commit | le numéro annoncé est **égal** à la version privée de son `v` initial, et le commit apparaît dans la sortie |
| binaire, version | le numéro lui est égal |
| binaire | le numéro est autre chose qu'`unknown` |

La comparaison de version est une égalité, pas une recherche. `0.2.0` est une sous-chaîne de `10.2.0`, et d'une empreinte de commit qui le contiendrait par hasard ; une estampille presque juste est précisément ce que cette vérification existe pour attraper.

| Code de sortie | Signification |
| --- | --- |
| `0` | Le binaire annonce ce que le build voulait. La ligne qu'il a affichée est réémise. |
| `1` | Il ne s'exécute pas, n'est pas là, ou annonce autre chose. |
| `2` | Aucun binaire n'a été nommé. |

## Où il s'affiche

### `-version`

Une ligne, portant chaque élément connu.

```
Turbo Go 0.2.0 (88a4c38, built 2026-08-31T18:04:05Z)
Turbo Go 0.2.0 (88a4c38)
Turbo Go 0.2.0
```

### Help ▸ About

Une ligne par fait connu. Un fait que le build n'a pas enregistré n'a **pas de ligne**, plutôt qu'une ligne vide.

```
Turbo Go 0.2.0

A Turbo C-style editor for Go,
written in Go.

Commit: 88a4c38
Built:  2026-08-31 18:04 UTC
Theme:  Turbo Classic
```

`Built` est rendu en UTC sous la forme `AAAA-MM-JJ HH:MM UTC`. Une estampille qui n'est pas un RFC 3339 valide est affichée exactement telle qu'elle a été donnée, plutôt que supprimée.

### `make version`

Affiche ce que ce dépôt estampillerait, sans construire.

```
$ make version
v0.1.0-14-g88a4c38 (88a4c38)
```

### `make ldflags`

Affiche les options d'édition de liens qu'utilise un build estampillé, pour qu'un script puisse les réutiliser au lieu de répéter les chemins `-X`.

```
$ make ldflags
-X 'rickub.com/turbo-editors/turbo-core/version.stamp=v0.2.0' -X '….commit=7f8b36a' -X '….built=2026-08-31T19:02:03Z'
```

`02-build-releases.sh` les lit pour ses compilations croisées, en surchargeant la version par le tag qu'il publie — `make ldflags VERSION=v0.2.0` — pour que les binaires disent ce que dit la release plutôt que ce que dit `git describe`. Un binaire compilé sans elles annonce `devel`, quoi que dise la release à laquelle il est attaché.

## Voir aussi

- Faire une release pour que le numéro soit juste : [Comment faire une release](../how-to/make-a-release.md)
- Ce à quoi `-version` ne sert **pas** : il est écrit pour un humain. Un script qui a besoin du numéro doit comparer avec `grep -F`, ou interroger git, plutôt que d'en extraire un champ.
- Pourquoi il n'y a pas de constante de version : [Décisions de conception](../explanation/design-decisions.md#la-version-est-une-propriété-du-build-pas-des-sources)
- L'option `-version` parmi les autres : [Ligne de commande](cli.md)