MVP

src/credentials.rs

@@ -12,14 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use displaydoc::Display;
+use eyre::Context;
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, env, path::PathBuf};
 use thiserror::Error;
 use tokio::fs;
 
 use crate::{
-    errors::{DeserializationError, SerializationError},
+    errors::{DeserializationError, ReadError, SerializationError, WriteError},
     registry::RegistryUri,
 };
 
@@ -35,99 +35,68 @@ pub struct Credentials {
     pub registry_tokens: HashMap<RegistryUri, String>,
 }
 
-#[derive(Error, Display, Debug)]
-#[non_exhaustive]
-#[allow(missing_docs)]
-pub enum LocateError {
-    /// the home folder could not be determined
-    MissingHome,
-}
-
-#[derive(Error, Display, Debug)]
-#[non_exhaustive]
-#[allow(missing_docs)]
-pub enum ExistsError {
-    /// could not locate the credentials file
-    Locate(#[from] LocateError),
-    /// could not access the filesystem
-    Io(#[from] std::io::Error),
-}
+const BUFFRS_HOME_VAR: &str = "BUFFRS_HOME";
 
-#[derive(Error, Display, Debug)]
-#[non_exhaustive]
-#[allow(missing_docs)]
-pub enum ReadError {
-    /// could not locate the credentials file
-    Locate(#[from] LocateError),
-    /// could not read the file
-    Io(#[from] std::io::Error),
-    /// could not deserialize the credentials
-    Deserialize(#[from] DeserializationError),
-}
-
-#[derive(Error, Display, Debug)]
-#[non_exhaustive]
-#[allow(missing_docs)]
-pub enum WriteError {
-    /// could not locate the credentials file
-    Locate(#[from] LocateError),
-    /// could not write to the file
-    Io(#[from] std::io::Error),
-    /// could not serialize the credentials
-    Serialize(#[from] SerializationError),
-}
+#[derive(Error, Debug)]
+#[error("could not determine credentials location")]
+struct LocateError(#[from] eyre::Report);
 
 impl Credentials {
     fn location() -> Result<PathBuf, LocateError> {
-        env::var("BUFFRS_HOME")
+        env::var(BUFFRS_HOME_VAR)
             .map(PathBuf::from)
-            .or(home::home_dir().ok_or(LocateError::MissingHome))
-            .map(|home| home.join(BUFFRS_HOME).join(CREDENTIALS_FILE))
+            .or_else(|_| {
+                home::home_dir()
+                    .ok_or_else(|| eyre::eyre!("{BUFFRS_HOME_VAR} is not set and the user's home folder could not be determined"))
+            })
+            .map(|home| home.join(BUFFRS_HOME).join(CREDENTIALS_FILE)).map_err(LocateError::from)
     }
 
     /// Checks if the credentials exists
-    pub async fn exists() -> Result<bool, ExistsError> {
+    pub async fn exists() -> eyre::Result<bool> {
         fs::try_exists(Self::location()?)
             .await
-            .map_err(ExistsError::from)
+            .wrap_err_with(|| format!("failed to determine if {CREDENTIALS_FILE} file exists"))
     }
 
     /// Reads the credentials from the file system
-    pub async fn read() -> Result<Self, ReadError> {
-        let raw: RawCredentialCollection =
-            toml::from_str(&fs::read_to_string(Self::location()?).await?)
-                .map_err(DeserializationError::from)?;
+    pub async fn read() -> eyre::Result<Self> {
+        let raw: RawCredentialCollection = toml::from_str(
+            &fs::read_to_string(Self::location()?)
+                .await
+                .wrap_err_with(|| ReadError(CREDENTIALS_FILE))?,
+        )
+        .wrap_err_with(|| DeserializationError("credentials"))?;
 
         Ok(raw.into())
     }
 
     /// Writes the credentials to the file system
-    pub async fn write(&self) -> Result<(), WriteError> {
+    pub async fn write(&self) -> eyre::Result<()> {
         fs::create_dir(
-            Self::location()
-                .map_err(WriteError::Locate)?
+            Self::location()?
                 .parent()
                 .expect("unexpected error: resolved credentials path has no parent"),
         )
         .await
-        .ok();
+        .ok(); // ok to ignore if parent already exists (other failure modes covered by expect above)
 
         let data: RawCredentialCollection = self.clone().into();
 
         fs::write(
             Self::location()?,
             toml::to_string(&data)
-                .map_err(SerializationError::from)?
+                .wrap_err_with(|| SerializationError("credentials"))?
                 .into_bytes(),
         )
         .await
-        .map_err(WriteError::from)
+        .wrap_err_with(|| WriteError(CREDENTIALS_FILE))
     }
 
     /// Loads the credentials from the file system
     ///
     /// Note: Initializes the credential file if its not present
-    pub async fn load() -> Result<Self, WriteError> {
+    pub async fn load() -> eyre::Result<Self> {
         let Ok(credentials) = Self::read().await else {
             let credentials = Credentials::default();
             credentials.write().await?;

src/errors.rs

@@ -1,16 +1,5 @@
-use displaydoc::Display;
 use url::Url;
 
-/// Wrapper for a generic serialization error
-#[derive(thiserror::Error, Debug)]
-#[error(transparent)]
-pub struct DeserializationError(#[from] toml::de::Error);
-
-/// Wrapper for a generic serialization error
-#[derive(thiserror::Error, Debug)]
-#[error(transparent)]
-pub struct SerializationError(#[from] toml::ser::Error);
-
 /// Request failure context
 #[derive(thiserror::Error, Debug)]
 #[error("{method} request to {url}")]
@@ -88,22 +77,38 @@ impl ResponseError {
     }
 }
 
-#[derive(thiserror::Error, Display, Debug)]
-#[allow(missing_docs)]
-pub enum ConfigError {
-    /// unknown error
-    Unknown,
-}
-
-#[derive(thiserror::Error, Display, Debug)]
-#[allow(missing_docs)]
-pub enum HttpError {
-    /// failed to make an http request
+#[derive(thiserror::Error, Debug)]
+pub(crate) enum HttpError {
+    #[error("failed to make an http request")]
     Request(#[from] RequestError),
-    /// remote produced an error response
+    #[error("remote produced an error response")]
     Response(#[from] ResponseError),
-    /// unauthorized - please provide registry credentials with `buffrs login`
+    #[error("unauthorized - please provide registry credentials with `buffrs login`")]
     Unauthorized,
-    /// {0}
+    #[error("{0}")]
     Other(String),
 }
+
+#[derive(thiserror::Error, Debug)]
+#[error("environment variable {0} is not set")]
+pub(crate) struct EnvVarNotSet(pub &'static str);
+
+#[derive(thiserror::Error, Debug)]
+#[error("could not write to {0} file")]
+pub(crate) struct WriteError(pub &'static str);
+
+#[derive(thiserror::Error, Debug)]
+#[error("could not read from {0} file")]
+pub(crate) struct ReadError(pub &'static str);
+
+#[derive(thiserror::Error, Debug)]
+#[error("could not deserialize {0}")]
+pub(crate) struct DeserializationError(pub &'static str);
+
+#[derive(thiserror::Error, Debug)]
+#[error("could not serialize {0}")]
+pub(crate) struct SerializationError(pub &'static str);
+
+#[derive(thiserror::Error, Debug)]
+#[error("file `{0}` is missing")]
+pub(crate) struct FileNotFound(pub String);

src/generator.rs

@@ -17,23 +17,19 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use displaydoc::Display;
+use eyre::Context;
 use protoc_bin_vendored::protoc_bin_path;
 use serde::{Deserialize, Serialize};
-use thiserror::Error;
 
-use crate::{
-    manifest::{self, Manifest},
-    package::PackageStore,
-};
+use crate::{manifest::Manifest, package::PackageStore};
 
 /// The language used for code generation
 #[derive(
     Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, clap::ValueEnum,
 )]
 #[serde(rename_all = "kebab-case")]
+#[allow(missing_docs)] // trivial enum
 pub enum Language {
-    /// The Python language
     Python,
 }
 
@@ -57,26 +53,13 @@ pub enum Generator {
     },
 }
 
-#[derive(Error, Display, Debug)]
-#[allow(missing_docs)]
-pub enum RunError {
-    /// unable to locate vendored protoc
-    Locate,
-    /// io error
-    Io(#[from] std::io::Error),
-    /// a signal interrupted the protoc subprocess before it could complete
-    Interrupted,
-    /// the protoc subprocess terminated with an error: {code}
-    NonZeroExitCode { code: i32, stderr: Vec<u8> },
-}
-
 impl Generator {
     /// Tonic include file name
     pub const TONIC_INCLUDE_FILE: &str = "buffrs.rs";
 
     /// Run the generator for a dependency and output files at the provided path
-    pub async fn run(&self) -> Result<(), RunError> {
-        let protoc = protoc_bin_path().map_err(|_| RunError::Locate)?;
+    pub async fn run(&self) -> eyre::Result<()> {
+        let protoc = protoc_bin_path().wrap_err("unable to locate vendored protoc")?;
 
         std::env::set_var("PROTOC", protoc.clone());
 
@@ -117,13 +100,12 @@ impl Generator {
 
                 let output = protoc_cmd.output().await?;
 
-                let exit = output.status.code().ok_or(RunError::Interrupted)?;
+                let exit = output.status.code().ok_or(eyre::eyre!(
+                    "a signal interrupted the protoc subprocess before it could complete"
+                ))?;
 
                 if exit != 0 {
-                    return Err(RunError::NonZeroExitCode {
-                        code: exit,
-                        stderr: output.stderr,
-                    });
+                    eyre::bail!("the protoc subprocess terminated with an error: {exit}");
                 }
 
                 tracing::info!(":: {language} code generated successfully");
@@ -134,29 +116,18 @@ impl Generator {
     }
 }
 
-#[derive(Error, Display, Debug)]
-#[allow(missing_docs)]
-pub enum GenerateError {
-    /// failed to read the manifest
-    ManifestRead(#[from] manifest::ReadError),
-    /// either a compilable package (library or api) or at least one dependency is needed to generate code bindings
-    NothingToGenerate,
-    /// failed to generate bindings
-    RunFailed(#[from] RunError),
-}
-
 impl Generator {
     /// Execute code generation with pre-configured parameters
-    pub async fn generate(&self) -> Result<(), GenerateError> {
+    pub async fn generate(&self) -> eyre::Result<()> {
         let manifest = Manifest::read().await?;
 
         tracing::info!(":: initializing code generator");
 
         if !manifest.package.kind.compilable() && manifest.dependencies.is_empty() {
-            return Err(GenerateError::NothingToGenerate);
+            eyre::bail!("either a compilable package (library or api) or at least one dependency is needed to generate code bindings");
         }
 
-        self.run().await?;
+        self.run().await.wrap_err("failed to generate bindings")?;
 
         if manifest.package.kind.compilable() {
             let location = Path::new(PackageStore::PROTO_PATH);