fix(credential)!: Decouple ErrorKind from BoxError

BREAKING CHANGE: `Error` because an opaque type with the enum broken out
into `ErrorKind`
- To construct an error from an `ErrorKind`, you can use `Into`.
- To wrap an existing error, use `Error::other`

Author: epage

credential/cargo-credential-1password/src/main.rs

@@ -4,7 +4,7 @@
 #![allow(clippy::print_stderr)]
 
 use cargo_credential::{
-    Action, CacheControl, Credential, CredentialResponse, Error, RegistryInfo, Secret,
+    Action, CacheControl, Credential, CredentialResponse, Error, ErrorKind, RegistryInfo, Secret,
 };
 use serde::Deserialize;
 use std::io::Read;
@@ -278,7 +278,7 @@ impl Credential for OnePasswordCredential {
                             operation_independent: true,
                         })
                 } else {
-                    Err(Error::NotFound)
+                    Err(ErrorKind::NotFound.into())
                 }
             }
             Action::Login(options) => {
@@ -301,10 +301,10 @@ impl Credential for OnePasswordCredential {
                     op.delete(&session, &id)?;
                     Ok(CredentialResponse::Logout)
                 } else {
-                    Err(Error::NotFound)
+                    Err(ErrorKind::NotFound.into())
                 }
             }
-            _ => Err(Error::OperationNotSupported),
+            _ => Err(ErrorKind::OperationNotSupported.into()),
         }
     }
 }

credential/cargo-credential-libsecret/src/lib.rs

@@ -4,8 +4,8 @@ mod linux {
 
     use anyhow::Context;
     use cargo_credential::{
-        read_token, Action, CacheControl, Credential, CredentialResponse, Error, RegistryInfo,
-        Secret,
+        read_token, Action, CacheControl, Credential, CredentialResponse, Error, ErrorKind,
+        RegistryInfo, Secret,
     };
     use libloading::{Library, Symbol};
     use std::ffi::{CStr, CString};
@@ -153,7 +153,7 @@ mod linux {
                             .into());
                         }
                         if token_c.is_null() {
-                            return Err(Error::NotFound);
+                            return Err(ErrorKind::NotFound.into());
                         }
                         let token = Secret::from(
                             CStr::from_ptr(token_c)
@@ -223,7 +223,7 @@ mod linux {
                     }
                     Ok(CredentialResponse::Logout)
                 }
-                _ => Err(Error::OperationNotSupported),
+                _ => Err(ErrorKind::OperationNotSupported.into()),
             }
         }
     }

credential/cargo-credential-macos-keychain/src/lib.rs

@@ -5,7 +5,8 @@
 #[cfg(target_os = "macos")]
 mod macos {
     use cargo_credential::{
-        read_token, Action, CacheControl, Credential, CredentialResponse, Error, RegistryInfo,
+        read_token, Action, CacheControl, Credential, CredentialResponse, Error, ErrorKind,
+        RegistryInfo,
     };
     use security_framework::os::macos::keychain::SecKeychain;
 
@@ -31,7 +32,7 @@ mod macos {
             let not_found = security_framework::base::Error::from(NOT_FOUND).code();
             match action {
                 Action::Get(_) => match keychain.find_generic_password(&service_name, ACCOUNT) {
-                    Err(e) if e.code() == not_found => Err(Error::NotFound),
+                    Err(e) if e.code() == not_found => Err(ErrorKind::NotFound.into()),
                     Err(e) => Err(Box::new(e).into()),
                     Ok((pass, _)) => {
                         let token = String::from_utf8(pass.as_ref().to_vec()).map_err(Box::new)?;
@@ -64,14 +65,14 @@ mod macos {
                     Ok(CredentialResponse::Login)
                 }
                 Action::Logout => match keychain.find_generic_password(&service_name, ACCOUNT) {
-                    Err(e) if e.code() == not_found => Err(Error::NotFound),
+                    Err(e) if e.code() == not_found => Err(ErrorKind::NotFound.into()),
                     Err(e) => Err(Box::new(e).into()),
                     Ok((_, item)) => {
                         item.delete();
                         Ok(CredentialResponse::Logout)
                     }
                 },
-                _ => Err(Error::OperationNotSupported),
+                _ => Err(ErrorKind::OperationNotSupported.into()),
             }
         }
     }

credential/cargo-credential-wincred/src/lib.rs

@@ -3,7 +3,7 @@
 #[cfg(windows)]
 mod win {
     use cargo_credential::{read_token, Action, CacheControl, CredentialResponse, RegistryInfo};
-    use cargo_credential::{Credential, Error};
+    use cargo_credential::{Credential, Error, ErrorKind};
     use std::ffi::OsStr;
 
     use std::os::windows::ffi::OsStrExt;
@@ -56,7 +56,7 @@ mod win {
                         {
                             let err = std::io::Error::last_os_error();
                             if err.raw_os_error() == Some(ERROR_NOT_FOUND as i32) {
-                                return Err(Error::NotFound);
+                                return Err(ErrorKind::NotFound.into());
                             }
                             return Err(Box::new(err).into());
                         }
@@ -107,13 +107,13 @@ mod win {
                     if result != TRUE {
                         let err = std::io::Error::last_os_error();
                         if err.raw_os_error() == Some(ERROR_NOT_FOUND as i32) {
-                            return Err(Error::NotFound);
+                            return Err(ErrorKind::NotFound.into());
                         }
                         return Err(Box::new(err).into());
                     }
                     Ok(CredentialResponse::Logout)
                 }
-                _ => Err(Error::OperationNotSupported),
+                _ => Err(ErrorKind::OperationNotSupported.into()),
             }
         }
     }

credential/cargo-credential/examples/file-provider.rs

@@ -21,11 +21,11 @@ impl Credential for FileCredential {
             // another provider for any other registry.
             //
             // If a provider supports any registry, then this check should be omitted.
-            return Err(cargo_credential::Error::UrlNotSupported);
+            return Err(cargo_credential::ErrorKind::UrlNotSupported.into());
         }
 
         // `Error::Other` takes a boxed `std::error::Error` type that causes Cargo to show the error.
-        let mut creds = FileCredential::read().map_err(cargo_credential::Error::Other)?;
+        let mut creds = FileCredential::read().map_err(cargo_credential::Error::other)?;
 
         match action {
             Action::Get(_) => {
@@ -39,7 +39,7 @@ impl Credential for FileCredential {
                 } else {
                     // Credential providers should respond with `NotFound` when a credential can not be
                     // found, allowing Cargo to attempt another provider.
-                    Err(cargo_credential::Error::NotFound)
+                    Err(cargo_credential::ErrorKind::NotFound.into())
                 }
             }
             Action::Login(login_options) => {
@@ -50,7 +50,7 @@ impl Credential for FileCredential {
                 let token = cargo_credential::read_token(login_options, registry)?;
                 creds.insert(registry.index_url.to_string(), token);
 
-                FileCredential::write(&creds).map_err(cargo_credential::Error::Other)?;
+                FileCredential::write(&creds).map_err(cargo_credential::Error::other)?;
 
                 // Credentials were successfully stored.
                 Ok(CredentialResponse::Login)
@@ -59,14 +59,14 @@ impl Credential for FileCredential {
                 if creds.remove(registry.index_url).is_none() {
                     // If the user attempts to log out from a registry that has no credentials
                     // stored, then NotFound is the appropriate error.
-                    Err(cargo_credential::Error::NotFound)
+                    Err(cargo_credential::ErrorKind::NotFound.into())
                 } else {
                     // Credentials were successfully erased.
                     Ok(CredentialResponse::Logout)
                 }
             }
             // If a credential provider doesn't support a given operation, it should respond with `OperationNotSupported`.
-            _ => Err(cargo_credential::Error::OperationNotSupported),
+            _ => Err(cargo_credential::ErrorKind::OperationNotSupported.into()),
         }
     }
 }

credential/cargo-credential/examples/stdout-redirected.rs

@@ -3,7 +3,7 @@
 #![allow(clippy::print_stderr)]
 #![allow(clippy::print_stdout)]
 
-use cargo_credential::{Action, Credential, CredentialResponse, Error, RegistryInfo};
+use cargo_credential::{Action, Credential, CredentialResponse, Error, ErrorKind, RegistryInfo};
 
 struct MyCredential;
 
@@ -19,7 +19,7 @@ impl Credential for MyCredential {
 
         // Reading from stdin and writing to stdout will go to the attached console (tty).
         println!("message from test credential provider");
-        Err(Error::OperationNotSupported)
+        Err(ErrorKind::OperationNotSupported.into())
     }
 }