Update dependencies, fix config edits

Author: octylFractal

Cargo.lock

@@ -14,42 +14,43 @@ edition = "2021"
 error-stack = "0.5.0"
 digest = "0.10.7"
 sha2 = "0.10.8"
-directories = "5.0.1"
+directories = "6.0.0"
 tracing = "0.1.41"
-toml = "0.8.19"
+toml = "0.8.20"
+toml_edit = "0.22.24"
 itertools = "0.14.0"
-thiserror = "2.0.9"
-console = "0.15.10"
-indicatif = "0.17.9"
+thiserror = "2.0.12"
+console = "0.15.11"
+indicatif = "0.17.11"
 hex = "0.4.3"
-tempfile = "3.15.0"
-tar = "0.4.43"
-flate2 = "1.0.35"
-zip = "2.2.2"
+tempfile = "3.19.1"
+tar = "0.4.44"
+flate2 = "1.1.0"
+zip = "2.5.0"
 enum_dispatch = "0.3.13"
 
 [dependencies.url]
 version = "2.5.4"
 features = ["serde"]
 
 [dependencies.ureq]
-version = "2.12.1"
-features = ["json", "proxy-from-env"]
+version = "3.0.10"
+features = ["json"]
 
 [dependencies.owo-colors]
-version = "4.1.0"
+version = "4.2.0"
 features = ["supports-colors"]
 
 [dependencies.derive_more]
-version = "1.0.0"
+version = "2.0.1"
 features = ["full"]
 
 [dependencies.clap]
-version = "4.5.23"
+version = "4.5.34"
 features = ["derive"]
 
 [dependencies.serde]
-version = "1.0.217"
+version = "1.0.219"
 features = ["derive"]
 
 [dependencies.tracing-subscriber]

Cargo.toml

@@ -38,12 +38,11 @@ impl JpreCommand for SetDefault {
             .get_jdk_path(&context.config, &self.jdk)
             .change_context(JpreError::Unexpected)
             .attach_printable_lazy(|| format!("Failed to get path for JDK {}", self.jdk))?;
-        context.config.default_jdk = Some(self.jdk.clone());
-        context
-            .config
-            .save()
-            .change_context(JpreError::Unexpected)
-            .attach_printable("Failed to save config")?;
+
+        context.config.edit_config(|doc| {
+            doc["default_jdk"] = toml_edit::value(self.jdk.to_string());
+        })?;
+
         eprintln!(
             "Default JDK set to '{}'",
             self.jdk

src/command/set_default.rs

@@ -55,12 +55,17 @@ impl JpreCommand for SetDistributions {
                     ),
                 }));
         }
-        context.config.distributions = self.distributions.clone();
-        context
-            .config
-            .save()
-            .change_context(JpreError::Unexpected)
-            .attach_printable("Failed to save config")?;
+
+        context.config.edit_config(|doc| {
+            let mut distributions = toml_edit::Array::new();
+            for distribution in &self.distributions {
+                distributions.push(toml_edit::Value::from(distribution));
+            }
+            distributions.fmt();
+
+            doc["distributions"] = toml_edit::value(distributions);
+        })?;
+
         eprintln!("Distribution(s) set to '{}'", self.distributions.join(", "));
         Ok(())
     }

src/command/set_distributions.rs

@@ -5,8 +5,9 @@ use directories::ProjectDirs;
 use error_stack::ResultExt;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
+use std::str::FromStr;
 use std::sync::LazyLock;
-use tracing::{debug, trace};
+use toml::de::Error;
 
 pub static PROJECT_DIRS: LazyLock<ProjectDirs> = LazyLock::new(|| {
     ProjectDirs::from("net", "octyl", "jpre").expect("Could not determine project directories")
@@ -54,12 +55,7 @@ impl JpreConfig {
             .attach_printable_lazy(|| {
                 format!("Could not open config file at {:?}", *CONFIG_PATH)
             })?;
-        let contents = std::fs::read_to_string(&*CONFIG_PATH)
-            .change_context(JpreError::Unexpected)
-            .attach_printable_lazy(|| {
-                format!("Could not read config file at {:?}", *CONFIG_PATH)
-            })?;
-        let config = toml::from_str::<JpreConfig>(&contents);
+        let (contents, config) = Self::read_config()?;
         match config {
             Ok(mut config) => {
                 if let Some(distribution) = config.distribution {
@@ -90,19 +86,35 @@ impl JpreConfig {
                                 format!("Could not parse config file at {:?}", *CONFIG_PATH)
                             });
                     }
-                    // jpre 0.2 config format
-                    let new_config = JpreConfig {
-                        default_jdk: Some(VersionKey {
+
+                    let mut new_config = toml_edit::DocumentMut::new();
+                    new_config["default_jdk"] = toml_edit::value(
+                        VersionKey {
                             major: *major as u32,
                             pre_release: PreRelease::None,
-                        }),
-                        distribution: None,
-                        distributions: default_distribution(),
-                        forced_architecture: None,
-                        forced_os: None,
-                    };
-                    new_config.save()?;
-                    return Ok(new_config);
+                        }
+                        .to_string(),
+                    );
+                    let mut distributions = toml_edit::Array::new();
+                    distributions.push("temurin");
+                    new_config["distributions"] = toml_edit::value(distributions);
+
+                    // Ensure whatever is in the config is valid.
+                    toml::from_str::<JpreConfig>(&new_config.to_string())
+                        .expect("New config is invalid");
+
+                    std::fs::write(&*CONFIG_PATH, new_config.to_string())
+                        .change_context(JpreError::Unexpected)
+                        .attach_printable_lazy(|| {
+                            format!("Could not write config file at {:?}", *CONFIG_PATH)
+                        })?;
+
+                    return Self::read_config()?
+                        .1
+                        .change_context(JpreError::Unexpected)
+                        .attach_printable_lazy(|| {
+                            format!("Could not parse config file at {:?}", *CONFIG_PATH)
+                        });
                 }
                 Err(e)
                     .change_context(JpreError::Unexpected)
@@ -113,16 +125,36 @@ impl JpreConfig {
         }
     }
 
-    pub fn save(&self) -> ESResult<(), JpreError> {
-        let contents = toml::to_string(self)
+    fn read_config() -> ESResult<(String, Result<JpreConfig, Error>), JpreError> {
+        let contents = std::fs::read_to_string(&*CONFIG_PATH)
+            .change_context(JpreError::Unexpected)
+            .attach_printable_lazy(|| {
+                format!("Could not read config file at {:?}", *CONFIG_PATH)
+            })?;
+        let config = toml::from_str::<JpreConfig>(&contents);
+        Ok((contents, config))
+    }
+
+    pub fn edit_config<F: FnOnce(&mut toml_edit::DocumentMut)>(
+        &mut self,
+        editor: F,
+    ) -> ESResult<(), JpreError> {
+        let contents = Self::read_config()?.0;
+        let mut config = toml_edit::DocumentMut::from_str(&contents)
             .change_context(JpreError::Unexpected)
-            .attach_printable("Could not serialize config to TOML")?;
-        debug!("Writing config to {:?}", *CONFIG_PATH);
-        trace!("Config: {}", contents);
-        std::fs::write(&*CONFIG_PATH, contents)
+            .attach_printable_lazy(|| {
+                format!("Could not parse config file at {:?}", *CONFIG_PATH)
+            })?;
+        editor(&mut config);
+
+        // Ensure whatever is in the config is valid, and update ourselves to it.
+        *self = toml::from_str::<JpreConfig>(&config.to_string())
+            .unwrap_or_else(|e| panic!("Edited config is invalid: {}", e));
+
+        std::fs::write(&*CONFIG_PATH, config.to_string())
             .change_context(JpreError::Unexpected)
             .attach_printable_lazy(|| {
-                format!("Could not write config file to {:?}", *CONFIG_PATH)
+                format!("Could not write config file at {:?}", *CONFIG_PATH)
             })?;
         Ok(())
     }

src/config.rs

@@ -208,19 +208,21 @@ impl FoojayDiscoApi {
             .change_context(FoojayDiscoApiError::Api)?;
         let status_code = response.status();
         let data: FoojayResult<T> = response
-            .into_json()
+            .into_body()
+            .read_json()
             .change_context(FoojayDiscoApiError::Api)?;
 
-        match status_code {
-            200..=299 => Ok(data.result),
-            _ => match data.message.as_str() {
+        if status_code.is_success() {
+            Ok(data.result)
+        } else {
+            match data.message.as_str() {
                 "Requested distribution not found" => {
                     Err(Report::new(FoojayDiscoApiError::InvalidDistribution))
                 }
                 _ => Err(Report::new(FoojayDiscoApiError::Api)
                     .attach_printable(format!("Unknown message: {}", data.message)))
                 .attach_printable(format!("Status code: {}", status_code)),
-            },
+            }
         }
     }
 
@@ -241,10 +243,10 @@ fn try_fill_checksum(info: &mut FoojayPackageInfo) {
         let Ok(response) = ureq::get(&url).call() else {
             continue;
         };
-        if !matches!(response.status(), 200..=299) {
+        if !response.status().is_success() {
             continue;
         }
-        let Ok(checksum) = response.into_string() else {
+        let Ok(checksum) = response.into_body().read_to_string() else {
             continue;
         };
         let checksum = checksum.trim();

src/foojay.rs

@@ -1,8 +1,10 @@
 pub fn new_http_client() -> ureq::Agent {
-    ureq::AgentBuilder::new()
-        .timeout_connect(std::time::Duration::from_secs(5))
-        .timeout_read(std::time::Duration::from_secs(30))
-        .timeout_write(std::time::Duration::from_secs(30))
+    ureq::Agent::config_builder()
+        .timeout_connect(Some(std::time::Duration::from_secs(5)))
+        .timeout_recv_response(Some(std::time::Duration::from_secs(10)))
+        .timeout_recv_body(Some(std::time::Duration::from_secs(30)))
+        .timeout_send_request(Some(std::time::Duration::from_secs(10)))
+        .timeout_send_body(Some(std::time::Duration::from_secs(30)))
         .user_agent(concat!(
             env!("CARGO_PKG_NAME"),
             "/",
@@ -13,4 +15,5 @@ pub fn new_http_client() -> ureq::Agent {
         ))
         .https_only(true)
         .build()
+        .new_agent()
 }

src/http_client.rs

@@ -7,6 +7,7 @@ use derive_more::Display;
 use error_stack::{Context, Report, ResultExt};
 use serde::Deserialize;
 use std::cmp::Ordering;
+use std::fmt::Display;
 use std::str::{FromStr, Split};
 
 #[derive(Debug, Display)]

src/java_version.rs

@@ -18,7 +18,8 @@ use std::str::FromStr;
 use std::sync::LazyLock;
 use tempfile::TempDir;
 use tracing::warn;
-use ureq::Response;
+use ureq::http::Response;
+use ureq::Body;
 
 #[derive(Debug, Display)]
 pub struct JdkManagerError;
@@ -251,7 +252,7 @@ impl JdkManager {
     fn download_jdk_to_file(
         list_info: &FoojayPackageListInfo,
         info: &FoojayPackageInfo,
-        response: Response,
+        response: Response<Body>,
         download_path: &Path,
     ) -> ESResult<(), JdkManagerError> {
         let mut file = std::fs::File::create(download_path)
@@ -276,17 +277,15 @@ impl JdkManager {
             &mut file,
         );
         let progress_bar = new_progress_bar(
-            response
-                .header("Content-Length")
-                .and_then(|s| s.parse().ok()),
+            response.body().content_length(),
         )
         .with_message(
             format!("Downloading JDK {}", list_info.java_version)
                 .if_supports_color(Stream::Stderr, |s| s.green())
                 .to_string(),
         );
         std::io::copy(
-            &mut response.into_reader(),
+            &mut response.into_body().into_reader(),
             &mut progress_bar.wrap_write(&mut checksum_verifier),
         )
         .change_context(JdkManagerError)

src/jdk_manager.rs

@@ -130,8 +130,6 @@ fn main_with_result() -> ESResult<(), JpreError> {
     }
 
     let config = JpreConfig::load()?;
-    // re-save config to ensure it's up-to-date
-    config.save()?;
 
     let context = Context {
         config: config.clone(),