Update deps

Author: Heliozoa

Cargo.toml

@@ -19,9 +19,9 @@ authors = [
   "University of Helsinki <mooc@cs.helsinki.fi>",
   "Daniel Martinez <daniel.x.martinez@helsinki.fi>",
 ]
-edition = "2021"
+edition = "2024"
 license = "MIT OR Apache-2.0"
-rust-version = "1.70.0"
+rust-version = "1.85.0"
 version = "0.37.2"
 
 [workspace.dependencies]

crates/bindings/tmc-langs-node/src/lib.rs

@@ -16,14 +16,13 @@ use std::{
 };
 use thiserror::Error;
 use tmc_langs::{
-    file_util,
+    Compression, Credentials, DownloadOrUpdateCourseExercisesResult, LangsError, Language,
+    PrepareSubmission, TmcConfig, file_util,
     tmc::{
+        TestMyCodeClient, TestMyCodeClientError,
         request::FeedbackAnswer,
         response::{NewSubmission, SubmissionFinished},
-        TestMyCodeClient, TestMyCodeClientError,
     },
-    Compression, Credentials, DownloadOrUpdateCourseExercisesResult, LangsError, Language,
-    PrepareSubmission, TmcConfig,
 };
 
 #[derive(Debug, Error)]
@@ -82,12 +81,6 @@ pub fn init_logging(mut cx: FunctionContext) -> JsResult<JsNull> {
     Ok(cx.null())
 }
 
-pub fn set_env(mut cx: FunctionContext) -> JsResult<JsNull> {
-    parse_args!(cx, key: String, val: String);
-    env::set_var(key, val);
-    Ok(cx.null())
-}
-
 fn checkstyle(mut cx: FunctionContext) -> JsResult<JsValue> {
     parse_args!(cx, exercise_path: PathBuf, locale: String);
     lock!(cx, exercise_path);
@@ -304,7 +297,9 @@ fn download_model_solution(mut cx: FunctionContext) -> JsResult<JsValue> {
     );
 
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.download_model_solution(exercise_id, &target)?)
+        Ok(client
+            .download_model_solution(exercise_id, &target)
+            .map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -398,7 +393,7 @@ fn get_course_details(mut cx: FunctionContext) -> JsResult<JsValue> {
     );
 
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.get_course_details(course_id)?)
+        Ok(client.get_course_details(course_id).map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -412,7 +407,7 @@ fn get_course_exercises(mut cx: FunctionContext) -> JsResult<JsValue> {
     );
 
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.get_course_exercises(course_id)?)
+        Ok(client.get_course_exercises(course_id).map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -426,7 +421,7 @@ fn get_course_settings(mut cx: FunctionContext) -> JsResult<JsValue> {
     );
 
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.get_course(course_id)?)
+        Ok(client.get_course(course_id).map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -440,7 +435,7 @@ fn get_courses(mut cx: FunctionContext) -> JsResult<JsValue> {
     );
 
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.list_courses(&organization)?)
+        Ok(client.list_courses(&organization).map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -454,7 +449,7 @@ fn get_exercise_details(mut cx: FunctionContext) -> JsResult<JsValue> {
     );
 
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.get_exercise_details(exercise_id)?)
+        Ok(client.get_exercise_details(exercise_id).map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -468,7 +463,9 @@ fn get_exercise_submissions(mut cx: FunctionContext) -> JsResult<JsValue> {
     );
 
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.get_exercise_submissions_for_current_user(exercise_id)?)
+        Ok(client
+            .get_exercise_submissions_for_current_user(exercise_id)
+            .map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -484,7 +481,9 @@ fn get_exercise_updates(mut cx: FunctionContext) -> JsResult<JsValue> {
 
     let map = exercise.into_iter().collect();
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.get_exercise_updates(course_id, map)?)
+        Ok(client
+            .get_exercise_updates(course_id, map)
+            .map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -498,7 +497,7 @@ fn get_organization(mut cx: FunctionContext) -> JsResult<JsValue> {
     );
 
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.get_organization(&organization)?)
+        Ok(client.get_organization(&organization).map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -507,7 +506,7 @@ fn get_organizations(mut cx: FunctionContext) -> JsResult<JsValue> {
     parse_args!(cx, client_name: String, client_version: String);
 
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.get_organizations()?)
+        Ok(client.get_organizations().map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -521,7 +520,7 @@ fn get_unread_reviews(mut cx: FunctionContext) -> JsResult<JsValue> {
     );
 
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.get_unread_reviews(course_id)?)
+        Ok(client.get_unread_reviews(course_id).map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -600,7 +599,9 @@ fn mark_review_as_read(mut cx: FunctionContext) -> JsResult<JsValue> {
     );
 
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.mark_review_as_read(course_id, review_id)?)
+        Ok(client
+            .mark_review_as_read(course_id, review_id)
+            .map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -619,7 +620,9 @@ fn paste(mut cx: FunctionContext) -> JsResult<JsValue> {
 
     let locale = locale.map(|l| Language::from_639_3(&l).expect("Invalid locale"));
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.paste(exercise_id, &submission_path, paste_message, locale)?)
+        Ok(client
+            .paste(exercise_id, &submission_path, paste_message, locale)
+            .map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -638,12 +641,14 @@ fn request_code_review(mut cx: FunctionContext) -> JsResult<JsValue> {
 
     let locale = Language::from_639_3(&locale).expect("Invalid locale");
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.request_code_review(
-            exercise_id,
-            &submission_path,
-            message_for_reviewer,
-            Some(locale),
-        )?)
+        Ok(client
+            .request_code_review(
+                exercise_id,
+                &submission_path,
+                message_for_reviewer,
+                Some(locale),
+            )
+            .map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -661,7 +666,9 @@ fn reset_exercise(mut cx: FunctionContext) -> JsResult<JsValue> {
 
     let res = with_client(client_name, client_version, |client| {
         if save_old_state {
-            client.submit(exercise_id, &exercise_path, None)?;
+            client
+                .submit(exercise_id, &exercise_path, None)
+                .map_err(Box::new)?;
         }
         tmc_langs::reset(client, exercise_id, &exercise_path)
     });
@@ -685,7 +692,9 @@ fn send_feedback(mut cx: FunctionContext) -> JsResult<JsValue> {
         })
         .collect();
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.send_feedback(submission_id, feedback)?)
+        Ok(client
+            .send_feedback(submission_id, feedback)
+            .map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -708,15 +717,19 @@ fn submit(mut cx: FunctionContext) -> JsResult<JsValue> {
 
     let locale = locale.map(|l| Language::from_639_3(&l).expect("Invalid locale"));
     let temp = with_client(client_name, client_version, |client| {
-        let new_submission = client.submit(exercise_id, &submission_path, locale)?;
+        let new_submission = client
+            .submit(exercise_id, &submission_path, locale)
+            .map_err(Box::new)?;
         if dont_block {
             Ok(Temp::NewSubmission(new_submission))
         } else {
             let submission_url = new_submission
                 .submission_url
                 .parse()
                 .expect("Failed to parse submission URL");
-            let finished = client.wait_for_submission_at(submission_url)?;
+            let finished = client
+                .wait_for_submission_at(submission_url)
+                .map_err(Box::new)?;
             Ok(Temp::Finished(Box::new(finished)))
         }
     })
@@ -747,7 +760,9 @@ fn wait_for_submission(mut cx: FunctionContext) -> JsResult<JsValue> {
     );
 
     let res = with_client(client_name, client_version, |client| {
-        Ok(client.wait_for_submission(submission_id)?)
+        Ok(client
+            .wait_for_submission(submission_id)
+            .map_err(Box::new)?)
     });
     convert_res(&mut cx, res)
 }
@@ -826,7 +841,6 @@ fn unset_setting(mut cx: FunctionContext) -> JsResult<JsValue> {
 #[neon::main]
 fn main(mut cx: ModuleContext) -> NeonResult<()> {
     cx.export_function("initLogging", init_logging)?;
-    cx.export_function("setEnv", set_env)?;
 
     cx.export_function("checkstyle", checkstyle)?;
     cx.export_function("clean", clean)?;
@@ -887,7 +901,7 @@ fn main(mut cx: ModuleContext) -> NeonResult<()> {
 
 #[cfg(test)]
 mod test {
-    use std::{env, process::Command};
+    use std::process::Command;
     use tmc_server_mock::mockito::Server;
 
     fn init() {
@@ -905,13 +919,13 @@ mod test {
         init();
         let mut server = Server::new();
         tmc_server_mock::mock_all(&mut server);
-        env::set_var(
-            "TMC_LANGS_MOCK_SERVER_ADDR",
-            format!("http://{}", server.host_with_port()),
-        );
 
         let s = Command::new("npm")
             .args(["run", "jest"])
+            .env(
+                "TMC_LANGS_MOCK_SERVER_ADDR",
+                format!("http://{}", server.host_with_port()),
+            )
             .output()
             .expect("running jest failed");
         println!("stdout: {}", String::from_utf8_lossy(&s.stdout));

crates/plugins/csharp/src/plugin.rs

@@ -1,6 +1,6 @@
 //! An implementation of LanguagePlugin for C#.
 
-use crate::{cs_test_result::CSTestResult, policy::CSharpStudentFilePolicy, CSharpError};
+use crate::{CSharpError, cs_test_result::CSTestResult, policy::CSharpStudentFilePolicy};
 use std::{
     collections::{HashMap, HashSet},
     env,
@@ -11,12 +11,12 @@ use std::{
     time::Duration,
 };
 use tmc_langs_framework::{
-    nom::{bytes, character, combinator, sequence, IResult, Parser},
-    nom_language::error::VerboseError,
     Archive, CommandError, ExerciseDesc, Language, LanguagePlugin, RunResult, RunStatus,
     StyleValidationResult, StyleValidationStrategy, TestDesc, TestResult, TmcCommand, TmcError,
+    nom::{IResult, Parser, bytes, character, combinator, sequence},
+    nom_language::error::VerboseError,
 };
-use tmc_langs_util::{deserialize, file_util, parse_util, path_util, FileError};
+use tmc_langs_util::{deserialize, file_util, parse_util, path_util};
 use walkdir::WalkDir;
 use zip::ZipArchive;
 
@@ -43,12 +43,7 @@ impl CSharpPlugin {
                 if let Some(parent) = target_file_path.parent() {
                     file_util::create_dir_all(parent)?;
                 }
-
-                let file_path = PathBuf::from(file.name());
-                let bytes: Vec<u8> = file
-                    .bytes()
-                    .collect::<Result<Vec<_>, _>>()
-                    .map_err(|e| FileError::FileRead(file_path, e))?;
+                let bytes = file_util::read_reader(file)?;
                 file_util::write_to_file(bytes, target_file_path)?;
             }
         }
@@ -91,7 +86,7 @@ impl CSharpPlugin {
     /// Returns the path to the TMC C# runner in the cache. If TMC_CSHARP_BOOTSTRAP_PATH is set, it is returned instead.
     fn get_bootstrap_path() -> Result<PathBuf, CSharpError> {
         if let Ok(var) = env::var("TMC_CSHARP_BOOTSTRAP_PATH") {
-            log::debug!("using bootstrap path TMC_CSHARP_BOOTSTRAP_PATH={}", var);
+            log::debug!("using bootstrap path TMC_CSHARP_BOOTSTRAP_PATH={var}");
             Ok(PathBuf::from(var))
         } else {
             let runner_path = Self::get_or_init_runner_dir()?;
@@ -253,8 +248,8 @@ impl LanguagePlugin for CSharpPlugin {
                 let stdout = String::from_utf8_lossy(&output.stdout);
                 let stderr = String::from_utf8_lossy(&output.stderr);
                 if !output.status.success() {
-                    log::warn!("stdout: {}", stdout);
-                    log::error!("stderr: {}", stderr);
+                    log::warn!("stdout: {stdout}");
+                    log::error!("stderr: {stderr}");
                     let mut logs = HashMap::new();
                     logs.insert("stdout".to_string(), stdout.into_owned());
                     logs.insert("stderr".to_string(), stderr.into_owned());
@@ -265,8 +260,8 @@ impl LanguagePlugin for CSharpPlugin {
                     });
                 }
 
-                log::trace!("stdout: {}", stdout);
-                log::debug!("stderr: {}", stderr);
+                log::trace!("stdout: {stdout}");
+                log::debug!("stderr: {stderr}");
 
                 if !test_results_path.exists() {
                     return Err(CSharpError::MissingTestResults {
@@ -479,9 +474,10 @@ mod test {
         init();
 
         let path = CSharpPlugin::get_bootstrap_path().unwrap();
-        assert!(path
-            .to_string_lossy()
-            .contains("TestMyCode.CSharp.Bootstrap.dll"));
+        assert!(
+            path.to_string_lossy()
+                .contains("TestMyCode.CSharp.Bootstrap.dll")
+        );
     }
 
     #[test]
@@ -634,11 +630,12 @@ mod test {
         assert_eq!(res.status, RunStatus::CompileFailed);
         assert!(!res.logs.is_empty());
         log::debug!("{:?}", res.logs.get("stdout"));
-        assert!(res
-            .logs
-            .get("stdout")
-            .unwrap()
-            .contains("This is a compile error"));
+        assert!(
+            res.logs
+                .get("stdout")
+                .unwrap()
+                .contains("This is a compile error")
+        );
     }
 
     #[test]