refactor: remove anyhow usages (#51)

Author: dsherret

Cargo.lock

@@ -13,7 +13,6 @@ crate_type = ["cdylib", "lib"]
 wasm = ["console_error_panic_hook", "js-sys", "serde-wasm-bindgen", "wasm-bindgen"]
 
 [dependencies]
-anyhow = "1.0.72"
 deno_media_type = "0.1.1"
 indexmap = { version = "2.0.0", features = ["serde"] }
 log = "0.4.19"

rs_lib/Cargo.toml

@@ -1,8 +1,8 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 
-use anyhow::Error as AnyError;
 use serde::Deserialize;
 use serde::Serialize;
+use std::io::ErrorKind;
 use std::path::PathBuf;
 use std::time::SystemTime;
 use thiserror::Error;
@@ -52,24 +52,17 @@ impl<'a> Checksum<'a> {
   }
 }
 
-#[derive(Debug, Error)]
-#[error("Can't convert url (\"{}\") to filename.", .url)]
-pub struct UrlToFilenameConversionError {
-  pub(super) url: String,
-}
-
 /// Turn provided `url` into a hashed filename.
 /// URLs can contain a lot of characters that cannot be used
 /// in filenames (like "?", "#", ":"), so in order to cache
 /// them properly they are deterministically hashed into ASCII
 /// strings.
-pub fn url_to_filename(
-  url: &Url,
-) -> Result<PathBuf, UrlToFilenameConversionError> {
+pub fn url_to_filename(url: &Url) -> std::io::Result<PathBuf> {
   let Some(mut cache_filename) = base_url_to_filename(url) else {
-    return Err(UrlToFilenameConversionError {
-      url: url.to_string(),
-    });
+    return Err(std::io::Error::new(
+      ErrorKind::InvalidInput,
+      format!("Can't convert url (\"{}\") to filename.", url),
+    ));
   };
 
   let mut rest_str = url.path().to_string();
@@ -104,11 +97,7 @@ pub enum CacheReadFileError {
   #[error(transparent)]
   Io(#[from] std::io::Error),
   #[error(transparent)]
-  UrlToFileName(#[from] UrlToFilenameConversionError),
-  #[error(transparent)]
   ChecksumIntegrity(Box<ChecksumIntegrityError>),
-  #[error(transparent)]
-  ReadHeaders(anyhow::Error),
 }
 
 #[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
@@ -139,19 +128,19 @@ pub trait HttpCache: Send + Sync + std::fmt::Debug {
   fn cache_item_key<'a>(
     &self,
     url: &'a Url,
-  ) -> Result<HttpCacheItemKey<'a>, UrlToFilenameConversionError>;
+  ) -> std::io::Result<HttpCacheItemKey<'a>>;
 
   fn contains(&self, url: &Url) -> bool;
   fn set(
     &self,
     url: &Url,
     headers: HeadersMap,
     content: &[u8],
-  ) -> Result<(), AnyError>;
+  ) -> std::io::Result<()>;
   fn read_modified_time(
     &self,
     key: &HttpCacheItemKey,
-  ) -> Result<Option<SystemTime>, AnyError>;
+  ) -> std::io::Result<Option<SystemTime>>;
   fn read_file_bytes(
     &self,
     key: &HttpCacheItemKey,
@@ -162,12 +151,12 @@ pub trait HttpCache: Send + Sync + std::fmt::Debug {
   fn read_headers(
     &self,
     key: &HttpCacheItemKey,
-  ) -> Result<Option<HeadersMap>, AnyError>;
+  ) -> std::io::Result<Option<HeadersMap>>;
   /// Reads the time the item was downloaded to the cache.
   fn read_download_time(
     &self,
     key: &HttpCacheItemKey,
-  ) -> Result<Option<SystemTime>, AnyError>;
+  ) -> std::io::Result<Option<SystemTime>>;
 }
 
 #[cfg(test)]

rs_lib/src/cache.rs

@@ -1,10 +1,10 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 
+use std::io::ErrorKind;
 use std::path::Path;
 use std::path::PathBuf;
 use std::time::SystemTime;
 
-use anyhow::Error as AnyError;
 use serde::de::DeserializeOwned;
 use serde::Deserialize;
 use url::Url;
@@ -17,7 +17,6 @@ use crate::cache::CacheReadFileError;
 use crate::cache::Checksum;
 use crate::cache::GlobalToLocalCopy;
 use crate::cache::SerializedCachedUrlMetadata;
-use crate::cache::UrlToFilenameConversionError;
 use crate::common::checksum;
 use crate::common::HeadersMap;
 use crate::ChecksumIntegrityError;
@@ -42,14 +41,11 @@ impl<Env: DenoCacheEnv> GlobalHttpCache<Env> {
   pub fn get_global_cache_filepath(
     &self,
     url: &Url,
-  ) -> Result<PathBuf, AnyError> {
+  ) -> std::io::Result<PathBuf> {
     Ok(self.path.join(url_to_filename(url)?))
   }
 
-  fn get_cache_filepath(
-    &self,
-    url: &Url,
-  ) -> Result<PathBuf, UrlToFilenameConversionError> {
+  fn get_cache_filepath(&self, url: &Url) -> std::io::Result<PathBuf> {
     Ok(self.path.join(url_to_filename(url)?))
   }
 
@@ -64,11 +60,15 @@ impl<Env: DenoCacheEnv> GlobalHttpCache<Env> {
   fn read_serialized_cache_metadata<T: DeserializeOwned>(
     &self,
     key: &HttpCacheItemKey,
-  ) -> Result<Option<T>, AnyError> {
+  ) -> std::io::Result<Option<T>> {
     let path = self.key_file_path(key).with_extension("metadata.json");
     let bytes = self.env.read_file_bytes(&path)?;
     Ok(match bytes {
-      Some(bytes) => Some(serde_json::from_slice::<T>(&bytes)?),
+      Some(bytes) => {
+        Some(serde_json::from_slice::<T>(&bytes).map_err(|e| {
+          std::io::Error::new(ErrorKind::InvalidData, e.to_string())
+        })?)
+      }
       None => None,
     })
   }
@@ -78,7 +78,7 @@ impl<Env: DenoCacheEnv> HttpCache for GlobalHttpCache<Env> {
   fn cache_item_key<'a>(
     &self,
     url: &'a Url,
-  ) -> Result<HttpCacheItemKey<'a>, UrlToFilenameConversionError> {
+  ) -> std::io::Result<HttpCacheItemKey<'a>> {
     Ok(HttpCacheItemKey {
       #[cfg(debug_assertions)]
       is_local_key: false,
@@ -97,19 +97,19 @@ impl<Env: DenoCacheEnv> HttpCache for GlobalHttpCache<Env> {
   fn read_modified_time(
     &self,
     key: &HttpCacheItemKey,
-  ) -> Result<Option<SystemTime>, AnyError> {
+  ) -> std::io::Result<Option<SystemTime>> {
     #[cfg(debug_assertions)]
     debug_assert!(!key.is_local_key);
 
-    Ok(self.env.modified(self.key_file_path(key))?)
+    self.env.modified(self.key_file_path(key))
   }
 
   fn set(
     &self,
     url: &Url,
     headers: HeadersMap,
     content: &[u8],
-  ) -> Result<(), AnyError> {
+  ) -> std::io::Result<()> {
     let cache_filepath = self.get_cache_filepath(url)?;
     // Cache content
     self.env.atomic_write_file(&cache_filepath, content)?;
@@ -159,7 +159,7 @@ impl<Env: DenoCacheEnv> HttpCache for GlobalHttpCache<Env> {
   fn read_headers(
     &self,
     key: &HttpCacheItemKey,
-  ) -> Result<Option<HeadersMap>, AnyError> {
+  ) -> std::io::Result<Option<HeadersMap>> {
     // targeted deserialize
     #[derive(Deserialize)]
     struct SerializedHeaders {
@@ -178,7 +178,7 @@ impl<Env: DenoCacheEnv> HttpCache for GlobalHttpCache<Env> {
   fn read_download_time(
     &self,
     key: &HttpCacheItemKey,
-  ) -> Result<Option<SystemTime>, AnyError> {
+  ) -> std::io::Result<Option<SystemTime>> {
     // targeted deserialize
     #[derive(Deserialize)]
     struct SerializedTime {
@@ -199,9 +199,10 @@ fn write_metadata<Env: DenoCacheEnv>(
   env: &Env,
   path: &Path,
   meta_data: &SerializedCachedUrlMetadata,
-) -> Result<(), AnyError> {
+) -> std::io::Result<()> {
   let path = path.with_extension("metadata.json");
-  let json = serde_json::to_string_pretty(meta_data)?;
+  let json = serde_json::to_string_pretty(meta_data)
+    .map_err(|e| std::io::Error::new(ErrorKind::InvalidData, e.to_string()))?;
   env.atomic_write_file(&path, json.as_bytes())?;
   Ok(())
 }

rs_lib/src/global.rs

@@ -13,7 +13,6 @@ pub use cache::GlobalToLocalCopy;
 pub use cache::HttpCache;
 pub use cache::HttpCacheItemKey;
 pub use cache::SerializedCachedUrlMetadata;
-pub use cache::UrlToFilenameConversionError;
 pub use common::DenoCacheEnv;
 pub use global::GlobalHttpCache;
 pub use local::LocalHttpCache;
@@ -34,6 +33,7 @@ pub mod wasm {
 
   use crate::cache::GlobalToLocalCopy;
   use crate::common::HeadersMap;
+  use crate::CacheReadFileError;
   use crate::Checksum;
   use crate::DenoCacheEnv;
   use crate::HttpCache;
@@ -99,7 +99,7 @@ pub mod wasm {
   #[wasm_bindgen]
   pub fn url_to_filename(url: &str) -> Result<String, JsValue> {
     console_error_panic_hook::set_once();
-    let url = Url::parse(url).map_err(|e| as_js_error(e.into()))?;
+    let url = parse_url(url).map_err(as_js_error)?;
     crate::cache::url_to_filename(&url)
       .map(|s| s.to_string_lossy().to_string())
       .map_err(|e| as_js_error(e.into()))
@@ -201,8 +201,8 @@ pub mod wasm {
     fn inner<Cache: HttpCache>(
       cache: &Cache,
       url: &str,
-    ) -> anyhow::Result<Option<HeadersMap>> {
-      let url = Url::parse(url)?;
+    ) -> std::io::Result<Option<HeadersMap>> {
+      let url = parse_url(url)?;
       let key = cache.cache_item_key(&url)?;
       cache.read_headers(&key)
     }
@@ -226,16 +226,18 @@ pub mod wasm {
       url: &str,
       maybe_checksum: Option<Checksum>,
       allow_global_to_local: GlobalToLocalCopy,
-    ) -> anyhow::Result<Option<Vec<u8>>> {
-      let url = Url::parse(url)?;
+    ) -> std::io::Result<Option<Vec<u8>>> {
+      let url = parse_url(url)?;
       let key = cache.cache_item_key(&url)?;
-      match cache.read_file_bytes(
-        &key,
-        maybe_checksum,
-        allow_global_to_local,
-      )? {
-        Some(bytes) => Ok(Some(bytes)),
-        None => Ok(None),
+      match cache.read_file_bytes(&key, maybe_checksum, allow_global_to_local) {
+        Ok(Some(bytes)) => Ok(Some(bytes)),
+        Ok(None) => Ok(None),
+        Err(err) => match err {
+          CacheReadFileError::Io(err) => Err(err),
+          CacheReadFileError::ChecksumIntegrity(err) => {
+            Err(std::io::Error::new(ErrorKind::InvalidData, err.to_string()))
+          }
+        },
       }
     }
 
@@ -272,18 +274,24 @@ pub mod wasm {
       url: &str,
       headers: JsValue,
       content: &[u8],
-    ) -> anyhow::Result<()> {
-      let url = Url::parse(url)?;
+    ) -> std::io::Result<()> {
+      let url = parse_url(url)?;
       let headers: HashMap<String, String> =
-        serde_wasm_bindgen::from_value(headers)
-          .map_err(|err| anyhow::anyhow!("{}", err))?;
+        serde_wasm_bindgen::from_value(headers).map_err(|err| {
+          std::io::Error::new(ErrorKind::InvalidData, err.to_string())
+        })?;
       cache.set(&url, headers, content)
     }
 
     inner(cache, url, headers, content).map_err(as_js_error)
   }
 
-  fn as_js_error(e: anyhow::Error) -> JsValue {
+  fn parse_url(url: &str) -> std::io::Result<Url> {
+    Url::parse(url)
+      .map_err(|e| std::io::Error::new(ErrorKind::InvalidInput, e.to_string()))
+  }
+
+  fn as_js_error(e: std::io::Error) -> JsValue {
     JsValue::from(js_sys::Error::new(&e.to_string()))
   }