Merge pull request #16 from rage/remove-panics

Removed panics

Author: Heliozoa

src/commands.rs

@@ -11,81 +11,68 @@ mod update;
 mod util;
 
 use crate::io::{Io, PrintColor};
+use anyhow::Context;
 use util::{Client, ClientProduction};
 
-pub fn handle(matches: &clap::ArgMatches, io: &mut dyn Io) {
-    let mut client = ClientProduction::new(matches.is_present("testmode"));
+pub fn handle(matches: &clap::ArgMatches, io: &mut dyn Io) -> anyhow::Result<()> {
+    let mut client = ClientProduction::new(matches.is_present("testmode"))?;
 
     // Authorize the client and raise error if not logged in when required
     match matches.subcommand() {
         Some(("login", _)) => {
             if client.load_login().is_ok() {
-                io.println(
-                    "Already logged in. Please logout first with 'tmc logout'",
-                    PrintColor::Failed,
-                );
-                return;
+                anyhow::bail!("Already logged in. Please logout first with 'tmc logout'",);
             }
         }
         Some(("test", _)) => (),
         _ => {
-            if client.load_login().is_err() {
-                io.println(
-                    "No login found. Login to use this command with 'tmc login'",
-                    PrintColor::Failed,
-                );
-                return;
-            }
+            client
+                .load_login()
+                .context("No login found. Login to use this command with 'tmc login'")?;
         }
     };
 
     // Check that organization is set
     if let Some(("download" | "courses", _)) = matches.subcommand() {
-        if util::get_organization().is_none() {
-            io.println(
-                "No organization found. Run 'tmc organization' first.",
-                PrintColor::Failed,
-            );
-            return;
-        }
+        util::get_organization().context("No organization found. Run 'tmc organization' first.")?;
     };
 
     match matches.subcommand() {
         Some(("login", args)) => {
             let interactive_mode = !args.is_present("non-interactive");
-            login::login(io, &mut client, interactive_mode)
+            login::login(io, &mut client, interactive_mode)?;
         }
         Some(("download", args)) => download::download_or_update(
             io,
             &mut client,
             args.value_of("course"),
             args.is_present("currentdir"),
-        ),
+        )?,
         Some(("update", args)) => {
-            update::update(io, &mut client, args.is_present("currentdir"));
+            update::update(io, &mut client, args.is_present("currentdir"))?;
         }
         Some(("organization", args)) => {
             let interactive_mode = !args.is_present("non-interactive");
-            organization::organization(io, &mut client, interactive_mode)
+            organization::organization(io, &mut client, interactive_mode)?
         }
-        Some(("courses", _)) => courses::list_courses(io, &mut client),
+        Some(("courses", _)) => courses::list_courses(io, &mut client)?,
         Some(("submit", args)) => {
-            submit::submit(io, &mut client, args.value_of("exercise"));
+            submit::submit(io, &mut client, args.value_of("exercise"))?;
         }
         Some(("exercises", args)) => {
             if let Some(c) = args.value_of("course") {
-                exercises::list_exercises(io, &mut client, c);
+                exercises::list_exercises(io, &mut client, c)?;
             } else {
-                io.println("argument for course not found", PrintColor::Normal);
+                io.println("argument for course not found", PrintColor::Normal)?;
             }
         }
         Some(("test", args)) => {
-            test::test(io, args.value_of("exercise"));
+            test::test(io, args.value_of("exercise"))?;
         }
         Some(("paste", args)) => {
-            paste::paste(io, &mut client, args.value_of("exercise"));
+            paste::paste(io, &mut client, args.value_of("exercise"))?;
         }
-        Some(("logout", _)) => logout::logout(io, &mut client),
+        Some(("logout", _)) => logout::logout(io, &mut client)?,
         Some(("fetchupdate", _)) => {
             #[cfg(target_os = "windows")]
             crate::updater::process_update();
@@ -95,11 +82,12 @@ pub fn handle(matches: &clap::ArgMatches, io: &mut dyn Io) {
             crate::updater::cleartemp().unwrap();
         }
         Some(("elevateddownload", _)) => {
-            download::elevated_download(io, &mut client);
+            download::elevated_download(io, &mut client)?;
         }
         Some(("elevatedupdate", _)) => {
-            update::elevated_update(io, &mut client);
+            update::elevated_update(io, &mut client)?;
         }
         _ => (), // Unknown subcommand or no subcommand was given
     }
+    Ok(())
 }

src/commands/courses.rs

@@ -3,19 +3,19 @@ use crate::io::{Io, PrintColor};
 use tmc_langs::Course;
 
 /// Lists available courses from clients organization
-pub fn list_courses(io: &mut dyn Io, client: &mut dyn Client) {
-    match client.list_courses() {
-        Ok(course_list) => print_courses(io, course_list),
-        Err(error) => io.println(&error, PrintColor::Failed),
-    }
+pub fn list_courses(io: &mut dyn Io, client: &mut dyn Client) -> anyhow::Result<()> {
+    let course_list = client.list_courses()?;
+    print_courses(io, &course_list)?;
+    Ok(())
 }
 
 /// Prints course names
-fn print_courses(io: &mut dyn Io, course_list: Vec<Course>) {
-    io.println("", PrintColor::Normal);
+fn print_courses(io: &mut dyn Io, course_list: &[Course]) -> anyhow::Result<()> {
+    io.println("", PrintColor::Normal)?;
     for course in course_list {
-        io.println(&course.name, PrintColor::Normal);
+        io.println(&course.name, PrintColor::Normal)?;
     }
+    Ok(())
 }
 
 #[cfg(test)]
@@ -43,25 +43,27 @@ mod tests {
 
     #[cfg(test)]
     impl Io for IoTest<'_> {
-        fn read_line(&mut self) -> String {
-            match self.input.next() {
+        fn read_line(&mut self) -> anyhow::Result<String> {
+            let res = match self.input.next() {
                 Some(string) => string,
                 None => "",
-            }
-            .to_string()
+            };
+            Ok(res.to_string())
         }
 
-        fn print(&mut self, output: &str, _font_color: PrintColor) {
+        fn print(&mut self, output: &str, _font_color: PrintColor) -> anyhow::Result<()> {
             print!("{}", output);
             self.list.push(output.to_string());
+            Ok(())
         }
 
-        fn println(&mut self, output: &str, _font_color: PrintColor) {
+        fn println(&mut self, output: &str, _font_color: PrintColor) -> anyhow::Result<()> {
             println!("{}", output);
             self.list.push(output.to_string());
+            Ok(())
         }
 
-        fn read_password(&mut self) -> String {
+        fn read_password(&mut self) -> anyhow::Result<String> {
             self.read_line()
         }
     }
@@ -87,13 +89,13 @@ mod tests {
         fn is_test_mode(&mut self) -> bool {
             false
         }
-        fn load_login(&mut self) -> Result<(), String> {
+        fn load_login(&mut self) -> anyhow::Result<()> {
             Ok(())
         }
-        fn try_login(&mut self, _username: String, _password: String) -> Result<String, String> {
+        fn try_login(&mut self, _username: String, _password: String) -> anyhow::Result<String> {
             Ok("ok".to_string())
         }
-        fn list_courses(&mut self) -> Result<Vec<Course>, String> {
+        fn list_courses(&mut self) -> anyhow::Result<Vec<Course>> {
             Ok(vec![
                 Course {
                     id: 0,
@@ -119,10 +121,12 @@ mod tests {
                 },
             ])
         }
-        fn get_organizations(&mut self) -> Result<Vec<Organization>, String> {
+        fn get_organizations(&mut self) -> anyhow::Result<Vec<Organization>> {
             Ok(vec![])
         }
-        fn logout(&mut self) {}
+        fn logout(&mut self) -> anyhow::Result<()> {
+            Ok(())
+        }
         fn update_exercises(
             &mut self,
             _path: &Path,
@@ -172,14 +176,14 @@ mod tests {
                 validations: None,
             })
         }
-        fn get_course_exercises(&mut self, _course_id: u32) -> Result<Vec<CourseExercise>, String> {
+        fn get_course_exercises(&mut self, _course_id: u32) -> anyhow::Result<Vec<CourseExercise>> {
             Ok(vec![])
         }
 
         fn get_exercise_details(
             &mut self,
             _exercise_ids: Vec<u32>,
-        ) -> Result<Vec<ExercisesDetails>, String> {
+        ) -> Result<Vec<ExercisesDetails>, ClientError> {
             todo!()
         }
 
@@ -217,7 +221,7 @@ mod tests {
                 input: &mut input,
             };
 
-            let courses = vec![
+            let courses = [
                 Course {
                     id: 0,
                     name: "name".to_string(),
@@ -241,7 +245,7 @@ mod tests {
                     spyware_urls: vec![],
                 },
             ];
-            print_courses(&mut io, courses);
+            print_courses(&mut io, &courses).unwrap();
 
             assert!(io.list[0].eq(""));
             assert!(io.list[1].eq("name"), "Expected 'name', got {}", io.list[1]);
@@ -264,7 +268,7 @@ mod tests {
             };
 
             let mut client = ClientTest {};
-            list_courses(&mut io, &mut client);
+            list_courses(&mut io, &mut client).unwrap();
 
             assert!(io.list[0].eq(""), "first line should be empty");
             assert!(io.list[1].eq("name"), "Expected 'name', got {}", io.list[1]);