runique 1.1.25

A Django-inspired web framework for Rust with ORM, templates, and comprehensive security middleware
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

// ═══════════════════════════════════════════════════════════════
// Surveille src/admin.rs avec notify et déclenche la génération
// à chaque modification.
//
// Flux :
//   Modification détectée
//     → parse src/admin.rs
//     → génère src/admin/generated.rs
//     → affiche le résultat (✅ ou ❌)
// ═══════════════════════════════════════════════════════════════

use notify::{Config, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
use std::fs;
use std::path::Path;
use std::sync::mpsc;
use std::time::{Duration, Instant};

use crate::admin::daemon::{generate, parse_admin_file};

/// Démarre la surveillance de admin_path et régénère à chaque modification
///
/// Bloquant — tourne jusqu'à Ctrl+C.
pub fn watch(admin_path: &Path) -> Result<(), String> {
    let (tx, rx) = mpsc::channel::<notify::Result<Event>>();

    let mut watcher: RecommendedWatcher = RecommendedWatcher::new(tx, Config::default())
        .map_err(|e| format!("Unable to create watcher: {}", e))?;

    watcher
        .watch(admin_path, RecursiveMode::NonRecursive)
        .map_err(|e| format!("Unable to watch {}: {}", admin_path.display(), e))?;

    // Génération initiale au démarrage
    run_generation(admin_path);

    // Debounce : évite plusieurs régénérations pour un seul save
    let mut last_event = Instant::now() - Duration::from_secs(10);
    let debounce = Duration::from_millis(300);

    for event in rx {
        match event {
            Ok(ev) => {
                if is_write_event(&ev) {
                    let now = Instant::now();
                    if now.duration_since(last_event) > debounce {
                        last_event = now;
                        println!("\n📝 Modification detected → regeneration...");
                        run_generation(admin_path);
                    }
                }
            }
            Err(e) => eprintln!("⚠️  Watcher error: {}", e),
        }
    }

    Ok(())
}

/// Vérifie si l'événement est une écriture/modification
fn is_write_event(event: &Event) -> bool {
    matches!(event.kind, EventKind::Modify(_) | EventKind::Create(_))
}

/// Parse + génère — affiche le résultat
fn run_generation(admin_path: &Path) {
    let source = match fs::read_to_string(admin_path) {
        Ok(s) => s,
        Err(e) => {
            eprintln!("❌ Unable to read: {}", e);
            return;
        }
    };

    match parse_admin_file(&source) {
        Err(e) => {
            eprintln!("❌ Parsing error: {}", e);
        }
        Ok(parsed) => {
            if parsed.resources.is_empty() {
                println!("⚠️  No resource in admin!{{}} — nothing to generate");
                return;
            }

            match generate(&parsed.resources) {
                Ok(()) => {
                    println!("✅ Daemon operational → src/admin/generated.rs");
                }
                Err(e) => {
                    eprintln!("❌ Generation error: {}", e);
                }
            }
        }
    }
}