Sprint 0 — industrialisation : CI, tracing, tests xdg-shell, GPLv3

5 livrables d'industrialisation posés avant la phase 13 (client réel).

- .gitlab-ci.yml : pipeline minimal (fmt-check + tests core +
  tests frontend nightly). Pas de cross-compile Redox dans le MVP.
- rustfmt.toml + fmt.sh : config formatter racine + boucle sur les 23
  crates ; fmt sweep appliqué (d'où les diffs cosmétiques).
- tracing dans wayland-frontend : 22 println/eprintln remplacés par
  debug/info/warn/error selon sévérité. Préfixe "[frontend]"
  supprimé (le target tracing le fournit).
- tracing-subscriber dans le compositor : TeeWriter écrit sur
  stdout + /scheme/debug, filtre via RUST_LOG (défaut info).
  DebugSink/dlog supprimés.
- 15 tests unitaires xdg-shell après extraction de 2 helpers libres
  (clamp_to_min_max + should_throttle_configure). Couvre
  compute_resize_geom, contraintes min/max et throttling configure.
- LICENSE (GPLv3 texte officiel FSF) + .editorconfig.

Total tests : 27 → 42 automatisés (compositor-core + frontend).

Leyoda 2026 – GPLv3

crates/redox-wl-compositor-core/src/lib.rs

@@ -187,9 +187,7 @@ impl SurfaceRegistry {
     /// C'est l'ordre de composition : on peint d'abord le fond, puis
     /// chaque surface au-dessus.
     pub fn iter_z_order_back_to_front(&self) -> impl Iterator<Item = &Surface> {
-        self.z_order
-            .iter()
-            .filter_map(|id| self.surfaces.get(id))
+        self.z_order.iter().filter_map(|id| self.surfaces.get(id))
     }
 
     /// Itérer les surfaces dans l'ordre Z, du premier plan vers le fond.
@@ -248,11 +246,7 @@ impl SurfaceRegistry {
 
     /// Convenience : modifie le pending state via une closure.
     /// Pratique pour `set_position`, `set_buffer` etc. dans les tests.
-    pub fn modify_pending<F: FnOnce(&mut SurfaceState)>(
-        &mut self,
-        id: SurfaceId,
-        f: F,
-    ) -> bool {
+    pub fn modify_pending<F: FnOnce(&mut SurfaceState)>(&mut self, id: SurfaceId, f: F) -> bool {
         match self.surfaces.get_mut(&id) {
             Some(s) => {
                 f(&mut s.pending);
@@ -385,10 +379,7 @@ mod tests {
         let a = r.create();
         let b = r.create();
         let c = r.create();
-        let order: Vec<SurfaceId> = r
-            .iter_z_order_back_to_front()
-            .map(|s| s.id())
-            .collect();
+        let order: Vec<SurfaceId> = r.iter_z_order_back_to_front().map(|s| s.id()).collect();
         assert_eq!(order, vec![a, b, c]); // a au fond, c devant
     }
 
@@ -399,10 +390,7 @@ mod tests {
         let b = r.create();
         let c = r.create();
         r.raise(a); // a passe au-dessus
-        let order: Vec<SurfaceId> = r
-            .iter_z_order_back_to_front()
-            .map(|s| s.id())
-            .collect();
+        let order: Vec<SurfaceId> = r.iter_z_order_back_to_front().map(|s| s.id()).collect();
         assert_eq!(order, vec![b, c, a]);
     }
 
@@ -413,10 +401,7 @@ mod tests {
         let b = r.create();
         r.raise(b);
         r.raise(b); // déjà au top
-        let order: Vec<SurfaceId> = r
-            .iter_z_order_back_to_front()
-            .map(|s| s.id())
-            .collect();
+        let order: Vec<SurfaceId> = r.iter_z_order_back_to_front().map(|s| s.id()).collect();
         assert_eq!(order, vec![a, b]);
     }
 
@@ -426,10 +411,7 @@ mod tests {
         let a = r.create();
         let bogus = SurfaceId(999);
         r.raise(bogus); // ne doit pas paniquer ni modifier z_order
-        let order: Vec<SurfaceId> = r
-            .iter_z_order_back_to_front()
-            .map(|s| s.id())
-            .collect();
+        let order: Vec<SurfaceId> = r.iter_z_order_back_to_front().map(|s| s.id()).collect();
         assert_eq!(order, vec![a]);
     }
 
@@ -495,10 +477,7 @@ mod tests {
         let b = r.create();
         let c = r.create();
         r.destroy(b);
-        let ids: Vec<SurfaceId> = r
-            .iter_z_order_back_to_front()
-            .map(|s| s.id())
-            .collect();
+        let ids: Vec<SurfaceId> = r.iter_z_order_back_to_front().map(|s| s.id()).collect();
         assert_eq!(ids, vec![a, c]);
     }
 
@@ -748,10 +727,7 @@ mod tests {
         let a = r.create();
         let b = r.create();
         let c = r.create();
-        let order: Vec<SurfaceId> = r
-            .iter_z_order_front_to_back()
-            .map(|s| s.id())
-            .collect();
+        let order: Vec<SurfaceId> = r.iter_z_order_front_to_back().map(|s| s.id()).collect();
         assert_eq!(order, vec![c, b, a]);
     }
 
@@ -845,18 +821,12 @@ mod tests {
         r.commit(fg2);
 
         // L'ordre attendu pour la composition : bg → fg1 → fg2 (vert au-dessus)
-        let ids: Vec<SurfaceId> = r
-            .iter_z_order_back_to_front()
-            .map(|s| s.id())
-            .collect();
+        let ids: Vec<SurfaceId> = r.iter_z_order_back_to_front().map(|s| s.id()).collect();
         assert_eq!(ids, vec![bg, fg1, fg2]);
 
         // Click sur fg1 → raise → fg1 passe au-dessus
         r.raise(fg1);
-        let ids: Vec<SurfaceId> = r
-            .iter_z_order_back_to_front()
-            .map(|s| s.id())
-            .collect();
+        let ids: Vec<SurfaceId> = r.iter_z_order_back_to_front().map(|s| s.id()).collect();
         assert_eq!(ids, vec![bg, fg2, fg1]);
 
         // Vérifie que le current state est bien défini après les commits