lockfile shenanigans part 2

src/commands/build.rs

@@ -26,7 +26,7 @@ pub async fn run(matches: &ArgMatches) -> Result<BuildContext> {
         .unwrap_or(&default_output)
         .clone();
 
-    let lockfile = Lockfile::load_from(&output_dir)?;
+    let lockfile = Lockfile::get_lockfile(&output_dir)?;
 
     let force = matches.get_flag("force");
 
@@ -40,10 +40,14 @@ pub async fn run(matches: &ArgMatches) -> Result<BuildContext> {
     let mut ctx = BuildContext {
         server,
         http_client,
-        output_dir,
+        new_lockfile: Lockfile {
+            path: output_dir.join(".mcman.lock"),
+            ..Default::default()
+        },
         force,
         skip_stages,
         lockfile,
+        output_dir,
         ..Default::default()
     };
 

src/core/addons.rs

@@ -1,18 +1,64 @@
 use anyhow::{Context, Result};
 use console::style;
+use tokio::fs;
+
+use crate::{model::Change, util::logger::Logger};
 
 use super::{BuildContext, ReportBackState};
 
 impl BuildContext {
-    pub async fn download_addons(&self, addon_type: &str) -> Result<()> {
-        let addon_count = match addon_type {
-            "plugins" => self.server.plugins.len(),
-            "mods" => self.server.mods.len(),
-            _ => unreachable!(),
+    pub async fn download_addons(
+        &mut self,
+        addon_type: &str,
+    ) -> Result<()> {
+        let change_list = match addon_type {
+            "plugins" => &self.changes.plugins,
+            "mods" => &self.changes.mods,
+            _ => unreachable!()
+        };
+
+        let server_list = match addon_type {
+            "plugins" => &self.server.plugins,
+            "mods" => &self.server.mods,
+            _ => unreachable!()
         };
 
+        let addon_count = server_list.len();
+
         let idx_w = addon_count.to_string().len();
 
+        let removed_addons = change_list.iter()
+            .filter(|c| matches!(c, Change::Removed(_)))
+            .map(|c| c.inner())
+            .collect::<Vec<_>>();
+
+        if !removed_addons.is_empty() {
+            println!(
+                "          {}",
+                style(format!("{} {addon_type} were removed from server.toml", removed_addons.len())).dim()
+            );
+
+            let logger = Logger::List { indent: 10, len: removed_addons.len() };
+
+            for (idx, (filename, _)) in removed_addons.iter().enumerate() {
+                let path = self.output_dir.join(addon_type).join(filename);
+                if path.exists() {
+                    fs::remove_file(path).await?;
+                    logger.item(idx, &format!(
+                        "{} {}",
+                        style("Deleted      : ").bold(),
+                        style(filename).dim()
+                    ));
+                } else {
+                    logger.item(idx, &format!(
+                        "{} {}",
+                        style("Doesn't exist: ").bold(),
+                        style(filename).dim()
+                    ));
+                }
+            }
+        }
+
         println!(
             "          {}",
             style(format!("{addon_count} {addon_type} present, processing...")).dim()
@@ -21,25 +67,21 @@ impl BuildContext {
         std::fs::create_dir_all(self.output_dir.join(addon_type))
             .context(format!("Failed to create {addon_type} directory"))?;
 
-        for (idx, addon) in match addon_type {
-            "plugins" => &self.server.plugins,
-            "mods" => &self.server.mods,
-            _ => unreachable!(),
-        }
-        .iter()
-        .enumerate()
+        for (idx, addon) in server_list
+            .iter()
+            .enumerate()
         {
-            self.downloadable(addon, Some(addon_type), |state, file_name| match state {
+            let filename = self.downloadable(addon, Some(addon_type), |state, file_name| match state {
                 ReportBackState::Skipped => {
                     println!(
-                        "          ({:idx_w$}/{addon_count}) Skipping    : {}",
+                        "          ({:idx_w$}/{addon_count}) Skipping  : {}",
                         idx + 1,
                         style(&file_name).dim()
                     );
                 }
                 ReportBackState::Downloaded => {
                     println!(
-                        "          ({:idx_w$}/{addon_count}) {}  : {}",
+                        "          ({:idx_w$}/{addon_count}) {}: {}",
                         idx + 1,
                         style("Downloaded").green().bold(),
                         style(&file_name).dim()
@@ -48,6 +90,12 @@ impl BuildContext {
                 ReportBackState::Downloading => {}
             })
             .await?;
+
+            match addon_type {
+                "plugins" => self.new_lockfile.plugins.push((filename, addon.clone())),
+                "mods" => self.new_lockfile.mods.push((filename, addon.clone())),
+                _ => unreachable!(),
+            }
         }
 
         Ok(())

src/core/mod.rs

@@ -6,7 +6,7 @@ use dialoguer::theme::ColorfulTheme;
 use tokio::fs::{self, File};
 
 use crate::{
-    model::{Server, StartupMethod, Network, Lockfile},
+    model::{Server, StartupMethod, Network, Lockfile, Changes},
     util::{self, logger::Logger}, Source,
 };
 
@@ -25,7 +25,9 @@ pub struct BuildContext {
     pub http_client: reqwest::Client,
     pub output_dir: PathBuf,
     pub lockfile: Lockfile,
+    pub new_lockfile: Lockfile,
 
+    pub changes: Changes,
     pub force: bool,
     pub skip_stages: Vec<String>,
     pub start_time: Instant,
@@ -44,6 +46,8 @@ impl Default for BuildContext {
             http_client: reqwest::Client::default(),
             output_dir: PathBuf::new(),
             lockfile: Lockfile::default(),
+            new_lockfile: Lockfile::default(),
+            changes: Changes::default(),
             startup_method: StartupMethod::Jar(String::from("server.jar")),
             skip_stages: vec![],
             stage_index: 1,
@@ -58,6 +62,8 @@ impl BuildContext {
         self.stage_index = 1;
         self.start_time = Instant::now();
 
+        self.reload()?;
+
         println!(
             " {} {}...",
             style("Building").bold(),
@@ -104,6 +110,12 @@ impl BuildContext {
         Ok(())
     }
 
+    pub fn reload(&mut self) -> Result<()> {
+        self.lockfile = Lockfile::get_lockfile(&self.output_dir)?;
+        self.changes = self.lockfile.get_changes(&self.server);
+        Ok(())
+    }
+
     pub async fn run_stage(&mut self, name: &str, id: &str) -> Result<()> {
         println!(" stage {}: {}", self.stage_index, style(name).blue().bold());
 

src/hot_reload/config.rs

@@ -1,5 +1,7 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, path::PathBuf, fs::File, io::Write};
 
+use anyhow::Result;
+use glob::Pattern;
 use serde::{Serialize, Deserialize};
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -13,17 +15,44 @@ pub enum HotReloadAction {
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct HotReloadConfig {
+    #[serde(skip)]
+    pub path: PathBuf,
+
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub files: Vec<Entry>,
-    pub events: HashMap<HotReloadEvent, HotReloadAction>,
+    #[serde(skip_serializing_if = "HashMap::is_empty")]
+    pub events: HashMap<String, HotReloadAction>,
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
-pub enum HotReloadEvent {
+impl HotReloadConfig {
+    pub fn load_from(path: &PathBuf) -> Result<Self> {
+        let data = std::fs::read_to_string(path)?;
+        let mut h: Self = toml::from_str(&data)?;
+        h.path = path.to_owned();
+        Ok(h)
+    }
+
+    pub fn reload(&mut self) -> Result<()> {
+        let path = self.path.clone();
+        let data = std::fs::read_to_string(path)?;
+        let mut h: Self = toml::from_str(&data)?;
+        self.events = h.events;
+        self.files = h.files;
+        Ok(())
+    }
+
+    pub fn save(&self) -> Result<()> {
+        let cfg_str = toml::to_string_pretty(&self)?;
+        let mut f = File::create(&self.path)?;
+        f.write_all(cfg_str.as_bytes())?;
 
+        Ok(())
+    }
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Entry {
-    pub path: String,
+    #[serde(with = "super::pattern_serde")]
+    pub path: Pattern,
     pub action: HotReloadAction,
 }

src/hot_reload/mod.rs

@@ -1,20 +1,20 @@
 use anyhow::{Result, Context};
-use glob_match::glob_match;
 use notify::{Watcher, recommended_watcher, EventKind};
 
-use crate::{commands::build::BuildContext, create_http_client, model::Server};
+use crate::{core::BuildContext, create_http_client, model::Server};
 
 use self::config::{HotReloadConfig, HotReloadAction};
 
 pub mod config;
+pub mod pattern_serde;
 
 #[derive(Debug)]
 pub struct DevSession {
     pub ctx: BuildContext,
 }
 
 impl DevSession {
-    pub async fn start(config: &HotReloadConfig) -> Result<()> {
+    pub async fn start(config: HotReloadConfig) -> Result<()> {
         let server = Server::load().context("Failed to load server.toml")?;
         let http_client = create_http_client()?;
 
@@ -31,12 +31,12 @@ impl DevSession {
                     EventKind::Create(_) | EventKind::Modify(_) => {
                         for path in e.paths {
                             let Some(file) = config.files.iter().find(|f| {
-                                glob_match(&f.path, &path.to_string_lossy())
+                                f.path.matches_path(&path)
                             }) else {
                                 return;
                             };
 
-                            match file.action {
+                            match &file.action {
                                 HotReloadAction::Reload => {
 
                                 }

src/hot_reload/pattern_serde.rs

@@ -0,0 +1,11 @@
+use glob::Pattern;
+use serde::{Serializer, Deserializer, Serialize, Deserialize};
+
+pub fn serialize<S: Serializer>(pat: &Pattern, ser: S) -> Result<S::Ok, S::Error> {
+    pat.as_str().serialize(ser)
+}
+
+pub fn deserialize<'de, D: Deserializer<'de>>(de: D) -> Result<Pattern, D::Error> {
+    Ok(Pattern::new(&String::deserialize(de)?)
+    .map_err(serde::de::Error::custom)?)
+}

src/main.rs

@@ -16,7 +16,7 @@ mod core;
 mod model;
 mod sources;
 mod util;
-//mod hot_reload;
+mod hot_reload;
 
 fn cli() -> Command {
     Command::new("mcman")

src/model/downloadable/import_url.rs

@@ -390,7 +390,7 @@ impl Downloadable {
             Some(_) | None => {
                 let items = vec!["Add as Custom URL", "Add as Jenkins", "Nevermind, cancel"];
                 let selection = Select::with_theme(&ColorfulTheme::default())
-                    .with_prompt("  How would you like to import this URL?")
+                    .with_prompt(format!("  How would you like to import this URL?\n  -> {urlstr}"))
                     .items(&items)
                     .default(0)
                     .interact_opt()?;
@@ -413,6 +413,7 @@ impl Downloadable {
 
                         let desc: String = Input::with_theme(&ColorfulTheme::default())
                             .with_prompt("  Optional description/comment?")
+                            .default(String::new())
                             .interact_text()?;
 
                         Ok(Self::Url {