Merge pull request #4 from tsirysndr/feat/diffs

feat: detect diffs in oh-my-droid.toml

src/cmd/setup.rs

···
+use std::path::Path;
+
 use anyhow::Error;
 use owo_colors::OwoColorize;
 
-use crate::{config::Configuration, consts::CONFIG_FILE};
+use crate::{config::Configuration, consts::CONFIG_FILE, diff::compare_configurations};
 
 pub fn setup(dry_run: bool, no_confirm: bool) -> Result<(), Error> {
     let mut cfg = Configuration::default();
···
         cfg = toml::from_str(&toml_str)?;
     }
 
+    let mut diffs = Vec::new();
+
     if !no_confirm && !dry_run {
+        let home_dir =
+            dirs::home_dir().ok_or_else(|| anyhow::anyhow!("Failed to get home directory"))?;
+        diffs = match Path::new(&home_dir).join(".oh-my-droid/lock.toml").exists() {
+            true => {
+                let old_cfg = Configuration::load_lock_file()?;
+                compare_configurations(&old_cfg, &cfg)
+            }
+            false => compare_configurations(&Configuration::empty(), &cfg),
+        };
+
+        if diffs.is_empty() {
+            println!(
+                "{}",
+                "No changes detected. Your environment is already up to date.".green()
+            );
+            return Ok(());
+        }
+
+        println!("The following changes will be made:");
+        for d in diffs.iter().clone() {
+            println!("{}", d);
+        }
+
         match std::path::Path::new(CONFIG_FILE).exists() {
             true => {
                 println!(
···
             }
             false => {
                 println!(
-                    "This wil set up your environment with the default configuration.\nDo you want to continue? (y/N)",
+                    "This will set up your environment with the default configuration.\nDo you want to continue? (y/N)",
                 );
             }
         }
···
         }
     }
 
-    cfg.setup_environment(dry_run)?;
+    cfg.setup_environment(dry_run, diffs)?;
 
     Ok(())
 }

src/config.rs

···
 use anyhow::{Context, Error, Result};
 use owo_colors::OwoColorize;
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, process::Command};
+use std::{
+    collections::HashMap,
+    fs::{self, File},
+    io::Write,
+    process::Command,
+};
 
-use crate::apply::SetupStep;
+use crate::{apply::SetupStep, diff::Diff};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct OhMyPosh {
···
 }
 
 impl Configuration {
-    pub fn setup_environment(&self, dry_run: bool) -> Result<()> {
+    pub fn empty() -> Self {
+        Self {
+            stow: None,
+            mise: None,
+            nix: None,
+            apt_get: None,
+            pkgx: None,
+            curl: None,
+            blesh: None,
+            oh_my_posh: None,
+            zoxide: None,
+            alias: None,
+            tailscale: None,
+            ssh: None,
+            neofetch: None,
+        }
+    }
+
+    pub fn setup_environment(&self, dry_run: bool, diffs: Vec<Diff>) -> Result<()> {
         let output = Command::new("df")
             .args(&["-BG", "--output=size", "/"])
             .output()
···
             return Err(Error::msg("Insufficient disk size: >= 7GB required"));
         }
 
-        let steps: Vec<SetupStep> = vec![
-            Some(SetupStep::Paths),
-            self.apt_get.as_deref().map(SetupStep::AptGet),
-            self.curl.as_ref().map(SetupStep::Curl),
-            self.pkgx.as_ref().map(SetupStep::Pkgx),
-            self.mise.as_ref().map(SetupStep::Mise),
-            self.blesh.map(SetupStep::BleSh),
-            self.zoxide.map(SetupStep::Zoxide),
-            self.nix.as_ref().map(SetupStep::Nix),
-            self.stow.as_ref().map(SetupStep::Stow),
-            self.oh_my_posh
-                .as_ref()
-                .map(|omp| SetupStep::OhMyPosh(omp.theme.as_deref().unwrap_or("tokyonight_storm"))),
-            self.alias.as_ref().map(SetupStep::Alias),
-            self.ssh.as_ref().map(SetupStep::Ssh),
-            self.tailscale.map(SetupStep::Tailscale),
-            self.neofetch.map(SetupStep::Neofetch),
-        ]
-        .into_iter()
-        .flatten()
-        .collect();
+        let steps = self.diffs_to_setup_steps(diffs);
 
         if dry_run {
             println!("{}", "=== Dry Run: Environment Setup ===".yellow().bold());
···
                 println!("\n=> Step {}:\n{}", i + 1, step.format_dry_run());
             }
             println!("{}", "=== Dry Run Complete ===".yellow().bold());
-        } else {
-            for step in steps {
-                step.run()?;
-            }
-            println!("{}", "Environment setup completed successfully 🎉".green());
-            println!("You can now open a new terminal to see the changes.");
-            println!(
-                "Or run {} to apply the changes to the current terminal session.",
-                "source ~/.bashrc".green()
-            );
+            return Ok(());
+        }
+
+        for step in steps {
+            step.run()?;
         }
+
+        self.write_lock_file()?;
+
+        println!("{}", "Environment setup completed successfully 🎉".green());
+        println!("You can now open a new terminal to see the changes.");
+        println!(
+            "Or run {} to apply the changes to the current terminal session.",
+            "source ~/.bashrc".green()
+        );
+
         Ok(())
+    }
+
+    pub fn write_lock_file(&self) -> Result<()> {
+        let home_dir = dirs::home_dir().context("Failed to get home directory")?;
+        let config_path = home_dir.join(".oh-my-droid/lock.toml");
+
+        fs::create_dir_all(
+            config_path
+                .parent()
+                .context("Failed to get parent directory of lock file")?,
+        )?;
+
+        let mut file = File::create(&config_path).context("Failed to create lock file")?;
+        file.write_all(
+            toml::to_string(&self)
+                .context("Failed to serialize config")?
+                .as_bytes(),
+        )
+        .context("Failed to write lock file")?;
+
+        Ok(())
+    }
+
+    pub fn load_lock_file() -> Result<Configuration> {
+        let home_dir = dirs::home_dir().context("Failed to get home directory")?;
+        let config_path = home_dir.join(".oh-my-droid/lock.toml");
+
+        let toml_str = fs::read_to_string(&config_path).context("Failed to read lock file")?;
+        let loaded_config: Configuration =
+            toml::from_str(&toml_str).context("Failed to parse lock file")?;
+
+        Ok(loaded_config)
+    }
+
+    pub fn diffs_to_setup_steps<'a>(&'a self, diffs: Vec<Diff>) -> Vec<SetupStep<'a>> {
+        let mut steps = Vec::new();
+
+        steps.push(SetupStep::Paths);
+
+        for diff in diffs {
+            match diff {
+                Diff::Added(parent, _child, _value) => {
+                    self.add_setup_step_for_parent(&mut steps, &parent);
+                }
+                Diff::Changed(parent, _child, _old, _new) => {
+                    self.add_setup_step_for_parent(&mut steps, &parent);
+                }
+                Diff::Nested(parent, nested_diffs) => {
+                    self.add_setup_step_for_parent(&mut steps, &parent);
+                    let nested_steps = self.diffs_to_setup_steps(nested_diffs);
+                    steps.extend(
+                        nested_steps
+                            .into_iter()
+                            .filter(|step| !matches!(step, SetupStep::Paths)),
+                    );
+                }
+                Diff::Removed(_parent, _child, _value) => {
+                    // For removed items, we typically don't need to do anything
+                    // as the setup is additive, but you could add cleanup logic here if needed
+                }
+            }
+        }
+
+        steps.dedup_by(|a, b| std::mem::discriminant(a) == std::mem::discriminant(b));
+
+        steps
+    }
+
+    fn add_setup_step_for_parent<'a>(&'a self, steps: &mut Vec<SetupStep<'a>>, parent: &str) {
+        match parent {
+            "apt-get" => {
+                if let Some(apt_packages) = &self.apt_get {
+                    steps.push(SetupStep::AptGet(apt_packages));
+                }
+            }
+            "pkgx" => {
+                if let Some(pkgx_packages) = &self.pkgx {
+                    steps.push(SetupStep::Pkgx(pkgx_packages));
+                }
+            }
+            "curl" => {
+                if let Some(curl_installers) = &self.curl {
+                    steps.push(SetupStep::Curl(curl_installers));
+                }
+            }
+            "mise" => {
+                if let Some(mise_tools) = &self.mise {
+                    steps.push(SetupStep::Mise(mise_tools));
+                }
+            }
+            "ble.sh" => {
+                if let Some(blesh_enabled) = self.blesh {
+                    steps.push(SetupStep::BleSh(blesh_enabled));
+                }
+            }
+            "nix" => {
+                if let Some(nix_packages) = &self.nix {
+                    steps.push(SetupStep::Nix(nix_packages));
+                }
+            }
+            "stow" => {
+                if let Some(stow_configs) = &self.stow {
+                    steps.push(SetupStep::Stow(stow_configs));
+                }
+            }
+            "oh_my_posh" => {
+                if let Some(oh_my_posh) = &self.oh_my_posh {
+                    let theme = oh_my_posh.theme.as_deref().unwrap_or("tokyonight_storm");
+                    steps.push(SetupStep::OhMyPosh(theme));
+                }
+            }
+            "zoxide" => {
+                if let Some(zoxide_enabled) = self.zoxide {
+                    steps.push(SetupStep::Zoxide(zoxide_enabled));
+                }
+            }
+            "alias" => {
+                if let Some(aliases) = &self.alias {
+                    steps.push(SetupStep::Alias(aliases));
+                }
+            }
+            "ssh" => {
+                if let Some(ssh_config) = &self.ssh {
+                    steps.push(SetupStep::Ssh(ssh_config));
+                }
+            }
+            "tailscale" => {
+                if let Some(tailscale_enabled) = self.tailscale {
+                    steps.push(SetupStep::Tailscale(tailscale_enabled));
+                }
+            }
+            "neofetch" => {
+                if let Some(neofetch_enabled) = self.neofetch {
+                    steps.push(SetupStep::Neofetch(neofetch_enabled));
+                }
+            }
+            _ => {} // Ignore unknown configuration keys
+        }
     }
 }
 

src/diff.rs

···
+use owo_colors::OwoColorize;
+use std::{collections::HashMap, fmt};
+
+use crate::config::{Configuration, OhMyPosh, SshConfig};
+
+#[derive(Debug)]
+pub enum Diff {
+    Added(String, String, String),           // Parent, child, value
+    Removed(String, String, String),         // Parent, child, value
+    Changed(String, String, String, String), // Parent, child, old value, new value
+    Nested(String, Vec<Diff>),               // Parent field, nested differences
+}
+
+impl fmt::Display for Diff {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Diff::Added(parent, child, value) => {
+                if child.is_empty() {
+                    write!(f, "+ {}: {}", parent.green(), value.green())
+                } else {
+                    write!(
+                        f,
+                        "+ {}:\n  + {}: {}",
+                        parent.green(),
+                        child.green(),
+                        value.green()
+                    )
+                }
+            }
+            Diff::Removed(parent, child, value) => {
+                if child.is_empty() {
+                    write!(f, "- {}: {}", parent.magenta(), value.magenta())
+                } else {
+                    write!(
+                        f,
+                        "- {}:\n  - {}: {}",
+                        parent.magenta(),
+                        child.magenta(),
+                        value.magenta()
+                    )
+                }
+            }
+            Diff::Changed(parent, child, old_value, new_value) => {
+                if child.is_empty() {
+                    write!(
+                        f,
+                        "- {}: {}\n+ {}: {}",
+                        parent.magenta(),
+                        old_value.magenta(),
+                        parent.green(),
+                        new_value.green()
+                    )
+                } else {
+                    write!(
+                        f,
+                        "- {}:\n  - {}: {}\n+ {}:\n  + {}: {}",
+                        parent.magenta(),
+                        child.magenta(),
+                        old_value.magenta(),
+                        parent.green(),
+                        child.green(),
+                        new_value.green()
+                    )
+                }
+            }
+            Diff::Nested(parent, diffs) => {
+                write!(f, "{}:", parent)?;
+                for diff in diffs {
+                    write!(f, "\n  {}", diff)?;
+                }
+                Ok(())
+            }
+        }
+    }
+}
+
+fn compare_hashmap(
+    parent: &str,
+    old: &Option<HashMap<String, String>>,
+    new: &Option<HashMap<String, String>>,
+) -> Vec<Diff> {
+    let mut diffs = Vec::new();
+    match (old, new) {
+        (None, Some(new_map)) => {
+            for (key, value) in new_map {
+                diffs.push(Diff::Added(parent.to_string(), key.clone(), value.clone()));
+            }
+        }
+        (Some(old_map), None) => {
+            for (key, value) in old_map {
+                diffs.push(Diff::Removed(
+                    parent.to_string(),
+                    key.clone(),
+                    value.clone(),
+                ));
+            }
+        }
+        (Some(old_map), Some(new_map)) => {
+            for (key, old_value) in old_map {
+                match new_map.get(key) {
+                    None => diffs.push(Diff::Removed(
+                        parent.to_string(),
+                        key.clone(),
+                        old_value.clone(),
+                    )),
+                    Some(new_value) if new_value != old_value => {
+                        diffs.push(Diff::Changed(
+                            parent.to_string(),
+                            key.clone(),
+                            old_value.clone(),
+                            new_value.clone(),
+                        ));
+                    }
+                    _ => {}
+                }
+            }
+            for (key, new_value) in new_map {
+                if !old_map.contains_key(key) {
+                    diffs.push(Diff::Added(
+                        parent.to_string(),
+                        key.clone(),
+                        new_value.clone(),
+                    ));
+                }
+            }
+        }
+        (None, None) => {}
+    }
+    diffs
+}
+
+fn compare_vec(parent: &str, old: &Option<Vec<String>>, new: &Option<Vec<String>>) -> Vec<Diff> {
+    let mut diffs = Vec::new();
+    match (old, new) {
+        (None, Some(new_vec)) => {
+            for item in new_vec {
+                diffs.push(Diff::Added(
+                    parent.to_string(),
+                    "".to_string(),
+                    item.clone(),
+                ));
+            }
+        }
+        (Some(old_vec), None) => {
+            for item in old_vec {
+                diffs.push(Diff::Removed(
+                    parent.to_string(),
+                    "".to_string(),
+                    item.clone(),
+                ));
+            }
+        }
+        (Some(old_vec), Some(new_vec)) => {
+            let old_set: std::collections::HashSet<_> = old_vec.iter().collect();
+            let new_set: std::collections::HashSet<_> = new_vec.iter().collect();
+            for item in new_set.difference(&old_set) {
+                diffs.push(Diff::Added(
+                    parent.to_string(),
+                    "".to_string(),
+                    item.to_string(),
+                ));
+            }
+            for item in old_set.difference(&new_set) {
+                diffs.push(Diff::Removed(
+                    parent.to_string(),
+                    "".to_string(),
+                    item.to_string(),
+                ));
+            }
+        }
+        (None, None) => {}
+    }
+    diffs
+}
+
+fn compare_bool(parent: &str, old: &Option<bool>, new: &Option<bool>) -> Vec<Diff> {
+    match (old, new) {
+        (None, Some(new_val)) => vec![Diff::Added(
+            parent.to_string(),
+            "".to_string(),
+            new_val.to_string(),
+        )],
+        (Some(old_val), None) => vec![Diff::Removed(
+            parent.to_string(),
+            "".to_string(),
+            old_val.to_string(),
+        )],
+        (Some(old_val), Some(new_val)) if old_val != new_val => {
+            vec![Diff::Changed(
+                parent.to_string(),
+                "".to_string(),
+                old_val.to_string(),
+                new_val.to_string(),
+            )]
+        }
+        _ => vec![],
+    }
+}
+
+fn compare_oh_my_posh(old: &Option<OhMyPosh>, new: &Option<OhMyPosh>) -> Vec<Diff> {
+    let mut diffs = Vec::new();
+    match (old, new) {
+        (None, Some(new_omp)) => {
+            if let Some(theme) = &new_omp.theme {
+                diffs.push(Diff::Added(
+                    "oh_my_posh".to_string(),
+                    "theme".to_string(),
+                    theme.clone(),
+                ));
+            }
+        }
+        (Some(old_omp), None) => {
+            if let Some(theme) = &old_omp.theme {
+                diffs.push(Diff::Removed(
+                    "oh_my_posh".to_string(),
+                    "theme".to_string(),
+                    theme.clone(),
+                ));
+            }
+        }
+        (Some(old_omp), Some(new_omp)) => match (&old_omp.theme, &new_omp.theme) {
+            (None, Some(new_theme)) => {
+                diffs.push(Diff::Added(
+                    "oh_my_posh".to_string(),
+                    "theme".to_string(),
+                    new_theme.clone(),
+                ));
+            }
+            (Some(old_theme), None) => {
+                diffs.push(Diff::Removed(
+                    "oh_my_posh".to_string(),
+                    "theme".to_string(),
+                    old_theme.clone(),
+                ));
+            }
+            (Some(old_theme), Some(new_theme)) if old_theme != new_theme => {
+                diffs.push(Diff::Changed(
+                    "oh_my_posh".to_string(),
+                    "theme".to_string(),
+                    old_theme.clone(),
+                    new_theme.clone(),
+                ));
+            }
+            _ => {}
+        },
+        (None, None) => {}
+    }
+    if !diffs.is_empty() {
+        vec![Diff::Nested("oh_my_posh".to_string(), diffs)]
+    } else {
+        vec![]
+    }
+}
+
+fn compare_ssh_config(old: &Option<SshConfig>, new: &Option<SshConfig>) -> Vec<Diff> {
+    let mut diffs = Vec::new();
+    match (old, new) {
+        (None, Some(new_ssh)) => {
+            if let Some(port) = new_ssh.port {
+                diffs.push(Diff::Added(
+                    "ssh".to_string(),
+                    "port".to_string(),
+                    port.to_string(),
+                ));
+            }
+            if let Some(keys) = &new_ssh.authorized_keys {
+                for key in keys {
+                    diffs.push(Diff::Added(
+                        "ssh".to_string(),
+                        "authorized_keys".to_string(),
+                        key.clone(),
+                    ));
+                }
+            }
+        }
+        (Some(old_ssh), None) => {
+            if let Some(port) = old_ssh.port {
+                diffs.push(Diff::Removed(
+                    "ssh".to_string(),
+                    "port".to_string(),
+                    port.to_string(),
+                ));
+            }
+            if let Some(keys) = &old_ssh.authorized_keys {
+                for key in keys {
+                    diffs.push(Diff::Removed(
+                        "ssh".to_string(),
+                        "authorized_keys".to_string(),
+                        key.clone(),
+                    ));
+                }
+            }
+        }
+        (Some(old_ssh), Some(new_ssh)) => {
+            match (old_ssh.port, new_ssh.port) {
+                (None, Some(new_port)) => {
+                    diffs.push(Diff::Added(
+                        "ssh".to_string(),
+                        "port".to_string(),
+                        new_port.to_string(),
+                    ));
+                }
+                (Some(old_port), None) => {
+                    diffs.push(Diff::Removed(
+                        "ssh".to_string(),
+                        "port".to_string(),
+                        old_port.to_string(),
+                    ));
+                }
+                (Some(old_port), Some(new_port)) if old_port != new_port => {
+                    diffs.push(Diff::Changed(
+                        "ssh".to_string(),
+                        "port".to_string(),
+                        old_port.to_string(),
+                        new_port.to_string(),
+                    ));
+                }
+                _ => {}
+            }
+            let key_diffs = compare_vec("ssh", &old_ssh.authorized_keys, &new_ssh.authorized_keys);
+            diffs.extend(key_diffs.into_iter().map(|diff| match diff {
+                Diff::Added(_, _, value) => {
+                    Diff::Added("ssh".to_string(), "authorized_keys".to_string(), value)
+                }
+                Diff::Removed(_, _, value) => {
+                    Diff::Removed("ssh".to_string(), "authorized_keys".to_string(), value)
+                }
+                Diff::Changed(_, _, old_value, new_value) => Diff::Changed(
+                    "ssh".to_string(),
+                    "authorized_keys".to_string(),
+                    old_value,
+                    new_value,
+                ),
+                Diff::Nested(_, _) => diff, // Unreachable
+            }));
+        }
+        (None, None) => {}
+    }
+    if !diffs.is_empty() {
+        vec![Diff::Nested("ssh".to_string(), diffs)]
+    } else {
+        vec![]
+    }
+}
+
+pub fn compare_configurations(old: &Configuration, new: &Configuration) -> Vec<Diff> {
+    let mut diffs = Vec::new();
+
+    diffs.extend(compare_hashmap("stow", &old.stow, &new.stow));
+    diffs.extend(compare_hashmap("mise", &old.mise, &new.mise));
+    diffs.extend(compare_hashmap("nix", &old.nix, &new.nix));
+    diffs.extend(compare_hashmap("pkgx", &old.pkgx, &new.pkgx));
+    diffs.extend(compare_hashmap("curl", &old.curl, &new.curl));
+    diffs.extend(compare_hashmap("alias", &old.alias, &new.alias));
+
+    diffs.extend(compare_vec("apt-get", &old.apt_get, &new.apt_get));
+
+    diffs.extend(compare_bool("blesh", &old.blesh, &new.blesh));
+    diffs.extend(compare_bool("zoxide", &old.zoxide, &new.zoxide));
+    diffs.extend(compare_bool("tailscale", &old.tailscale, &new.tailscale));
+    diffs.extend(compare_bool("neofetch", &old.neofetch, &new.neofetch));
+
+    diffs.extend(compare_oh_my_posh(&old.oh_my_posh, &new.oh_my_posh));
+    diffs.extend(compare_ssh_config(&old.ssh, &new.ssh));
+
+    diffs
+}

src/main.rs

···
 pub mod command;
 pub mod config;
 pub mod consts;
+pub mod diff;
 
 fn cli() -> Command {
     let banner = format!(