rustdiff 0.2.1

Semantic JSON & XML diff tool with a native GTK4 desktop UI
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

//! Punto de entrada de la aplicación GTK.
//!
//! Configura `adw::Application`, maneja argumentos CLI,
//! y conecta la señal `activate` para construir la ventana principal.

use gtk::prelude::*;
use gtk4 as gtk;
use libadwaita as adw;

use crate::ui::main_window::MainWindow;

/// ID de la aplicación en formato reverse-DNS (requerido por Freedesktop/GNOME).
///
/// Los builds de desarrollo usan el sufijo `.Devel` para no colisionar con
/// una instancia instalada (Flatpak/.deb): GApplication es de instancia
/// única por ID, y sin esto `cargo run` le reenviaría los archivos a la
/// app instalada en vez de arrancar el binario recién compilado.
const APP_ID: &str = if cfg!(debug_assertions) {
    "com.digitalgex.RustDiff.Devel"
} else {
    "com.digitalgex.RustDiff"
};

/// Construye y ejecuta la aplicación GTK.
///
/// La app declara `HANDLES_OPEN`, por lo que GTK enruta cualquier archivo
/// recibido (CLI `rustdiff a.json b.json`, o "Abrir con RustDiff" desde el
/// gestor de archivos) a la señal `open` en lugar de `activate`.
pub fn run() -> gtk::glib::ExitCode {
    // Inicializar logging estructurado
    tracing_subscriber::fmt()
        .with_env_filter(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("warn")),
        )
        .init();

    // Seleccionar el idioma activo en funcion del locale del sistema.
    setup_locale();

    let app = adw::Application::builder()
        .application_id(APP_ID)
        .flags(gtk::gio::ApplicationFlags::HANDLES_OPEN)
        .build();

    app.connect_activate(build_ui);
    app.connect_open(open_files);

    // Ejecutar la aplicación pasando los argumentos del sistema
    app.run()
}

/// Determina el idioma activo. Prioridad:
///   1. `Settings::language` si es `"en"` o `"es"` (preferencia explicita del usuario).
///   2. `LC_ALL` / `LC_MESSAGES` / `LANG` del entorno.
///   3. Fallback a ingles.
///
/// El valor se propaga a `rust_i18n` para que `t!()` resuelva contra el
/// idioma correcto en toda la aplicacion.
fn setup_locale() {
    use crate::settings::{SUPPORTED_LANGUAGES, Settings};

    let settings = Settings::load();

    let code = if SUPPORTED_LANGUAGES.contains(&settings.language.as_str()) {
        settings.language.clone()
    } else {
        // `"auto"` o cualquier valor no soportado -> detectar del entorno
        ["LC_ALL", "LC_MESSAGES", "LANG"]
            .iter()
            .filter_map(|var| std::env::var(var).ok())
            .find(|v| !v.is_empty())
            .and_then(|raw| {
                // "es_ES.UTF-8" -> "es"
                raw.split(['.', '@'])
                    .next()
                    .and_then(|s| s.split('_').next())
                    .map(|s| s.to_lowercase())
            })
            .filter(|code| SUPPORTED_LANGUAGES.contains(&code.as_str()))
            .unwrap_or_else(|| "en".into())
    };

    tracing::info!("Idioma activo: {code} (pref={})", settings.language);
    rust_i18n::set_locale(&code);
}

/// Callback principal: se invoca cuando la aplicación se activa sin archivos.
///
/// Construye la ventana principal (pantalla de bienvenida) y la presenta.
fn build_ui(app: &adw::Application) {
    let window = MainWindow::new(app);
    window.present();
}

/// Callback de la señal `open`: se invoca cuando la app recibe archivos,
/// ya sea por CLI (`rustdiff a.json [b.json]`) o desde el gestor de
/// archivos ("Abrir con RustDiff").
///
/// - Un archivo  → se carga en el editor izquierdo (modo documento único).
/// - Dos o más   → los dos primeros se cargan en izquierdo/derecho con
///   el modo comparación activado.
fn open_files(app: &adw::Application, files: &[gtk::gio::File], _hint: &str) {
    let window = MainWindow::new(app);

    let paths: Vec<String> = files
        .iter()
        .filter_map(|f| f.path())
        .map(|p| p.to_string_lossy().into_owned())
        .collect();

    match paths.as_slice() {
        [] => {}
        [single] => {
            tracing::info!("Abriendo archivo único: {single}");
            window.load_single_file(single);
        }
        [left, right, ..] => {
            tracing::info!("Cargando archivos: {left} y {right}");
            window.load_files_from_paths(left, right);
        }
    }

    window.present();
}