rework errors again

Cargo.lock

···
 ]
 
 [[package]]
-name = "anyhow"
-version = "1.0.75"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
-
-[[package]]
 name = "atty"
 version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "3.4.0"
 dependencies = [
  "ansi_term",
- "anyhow",
  "cc",
  "clap",
  "console",

syncat/Cargo.toml

···
 tempdir = "0.3.7"
 clap = { version = "4.4.6", features = ["derive"] }
 tar = "0.4.40"
-anyhow = "1.0.75"
 
 [build-dependencies]
 tar = "0.4.40"

syncat/src/config/error.rs

···
-use std::fmt::{self, Display};
-
-#[derive(Debug)]
-pub struct ConfigError {
-    pub(super) message: &'static str,
-    pub(super) source: Option<Box<dyn std::error::Error + Sync + Send>>,
-}
-
-impl Display for ConfigError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match &self.source {
-            Some(source) => source.fmt(f),
-            None => self.message.fmt(f),
-        }
-    }
-}
-
-impl std::error::Error for ConfigError {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        self.source.as_ref().map(|s| &**s as _)
-    }
-}
-
-impl From<std::io::Error> for ConfigError {
-    fn from(value: std::io::Error) -> Self {
-        Self {
-            message: "IO Error",
-            source: Some(Box::new(value)),
-        }
-    }
-}
-
-impl From<syncat_stylesheet::Error> for ConfigError {
-    fn from(value: syncat_stylesheet::Error) -> Self {
-        Self {
-            message: "Stylesheet Error",
-            source: Some(Box::new(value)),
-        }
-    }
-}

syncat/src/config/mod.rs syncat/src/config.rs

···
 use std::{fs, io};
 use syncat_stylesheet::Stylesheet;
 
-mod error;
-
-pub use error::ConfigError;
-
 const DEFAULT_CONFIG: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/config.tar"));
 
 fn normalize(path: &Path) -> PathBuf {
···
     components.into_iter().collect()
 }
 
-fn read_config<P: AsRef<Path>>(file: P) -> Result<String, ConfigError> {
+fn read_config<P: AsRef<Path>>(file: P) -> crate::Result<String> {
     let normalized = normalize(file.as_ref());
     let mut config_reader = DEFAULT_CONFIG;
-    for entry in tar::Archive::new(&mut config_reader).entries().unwrap() {
-        let entry = entry?;
+    for entry in tar::Archive::new(&mut config_reader)
+        .entries()
+        .unwrap()
+        .map(Result::unwrap)
+    {
         if entry.path().unwrap().as_ref() == normalized {
-            return Ok(io::read_to_string(entry)?);
+            return Ok(io::read_to_string(entry).expect("default config should be valid"));
         }
     }
-    Err(ConfigError {
-        message: "file not found in default configuration",
-        source: None,
-    })
+    Err(crate::Error::new("file not found in default configuration"))
 }
 
 fn config_exists<P: AsRef<Path>>(file: P) -> bool {
···
         .any(|res| res.unwrap().path().unwrap().as_ref() == file.as_ref())
 }
 
-pub fn read_to_string<P: AsRef<Path>>(file: P) -> Result<String, ConfigError> {
-    if config().join(&file).exists() {
-        Ok(fs::read_to_string(config().join(file))?)
+pub(crate) fn read_to_string<P: AsRef<Path>>(file: P) -> crate::Result<String> {
+    let path = config().join(&file);
+    if path.exists() {
+        Ok(fs::read_to_string(&path).map_err(|er| {
+            crate::Error::new("could not read config file")
+                .with_source(er)
+                .with_path(path)
+        })?)
     } else {
         read_config(file)
     }
 }
 
-pub fn load_stylesheet<P: AsRef<Path>>(file: P) -> Result<Option<Stylesheet>, ConfigError> {
-    if active_color().join(&file).exists() {
-        Ok(Some(Stylesheet::from_file(active_color().join(&file))?))
+pub(crate) fn load_stylesheet<P: AsRef<Path>>(file: P) -> crate::Result<Option<Stylesheet>> {
+    let path = active_color().join(&file);
+    if path.exists() {
+        Ok(Some(Stylesheet::from_file(&path).map_err(|er| {
+            crate::Error::new("could not read stylesheet")
+                .with_source(er)
+                .with_path(path)
+        })?))
     } else if !config_exists(Path::new("style/active").join(&file)) {
         Ok(None)
     } else {
-        Ok(Some(Stylesheet::from_file_with_resolver(
-            Path::new("style/active").join(file),
-            &ConstResolver,
-        )?))
+        Ok(Some(
+            Stylesheet::from_file_with_resolver(
+                Path::new("style/active").join(file),
+                &ConstResolver,
+            )
+            .unwrap(),
+        ))
     }
 }
 
···
 struct ConstResolver;
 
 impl syncat_stylesheet::resolver::Resolver for ConstResolver {
-    type Error = ConfigError;
+    type Error = crate::Error;
 
     fn read_to_string<P: AsRef<Path>>(&self, path: P) -> Result<String, Self::Error> {
         read_config(path)

syncat/src/language.rs

···
-use crate::config::{self, ConfigError};
+use crate::config;
 use crate::dirs::libraries;
 use libloading::{Library, Symbol};
 use std::borrow::Borrow;
···
 /// The list of languages, found in `languages.toml` in the config directory.
 #[derive(serde::Deserialize, Default)]
 #[serde(transparent)]
-pub struct LangMap(BTreeMap<String, Lang>);
+pub(crate) struct LangMap(BTreeMap<String, Lang>);
 
 impl LangMap {
-    pub fn open() -> anyhow::Result<Self> {
+    pub(crate) fn open() -> crate::Result<Self> {
         match config::read_to_string("languages.toml") {
-            Ok(string) => Ok(toml::from_str(&string)?),
+            Ok(string) => Ok(toml::from_str(&string)
+                .map_err(|er| crate::Error::new("failed to parse language map").with_source(er))?),
             Err(..) => Ok(LangMap::default()),
         }
     }
 
-    pub fn get(&self, name: &str) -> Option<&Lang> {
+    pub(crate) fn get(&self, name: &str) -> Option<&Lang> {
         self.0
             .iter()
             .find(|(key, lang)| *key == name || lang.extensions.iter().any(|i| i == name))
             .map(|(.., lang)| lang)
     }
 
-    pub fn get_strict<Q>(&self, name: &Q) -> Option<&Lang>
+    pub(crate) fn get_strict<Q>(&self, name: &Q) -> Option<&Lang>
     where
         Q: Eq + Ord,
         String: Borrow<Q>,
···
 }
 
 impl Lang {
-    fn load(&self) -> anyhow::Result<bool> {
+    fn load(&self) -> crate::Result<bool> {
         if self.lib.borrow().is_some() {
             return Ok(true);
         }
···
         if !lib_dir.exists() {
             return Ok(false);
         }
-        let lib_name = fs::read_dir(&lib_dir)?
+        let lib_name = fs::read_dir(&lib_dir)
+            .map_err(|er| {
+                crate::Error::new("language directory not found")
+                    .with_source(er)
+                    .with_path(&lib_dir)
+            })?
             .filter_map(|entry| entry.ok())
             .map(|entry| entry.path())
             .find(|path| {
···
                     .filter(|path| path.contains("syncat"))
                     .is_some()
             })
-            .ok_or_else(|| anyhow::anyhow!("Language is not installed correctly."))?;
-        let library = Library::new(lib_dir.join(lib_name))?;
+            .ok_or_else(|| crate::Error::new("language is not installed correctly."))?;
+        let library = Library::new(lib_dir.join(lib_name))
+            .map_err(|er| crate::Error::new("language could not be loaded").with_source(er))?;
         *self.lib.borrow_mut() = Some(library);
         Ok(true)
     }
 
-    pub fn parser(&self) -> anyhow::Result<Option<Parser>> {
+    pub(crate) fn parser(&self) -> crate::Result<Option<Parser>> {
         if !self.load()? {
             return Ok(None);
         }
         let language = unsafe {
             let borrow = self.lib.borrow();
             let lib = borrow.as_ref().unwrap();
-            let get_language: Symbol<unsafe extern "C" fn() -> Language> =
-                lib.get(format!("tree_sitter_{}", self.name).as_bytes())?;
+            let get_language: Symbol<unsafe extern "C" fn() -> Language> = lib
+                .get(format!("tree_sitter_{}", self.name).as_bytes())
+                .map_err(|er| {
+                    crate::Error::new(format!(
+                        "tree_sitter_{} not found in language library",
+                        self.name
+                    ))
+                    .with_source(er)
+                })?;
             get_language()
         };
 
         let mut parser = Parser::new();
-        parser.set_language(language)?;
+        parser
+            .set_language(language)
+            .map_err(|er| crate::Error::new("tree sitter").with_source(er))?;
         Ok(Some(parser))
     }
 
-    pub fn style(&self) -> Result<Stylesheet, ConfigError> {
+    pub(crate) fn style(&self) -> crate::Result<Stylesheet> {
         config::load_stylesheet(Path::new(&self.name).with_extension("syncat"))
             .map(|opt| opt.unwrap_or_default())
     }

syncat/src/main.rs

···
+use clap::{ArgAction, Parser};
 use std::fs;
 use std::io::{self, Read};
 use std::path::{Path, PathBuf};
-
-use clap::{ArgAction, Parser};
 
 mod colorize;
 mod config;
···
 mod package_manager;
 
 use colorize::Colorizer;
-use error::Error;
+use error::{Error, Result};
 use language::LangMap;
 use line::Line;
 use meta_stylesheet::MetaStylesheet;
···
 }
 
 impl Syncat {
-    fn new(opts: Opts) -> anyhow::Result<Self> {
+    fn new(opts: Opts) -> error::Result<Self> {
         let lang_map = LangMap::open()?;
         let meta_style = MetaStylesheet::from_file()?;
         Ok(Self {
···
         })
     }
 
-    fn colorize(&self, language: Option<&str>, source: String) -> anyhow::Result<String> {
+    fn colorize(&self, language: Option<&str>, source: String) -> crate::Result<String> {
         let language = self
             .opts
             .language
···
         language: Option<&str>,
         source: String,
         path: Option<&Path>,
-    ) -> anyhow::Result<Vec<Line>> {
+    ) -> crate::Result<Vec<Line>> {
         let source = self.colorize(language, source)?;
 
         if self.opts.dev {
···
     fn print<'a>(
         &self,
         sources: impl IntoIterator<Item = error::Result<Source<'a>>> + ExactSizeIterator,
-    ) -> anyhow::Result<()> {
+    ) -> crate::Result<()> {
         let count = sources.len();
         let mut line_numbers = filter::line_numbers(&self.opts);
         for (index, source) in sources.into_iter().enumerate() {
···
     }
 }
 
-fn try_main() -> anyhow::Result<()> {
+fn try_main() -> error::Result<()> {
     let opts = Opts::parse();
     match &opts.command {
         Some(subcommand) => package_manager::main(subcommand),
···
             // These lines cannot be syntax highlighted, as we do not know what the language is.
             loop {
                 let mut line = String::new();
-                if io::stdin().read_line(&mut line)? == 0 {
+                if io::stdin()
+                    .read_line(&mut line)
+                    .map_err(|er| crate::Error::new("could not read stdin").with_source(er))?
+                    == 0
+                {
                     return Ok(());
                 }
                 print!("{}", line);
···
             // at once using the specified language.
             let mut stdin = io::stdin();
             let mut source = String::new();
-            stdin.read_to_string(&mut source)?;
+            stdin
+                .read_to_string(&mut source)
+                .map_err(|er| crate::Error::new("could not read stdin").with_source(er))?;
             let syncat = Syncat::new(opts)?;
             syncat.print(std::iter::once(Ok(Source {
                 language: None,
···
 
 fn main() {
     if let Err(error) = try_main() {
-        eprintln!("syncat: {}", error);
+        eprintln!("{}", error);
         std::process::exit(1);
     }
 }

syncat/src/meta_stylesheet.rs

···
 }
 
 impl MetaStylesheet {
-    pub fn from_file() -> anyhow::Result<MetaStylesheet> {
+    pub(crate) fn from_file() -> crate::Result<MetaStylesheet> {
         let mut meta_stylesheet = MetaStylesheet::default();
-        if let Some(stylesheet) = config::load_stylesheet(".syncat")? {
+        if let Some(stylesheet) = config::load_stylesheet(".syncat")
+            .map_err(|er| crate::Error::new("failed to load meta stylesheet").with_source(er))?
+        {
             if let Some(style) = stylesheet.style(&"line_ending".into()) {
                 meta_stylesheet.line_ending = style.try_into()?;
             }
···
         &self.title.style
     }
 }
+
+impl From<FromValueError> for crate::Error {
+    fn from(value: FromValueError) -> Self {
+        Self::new("failed to parse meta stylesheet value").with_source(value)
+    }
+}

syncat/src/package_manager.rs

···
     Ok(())
 }
 
-pub(crate) fn main(opts: &Subcommand) -> anyhow::Result<()> {
+pub(crate) fn main(opts: &Subcommand) -> crate::Result<()> {
     let lang_map = LangMap::open()?;
     if !libraries().exists() {
-        fs::create_dir_all(libraries())?;
+        // Don't really care about this error, it's a sketchy side effect anyway.
+        fs::create_dir_all(libraries()).ok();
     }
 
     match opts {
···
         Subcommand::Remove { language } => {
             if let Some(lang) = lang_map.get_strict(language) {
                 let directory = libraries().join(&lang.library);
-                fs::remove_dir_all(directory)?;
+                fs::remove_dir_all(directory)
+                    .map_err(|er| crate::Error::new("failed to remove language").with_source(er))?;
                 println!("Language `{}` has been removed", language);
             } else {
                 println!("No language `{}` is installed", language);