Remove thiserror dependency

Author: yukibtc

Cargo.lock

@@ -19,7 +19,6 @@ tor = ["dep:arti-client", "dep:tor-hsservice", "dep:tor-hsrproxy", "dep:tor-rtco
 [dependencies]
 async-utility = "0.2"
 futures-util = { version = "0.3", default-features = false, features = ["std", "sink"] }
-thiserror = "1.0"
 url = { version = "2.5", default-features = false }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

Cargo.toml

@@ -1,38 +1,73 @@
 // Copyright (c) 2022-2024 Yuki Kishimoto
 // Distributed under the MIT software license
 
-use thiserror::Error;
+use std::{fmt, io};
+
 use tokio_tungstenite::tungstenite::Error as WsError;
 use url::ParseError;
 
 #[cfg(feature = "tor")]
 use super::tor;
 
-#[derive(Debug, Error)]
+#[derive(Debug)]
 pub enum Error {
     /// I/O error
-    #[error(transparent)]
-    IO(#[from] std::io::Error),
+    IO(io::Error),
     /// Ws error
-    #[error(transparent)]
-    Ws(#[from] WsError),
+    Ws(WsError),
     /// Socks error
     #[cfg(feature = "socks")]
-    #[error(transparent)]
-    Socks(#[from] tokio_socks::Error),
+    Socks(tokio_socks::Error),
     /// Tor error
     #[cfg(feature = "tor")]
-    #[error(transparent)]
-    Tor(#[from] tor::Error),
+    Tor(tor::Error),
     /// Url parse error
-    #[error(transparent)]
-    Url(#[from] ParseError),
+    Url(ParseError),
     /// Timeout
-    #[error("timeout")]
     Timeout,
-    /// Invalid DNS name
-    #[error("invalid DNS name")]
-    InvalidDNSName,
+}
+
+impl std::error::Error for Error {}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::IO(e) => write!(f, "{e}"),
+            Self::Ws(e) => write!(f, "{e}"),
+            #[cfg(feature = "socks")]
+            Self::Socks(e) => write!(f, "{e}"),
+            #[cfg(feature = "tor")]
+            Self::Tor(e) => write!(f, "{e}"),
+            Self::Url(e) => write!(f, "{e}"),
+            Self::Timeout => write!(f, "timeout"),
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(e: io::Error) -> Self {
+        Self::IO(e)
+    }
+}
+
+impl From<WsError> for Error {
+    fn from(e: WsError) -> Self {
+        Self::Ws(e)
+    }
+}
+
+#[cfg(feature = "socks")]
+impl From<tokio_socks::Error> for Error {
+    fn from(e: tokio_socks::Error) -> Self {
+        Self::Socks(e)
+    }
+}
+
+#[cfg(feature = "tor")]
+impl From<tor::Error> for Error {
+    fn from(e: tor::Error) -> Self {
+        Self::Tor(e)
+    }
 }
 
 impl Error {

src/native/error.rs

@@ -3,6 +3,7 @@
 
 //! Tor
 
+use std::fmt;
 use std::net::SocketAddr;
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -11,7 +12,6 @@ use arti_client::config::onion_service::OnionServiceConfigBuilder;
 use arti_client::config::{CfgPath, ConfigBuildError, TorClientConfigBuilder};
 use arti_client::{DataStream, TorClient, TorClientConfig};
 use async_utility::thread;
-use thiserror::Error;
 use tokio::sync::OnceCell;
 use tor_hsrproxy::config::{
     Encapsulation, ProxyAction, ProxyConfigBuilder, ProxyConfigError, ProxyPattern, ProxyRule,
@@ -23,20 +23,53 @@ use tor_rtcompat::PreferredRuntime;
 
 static TOR_CLIENT: OnceCell<TorClient<PreferredRuntime>> = OnceCell::const_new();
 
-#[derive(Debug, Clone, Error)]
+#[derive(Debug, Clone)]
 pub enum Error {
     /// Arti Client error
-    #[error(transparent)]
-    ArtiClient(#[from] arti_client::Error),
+    ArtiClient(arti_client::Error),
     /// Config builder error
-    #[error(transparent)]
-    ConfigBuilder(#[from] ConfigBuildError),
+    ConfigBuilder(ConfigBuildError),
     /// Proxy config error
-    #[error(transparent)]
-    ProxyConfig(#[from] ProxyConfigError),
+    ProxyConfig(ProxyConfigError),
     /// Invalid nickname
-    #[error(transparent)]
-    InvalidNickname(#[from] InvalidNickname),
+    InvalidNickname(InvalidNickname),
+}
+
+impl std::error::Error for Error {}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::ArtiClient(e) => write!(f, "{e}"),
+            Self::ConfigBuilder(e) => write!(f, "{e}"),
+            Self::ProxyConfig(e) => write!(f, "{e}"),
+            Self::InvalidNickname(e) => write!(f, "{e}"),
+        }
+    }
+}
+
+impl From<arti_client::Error> for Error {
+    fn from(e: arti_client::Error) -> Self {
+        Self::ArtiClient(e)
+    }
+}
+
+impl From<ConfigBuildError> for Error {
+    fn from(e: ConfigBuildError) -> Self {
+        Self::ConfigBuilder(e)
+    }
+}
+
+impl From<ProxyConfigError> for Error {
+    fn from(e: ProxyConfigError) -> Self {
+        Self::ProxyConfig(e)
+    }
+}
+
+impl From<InvalidNickname> for Error {
+    fn from(e: InvalidNickname) -> Self {
+        Self::InvalidNickname(e)
+    }
 }
 
 async fn init_tor_client(

src/native/tor.rs

@@ -2,85 +2,108 @@
 // Copyright (c) 2023-2024 Yuki Kishimoto
 // Distributed under the MIT software license
 
+use core::fmt;
 use core::str::Utf8Error;
 
-use thiserror::Error;
-
 use crate::wasm::CloseEvent;
 
 /// WebSocket Error
-#[derive(Debug, Clone, PartialEq, Eq, Error)]
-pub enum WsError {
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Error {
     /// UTF-8 error
-    #[error(transparent)]
-    Utf8(#[from] Utf8Error),
-
+    Utf8(Utf8Error),
     /// Invalid input to [WsState::try_from( u16 )](crate::WsState).
-    #[error("Invalid input to conversion to WsReadyState: {supplied}")]
     InvalidWsState {
         /// The user supplied value that is invalid.
         supplied: u16,
     },
-
     /// When trying to send and [WsState](crate::WsState) is anything but [WsState::Open](crate::WsState::Open) this error is returned.
-    #[error("The connection state is not \"Open\".")]
     ConnectionNotOpen,
-
     /// An invalid URL was given to [WsMeta::connect](crate::WsMeta::connect), please see:
     /// [HTML Living Standard](https://html.spec.whatwg.org/multipage/web-sockets.html#dom-websocket).
-    #[error("An invalid URL was given to the connect method: {supplied}")]
     InvalidUrl {
         /// The user supplied value that is invalid.
         supplied: String,
     },
-
     /// An invalid close code was given to a close method. For valid close codes, please see:
     /// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes).
-    #[error("An invalid close code was given to a close method: {supplied}")]
     InvalidCloseCode {
         /// The user supplied value that is invalid.
         supplied: u16,
     },
-
     /// The reason string given to a close method is longer than 123 bytes, please see:
     /// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close).
-    #[error("The reason string given to a close method is to long.")]
     ReasonStringToLong,
-
     /// Failed to connect to the server.
-    #[error("Failed to connect to the server. CloseEvent: {event:?}")]
     ConnectionFailed {
         /// The close event that might hold extra code and reason information.
         event: CloseEvent,
     },
-
     /// When converting the JavaScript Message into a WsMessage, it's possible that
     /// a String message doesn't convert correctly as Js does not guarantee that
     /// strings are valid Unicode. Happens in `impl TryFrom< MessageEvent > for WsMessage`.
-    #[error("Received a String message that couldn't be decoded to valid UTF-8")]
     InvalidEncoding,
-
     /// When converting the JavaScript Message into a WsMessage, it's not possible to
     /// convert Blob type messages, as Blob is a streaming type, that needs to be read
     /// asynchronously. If you are using the type without setting up the connection with
     /// [`WsMeta::connect`](crate::WsMeta::connect), you have to make sure to set the binary
     /// type of the connection to `ArrayBuffer`.
     ///
     /// Happens in `impl TryFrom< MessageEvent > for WsMessage`.
-    #[error("Received a Blob message that couldn't converted.")]
     CantDecodeBlob,
-
     /// When converting the JavaScript Message into a WsMessage, the data type was neither
     /// `Arraybuffer`, `String` nor `Blob`. This should never happen. If it does, please
     /// try to make a reproducible example and file an issue.
     ///
     /// Happens in `impl TryFrom< MessageEvent > for WsMessage`.
-    #[error("Received a message that is neither ArrayBuffer, String or Blob.")]
     UnknownDataType,
-
-    #[error("DOM Exception: {0}")]
     Dom(u16),
-
-    #[error("{0}")]
     Other(String),
+    Timeout,
+}
+
+impl std::error::Error for Error {}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Utf8(e) => write!(f, "{e}"),
+            Self::InvalidWsState { supplied } => {
+                write!(f, "Invalid input to conversion to WsReadyState: {supplied}")
+            }
+            Self::ConnectionNotOpen => write!(f, "The connection state is not \"Open\"."),
+            Self::InvalidUrl { supplied } => write!(
+                f,
+                "An invalid URL was given to the connect method: {supplied}"
+            ),
+            Self::InvalidCloseCode { supplied } => write!(
+                f,
+                "An invalid close code was given to a close method: {supplied}"
+            ),
+            Self::ReasonStringToLong => {
+                write!(f, "The reason string given to a close method is to long.")
+            }
+            Self::ConnectionFailed { event } => {
+                write!(f, "Failed to connect to the server. CloseEvent: {event:?}")
+            }
+            Self::InvalidEncoding => write!(
+                f,
+                "Received a String message that couldn't be decoded to valid UTF-8"
+            ),
+            Self::CantDecodeBlob => write!(f, "Received a Blob message that couldn't converted."),
+            Self::UnknownDataType => write!(
+                f,
+                "Received a message that is neither ArrayBuffer, String or Blob."
+            ),
+            Self::Dom(code) => write!(f, "DOM Exception: {code}"),
+            Self::Other(e) => write!(f, "{e}"),
+            Self::Timeout => write!(f, "timeout"),
+        }
+    }
+}
+
+impl From<Utf8Error> for Error {
+    fn from(e: Utf8Error) -> Self {
+        Self::Utf8(e)
+    }
 }

src/wasm/error.rs

@@ -4,7 +4,7 @@
 
 use web_sys::CloseEvent as JsCloseEvt;
 
-use crate::wasm::WsError;
+use crate::wasm::Error;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum WsEvent {
@@ -24,7 +24,7 @@ pub enum WsEvent {
     /// An error happened, not on the connection, but inside _ws_stream_wasm_. This currently happens
     /// when an incoming message can not be converted to Rust types, eg. a String message with invalid
     /// encoding.
-    WsErr(WsError),
+    WsErr(Error),
 }
 
 impl WsEvent {

src/wasm/event.rs

@@ -8,7 +8,7 @@ use js_sys::{ArrayBuffer, Uint8Array};
 use wasm_bindgen::JsCast;
 use web_sys::{Blob, MessageEvent};
 
-use crate::wasm::WsError;
+use crate::wasm::Error;
 
 /// Represents a WebSocket Message, after converting from JavaScript type.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -46,7 +46,7 @@ impl WsMessage {
 
     /// Attempt to get a &str from the WebSocket message,
     /// this will try to convert binary data to utf8.
-    pub fn to_text(&self) -> Result<&str, WsError> {
+    pub fn to_text(&self) -> Result<&str, Error> {
         match self {
             Self::Text(string) => Ok(string),
             Self::Binary(data) => Ok(str::from_utf8(data)?),
@@ -58,7 +58,7 @@ impl WsMessage {
 /// will only work if the connection is set to use the binary type ArrayBuffer.
 /// On binary type Blob, this will panic.
 impl TryFrom<MessageEvent> for WsMessage {
-    type Error = WsError;
+    type Error = Error;
 
     fn try_from(evt: MessageEvent) -> Result<Self, Self::Error> {
         match evt.data() {
@@ -75,15 +75,15 @@ impl TryFrom<MessageEvent> for WsMessage {
             // message.
             d if d.is_string() => match d.as_string() {
                 Some(text) => Ok(WsMessage::Text(text)),
-                None => Err(WsError::InvalidEncoding),
+                None => Err(Error::InvalidEncoding),
             },
 
             // We have set the binary mode to array buffer (WsMeta::connect), so normally this shouldn't happen.
             // That is as long as this is used within the context of the WsMeta constructor.
-            d if d.is_instance_of::<Blob>() => Err(WsError::CantDecodeBlob),
+            d if d.is_instance_of::<Blob>() => Err(Error::CantDecodeBlob),
 
             // should never happen.
-            _ => Err(WsError::UnknownDataType),
+            _ => Err(Error::UnknownDataType),
         }
     }
 }