refactored tmc-langs from anyhow to thiserror

Author: Heliozoa

tmc-langs-cli/src/config.rs

@@ -7,7 +7,6 @@ mod tmc_config;
 pub use self::credentials::Credentials;
 pub use self::projects_config::{CourseConfig, Exercise, ProjectsConfig};
 pub use self::tmc_config::{ConfigValue, TmcConfig};
-use crate::output::LocalExercise;
 
 use anyhow::{Context, Error};
 use std::path::{Path, PathBuf};
@@ -23,29 +22,6 @@ fn get_tmc_dir(client_name: &str) -> Result<PathBuf, Error> {
     Ok(config_dir.join(format!("tmc-{}", client_name)))
 }
 
-pub fn list_local_course_exercises(
-    client_name: &str,
-    course_slug: &str,
-) -> Result<Vec<LocalExercise>, anyhow::Error> {
-    let config_path = TmcConfig::get_location(client_name)?;
-    let projects_dir = TmcConfig::load(client_name, &config_path)?.projects_dir;
-    let mut projects_config = ProjectsConfig::load(&projects_dir)?;
-
-    let exercises = projects_config
-        .courses
-        .remove(course_slug)
-        .map(|cc| cc.exercises)
-        .unwrap_or_default();
-    let mut local_exercises: Vec<LocalExercise> = vec![];
-    for (exercise_slug, _) in exercises {
-        local_exercises.push(LocalExercise {
-            exercise_path: projects_dir.join(course_slug).join(&exercise_slug),
-            exercise_slug,
-        })
-    }
-    Ok(local_exercises)
-}
-
 pub fn migrate(
     tmc_config: &TmcConfig,
     course_slug: &str,

tmc-langs-util/src/error.rs

@@ -25,6 +25,8 @@ pub enum FileError {
     },
     #[error("Failed to create temporary file")]
     TempFile(#[source] std::io::Error),
+    #[error("Failed to read directory at {0}")]
+    DirRead(PathBuf, #[source] std::io::Error),
     #[error("Failed to create directory at {0}")]
     DirCreate(PathBuf, #[source] std::io::Error),
     #[error("Failed to remove directory at {0}")]

tmc-langs-util/src/file_util.rs

@@ -2,7 +2,7 @@
 
 use crate::error::FileError;
 use fd_lock::FdLock;
-use std::fs::{self, File};
+use std::fs::{self, File, ReadDir};
 use std::io::{Read, Write};
 use std::path::Path;
 use walkdir::WalkDir;
@@ -120,6 +120,10 @@ pub fn read_to_file<R: Read, P: AsRef<Path>>(source: &mut R, target: P) -> Resul
     Ok(target_file)
 }
 
+pub fn read_dir<P: AsRef<Path>>(path: P) -> Result<ReadDir, FileError> {
+    fs::read_dir(&path).map_err(|e| FileError::DirRead(path.as_ref().to_path_buf(), e))
+}
+
 pub fn create_dir<P: AsRef<Path>>(path: P) -> Result<(), FileError> {
     fs::create_dir(&path).map_err(|e| FileError::DirCreate(path.as_ref().to_path_buf(), e))
 }

tmc-langs/Cargo.toml

@@ -11,7 +11,6 @@ tmc-langs-plugins = { path = "../tmc-langs-plugins" }
 tmc-langs-framework = { path = "../tmc-langs-framework" }
 tmc-langs-util = { path = "../tmc-langs-util" }
 
-anyhow = "1"
 dirs = "3"
 heim = { version = "0.1.0-beta.3", features = ["disk"] }
 impl-enum = "0.2"

tmc-langs/src/config.rs

@@ -7,26 +7,25 @@ mod tmc_config;
 pub use self::credentials::Credentials;
 pub use self::projects_config::{CourseConfig, Exercise, ProjectsConfig};
 pub use self::tmc_config::{ConfigValue, TmcConfig};
-use crate::data::LocalExercise;
+use crate::{data::LocalExercise, error::LangsError};
 
-use anyhow::{Context, Error};
 use std::path::{Path, PathBuf};
-use std::{collections::BTreeMap, env, fs};
-use tmc_langs_util::file_util;
+use std::{collections::BTreeMap, env};
+use tmc_langs_util::{file_util, FileError};
 
 // base directory for a given plugin's settings files
-fn get_tmc_dir(client_name: &str) -> Result<PathBuf, Error> {
+fn get_tmc_dir(client_name: &str) -> Result<PathBuf, LangsError> {
     let config_dir = match env::var("TMC_LANGS_CONFIG_DIR") {
         Ok(v) => PathBuf::from(v),
-        Err(_) => dirs::config_dir().context("Failed to find config directory")?,
+        Err(_) => dirs::config_dir().ok_or(LangsError::NoConfigDir)?,
     };
     Ok(config_dir.join(format!("tmc-{}", client_name)))
 }
 
 pub fn list_local_course_exercises(
     client_name: &str,
     course_slug: &str,
-) -> Result<Vec<LocalExercise>, anyhow::Error> {
+) -> Result<Vec<LocalExercise>, LangsError> {
     let config_path = TmcConfig::get_location(client_name)?;
     let projects_dir = TmcConfig::load(client_name, &config_path)?.projects_dir;
     let mut projects_config = ProjectsConfig::load(&projects_dir)?;
@@ -53,7 +52,7 @@ pub fn migrate(
     exercise_id: usize,
     exercise_checksum: &str,
     exercise_path: &Path,
-) -> anyhow::Result<()> {
+) -> Result<(), LangsError> {
     let mut lock = file_util::FileLock::new(exercise_path.to_path_buf())?;
     let guard = lock.lock()?;
 
@@ -72,10 +71,7 @@ pub fn migrate(
         exercise_slug,
     );
     if target_dir.exists() {
-        anyhow::bail!(
-            "Tried to migrate exercise to {}; however, something already exists at that path.",
-            target_dir.display()
-        );
+        return Err(LangsError::DirectoryExists(target_dir));
     }
 
     course_config.exercises.insert(
@@ -95,26 +91,23 @@ pub fn move_projects_dir(
     mut tmc_config: TmcConfig,
     config_path: &Path,
     target: PathBuf,
-) -> anyhow::Result<()> {
+) -> Result<(), LangsError> {
     if target.is_file() {
-        anyhow::bail!("The target path points to a file.")
+        return Err(FileError::UnexpectedFile(target).into());
     }
     if !target.exists() {
-        fs::create_dir_all(&target)
-            .with_context(|| format!("Failed to create directory at {}", target.display()))?;
+        file_util::create_dir_all(&target)?;
     }
 
     let target_canon = target
         .canonicalize()
-        .with_context(|| format!("Failed to canonicalize {}", target.display()))?;
-    let prev_dir_canon = tmc_config.projects_dir.canonicalize().with_context(|| {
-        format!(
-            "Failed to canonicalize {}",
-            tmc_config.projects_dir.display()
-        )
-    })?;
+        .map_err(|e| LangsError::Canonicalize(target.clone(), e))?;
+    let prev_dir_canon = tmc_config
+        .projects_dir
+        .canonicalize()
+        .map_err(|e| LangsError::Canonicalize(target.clone(), e))?;
     if target_canon == prev_dir_canon {
-        anyhow::bail!("Attempted to move the projects-dir to the directory it's already in.")
+        return Err(LangsError::MovingProjectsDirToItself);
     }
 
     let old_projects_dir = tmc_config.set_projects_dir(target.clone())?;

tmc-langs/src/config/credentials.rs

@@ -1,10 +1,8 @@
-use crate::Token;
-use anyhow::{Context, Result};
+use crate::{LangsError, Token};
 use serde::{Deserialize, Serialize};
-use std::fs;
 use std::ops::Deref;
 use std::path::PathBuf;
-use tmc_langs_util::file_util::{self, create_file_lock};
+use tmc_langs_util::{file_util, FileError};
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Credentials {
@@ -14,7 +12,7 @@ pub struct Credentials {
 
 impl Credentials {
     // path to the credentials file
-    fn get_credentials_path(client_name: &str) -> Result<PathBuf> {
+    fn get_credentials_path(client_name: &str) -> Result<PathBuf, LangsError> {
         super::get_tmc_dir(client_name).map(|dir| dir.join("credentials.json"))
     }
 
@@ -24,19 +22,16 @@ impl Credentials {
     /// - Err if a credentials file exists but cannot be deserialized.
     ///
     /// On Err, the file is deleted.
-    pub fn load(client_name: &str) -> Result<Option<Self>> {
+    pub fn load(client_name: &str) -> Result<Option<Self>, LangsError> {
         let credentials_path = Self::get_credentials_path(client_name)?;
         if !credentials_path.exists() {
             return Ok(None);
         }
 
         let mut credentials_file = file_util::open_file_lock(&credentials_path)?;
-        let guard = credentials_file.lock().with_context(|| {
-            format!(
-                "Failed to lock credentials file at {}",
-                credentials_path.display()
-            )
-        })?;
+        let guard = credentials_file
+            .lock()
+            .map_err(|e| FileError::FdLock(credentials_path.clone(), e))?;
 
         match serde_json::from_reader(guard.deref()) {
             Ok(token) => Ok(Some(Credentials {
@@ -48,55 +43,36 @@ impl Credentials {
                     "Failed to deserialize credentials.json due to \"{}\", deleting",
                     e
                 );
-                fs::remove_file(&credentials_path).with_context(|| {
-                    format!(
-                        "Failed to remove malformed credentials.json file {}",
-                        credentials_path.display()
-                    )
-                })?;
-                anyhow::bail!(
-                "Failed to deserialize credentials file at {}; removed the file, please try again.",
-                credentials_path.display()
-            )
+                file_util::remove_file(&credentials_path)?;
+                Err(LangsError::DeserializeCredentials(credentials_path, e))
             }
         }
     }
 
-    pub fn save(client_name: &str, token: Token) -> Result<()> {
+    pub fn save(client_name: &str, token: Token) -> Result<(), LangsError> {
         let credentials_path = Self::get_credentials_path(client_name)?;
 
         if let Some(p) = credentials_path.parent() {
-            fs::create_dir_all(p)
-                .with_context(|| format!("Failed to create directory {}", p.display()))?;
+            file_util::create_dir_all(p)?;
         }
-        let mut credentials_file = create_file_lock(&credentials_path)
-            .with_context(|| format!("Failed to create file at {}", credentials_path.display()))?;
-        let guard = credentials_file.lock()?;
+        let mut credentials_file = file_util::create_file_lock(&credentials_path)?;
+        let guard = credentials_file
+            .lock()
+            .map_err(|e| FileError::FdLock(credentials_path.clone(), e))?;
 
         // write token
         if let Err(e) = serde_json::to_writer(guard.deref(), &token) {
             // failed to write token, removing credentials file
-            fs::remove_file(&credentials_path).with_context(|| {
-                format!(
-                    "Failed to remove empty credentials file after failing to write {}",
-                    credentials_path.display()
-                )
-            })?;
-            Err(e).with_context(|| {
-                format!(
-                    "Failed to write credentials to {}",
-                    credentials_path.display()
-                )
-            })?;
+            file_util::remove_file(&credentials_path)?;
+            return Err(LangsError::Json(e));
         }
         Ok(())
     }
 
-    pub fn remove(self) -> Result<()> {
+    pub fn remove(self) -> Result<(), LangsError> {
         file_util::lock!(&self.path);
 
-        fs::remove_file(&self.path)
-            .with_context(|| format!("Failed to remove credentials at {}", self.path.display()))?;
+        file_util::remove_file(&self.path)?;
         Ok(())
     }
 

tmc-langs/src/config/projects_config.rs

@@ -1,9 +1,9 @@
-use anyhow::{Context, Result};
+use crate::LangsError;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
-use std::fs;
 use std::path::{Path, PathBuf};
-use tmc_langs_util::file_util;
+use tmc_langs_util::{file_util, FileError};
+use walkdir::WalkDir;
 
 #[derive(Debug)]
 pub struct ProjectsConfig {
@@ -12,26 +12,20 @@ pub struct ProjectsConfig {
 }
 
 impl ProjectsConfig {
-    pub fn load(projects_dir: &Path) -> Result<ProjectsConfig> {
+    pub fn load(projects_dir: &Path) -> Result<ProjectsConfig, LangsError> {
         file_util::lock!(projects_dir);
 
         let mut course_configs = BTreeMap::new();
-        for file in fs::read_dir(projects_dir)
-            .with_context(|| format!("Failed to read directory at {}", projects_dir.display()))?
-        {
-            let file =
-                file.with_context(|| format!("Failed to read file in {}", projects_dir.display()))?;
+        for file in WalkDir::new(projects_dir) {
+            let file = file?;
             let course_config_path = file.path().join("course_config.toml");
             if course_config_path.exists() {
                 let file_name = file.file_name();
-                let course_dir_name = file_name.to_str().with_context(|| {
-                    format!(
-                        "Course directory name was not valid utf-8: {}",
-                        file.file_name().to_string_lossy()
-                    )
+                let course_dir_name = file_name.to_str().ok_or_else(|| {
+                    LangsError::FileError(FileError::NoFileName(file.path().to_path_buf()))
                 })?;
 
-                let bytes = fs::read(course_config_path)?;
+                let bytes = file_util::read_file(course_config_path)?;
                 let course_config: CourseConfig = toml::from_slice(&bytes)?;
 
                 course_configs.insert(course_dir_name.to_string(), course_config);
@@ -63,7 +57,10 @@ impl ProjectsConfig {
                 }
             }
             for deleted_exercise in &deleted_exercises {
-                course_config.exercises.remove(deleted_exercise).unwrap(); // cannot fail
+                course_config
+                    .exercises
+                    .remove(deleted_exercise)
+                    .expect("this should never fail");
             }
             if !deleted_exercises.is_empty() {
                 // if any exercises were deleted, save the course config
@@ -91,22 +88,16 @@ pub struct CourseConfig {
 }
 
 impl CourseConfig {
-    pub fn save_to_projects_dir(&self, projects_dir: &Path) -> Result<()> {
+    pub fn save_to_projects_dir(&self, projects_dir: &Path) -> Result<(), LangsError> {
         file_util::lock!(projects_dir);
 
         let course_dir = projects_dir.join(&self.course);
         if !course_dir.exists() {
-            fs::create_dir_all(&course_dir).with_context(|| {
-                format!(
-                    "Failed to create course directory at {}",
-                    course_dir.display()
-                )
-            })?;
+            file_util::create_dir_all(&course_dir)?;
         }
         let target = course_dir.join("course_config.toml");
         let s = toml::to_string_pretty(&self)?;
-        fs::write(&target, s.as_bytes())
-            .with_context(|| format!("Failed to write course config to {}", target.display()))?;
+        file_util::write_to_file(s.as_bytes(), &target)?;
         Ok(())
     }
 }