error handling workover

Author: Alexander Weber

.complate/config.yaml

@@ -36,7 +36,7 @@ templates:
             e.echo:
                 check:
                     text: Select the components that are affected
-                    separator: "\n"
+                    separator: ", "
                     options:
                       alpha:
                         display: alpha
@@ -46,4 +46,4 @@ templates:
                         display: bravo
                         value:
                           shell: printf bravo
-                      
+

.vscode/settings.json

@@ -3,4 +3,4 @@
         "backend+cli",
         "backend+ui",
     ]
-}
+}

src/args/mod.rs

@@ -1,4 +1,4 @@
-use std::io::Result;
+use std::result::Result;
 
 pub struct CallArgs {
     pub privileges: Privilege,
@@ -7,24 +7,18 @@ pub struct CallArgs {
 
 impl CallArgs {
     #[allow(clippy::single_match)]
-    pub async fn validate(&self) -> Result<()> {
+    pub async fn validate(&self) -> Result<(), Box<dyn std::error::Error>> {
         match self.privileges {
             Privilege::Normal => match &self.command {
                 Command::Render(args) => {
                     match args.backend {
                         #[cfg(feature = "backend+ui")]
-                        Backend::UI => return Err(std::io::Error::new(
-                            std::io::ErrorKind::Other,
-                            "can not use backend+ui without experimental features being activated",
-                        )),
+                        Backend::UI => return Err(Box::new(crate::error::NeedExperimentalFlag::default())),
                         #[cfg(feature = "backend+cli")]
                         Backend::CLI => {}
                     };
                     if args.value_overrides.len() > 0 {
-                        return Err(std::io::Error::new(
-                            std::io::ErrorKind::Other,
-                            "value overrides is an experimental feature and needs the respective flag to be active",
-                        ));
+                        return Err(Box::new(crate::error::NeedExperimentalFlag::default()));
                     }
                     #[allow(unreachable_code)]
                     Ok(())
@@ -70,7 +64,7 @@ pub enum Backend {
 pub struct ClapArgumentLoader {}
 
 impl ClapArgumentLoader {
-    pub async fn load_from_cli() -> std::io::Result<CallArgs> {
+    pub async fn load_from_cli() -> std::result::Result<CallArgs, Box<dyn std::error::Error>> {
         let mut backend_values = Vec::new();
         if cfg!(feature = "backend+cli") {
             backend_values.push("cli");
@@ -159,10 +153,7 @@ impl ClapArgumentLoader {
                     let config_param = x.value_of("config").unwrap();
                     std::fs::read_to_string(config_param.to_owned())?
                 } else {
-                    return Err(std::io::Error::new(
-                        std::io::ErrorKind::Other,
-                        "configuration not specified",
-                    ));
+                    return Err(Box::new(crate::error::Failed::new("configuration unspecified")));
                 };
 
                 let template = if x.is_present("template") {
@@ -197,10 +188,7 @@ impl ClapArgumentLoader {
                         #[cfg(feature = "backend+ui")]
                         "ui" => Backend::UI,
                         _ => {
-                            return Err(std::io::Error::new(
-                                std::io::ErrorKind::Other,
-                                "unknown backend configuration",
-                            ))
+                            return Err(Box::new(crate::error::Failed::new("no backend specified")))
                         }
                     },
                     #[cfg(feature = "backend+cli")]
@@ -221,10 +209,7 @@ impl ClapArgumentLoader {
                     }),
                 })
             }
-            None => Err(std::io::Error::new(
-                std::io::ErrorKind::Other,
-                "could not resolve subcommand",
-            )),
+            None => Err(Box::new(crate::error::UnknownCommand::default())),
         }
     }
 }

src/error.rs

@@ -0,0 +1,36 @@
+macro_rules! make_error {
+    ($name:ident) => {
+        #[derive(Debug, Clone)]
+        /// An error type.
+        pub struct $name {
+            details: String,
+        }
+
+        impl $name {
+            pub fn default() -> Self {
+                Self::new("")
+            }
+
+            /// Error type constructor.
+            pub fn new(details: &str) -> Self {
+                Self {
+                    details: details.to_owned(),
+                }
+            }
+        }
+
+        impl std::fmt::Display for $name {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                f.write_str(&self.details)
+            }
+        }
+
+        impl std::error::Error for $name {}
+    };
+}
+
+make_error!(Failed);
+make_error!(NeedExperimentalFlag);
+make_error!(UnknownCommand);
+make_error!(UserAbort);
+make_error!(NoShellTrust);

src/main.rs

@@ -2,67 +2,69 @@ include!("check_features.rs");
 
 use futures::executor::block_on;
 
-use std::io::{Result, Write};
+use std::io::Write;
+use std::result::Result;
 
 pub mod args;
 pub mod config;
 pub mod render;
+pub mod error;
 
 async fn default_config() -> String {
     r###"version: 0.10
-    templates:
-        one:
-            content:
-                file: ./.complate/templates/arbitraty-template-file.tpl
-            values:
-                a.summary:
-                    static: "random summary"
-        two:
-            content:
-                inline: |-
-                    {{ a.alpha }}
-                    {{ b.bravo }}
-                    {{ c.charlie }}
-                    {{ d.delta }}
-                    {{ e.echo }}
-            values:
-                a.alpha:
-                  prompt: "alpha"
-                b.bravo:
-                  shell: "printf bravo"
-                c.charlie:
-                  static: "charlie"
-                d.delta:
-                    select:
-                        text: Select the version level that shall be incremented
-                        options:
-                          alpha:
-                            display: alpha
-                            value:
-                              static: alpha
-                          bravo:
-                            display: bravo
-                            value:
-                              shell: printf bravo
-                e.echo:
-                    check:
-                        text: Select the components that are affected
-                        separator: ", "
-                        options:
-                          alpha:
-                            display: alpha
-                            value:
-                              static: alpha
-                          bravo:
-                            display: bravo
-                            value:
-                              shell: printf bravo
+templates:
+    one:
+        content:
+            file: ./.complate/templates/arbitraty-template-file.tpl
+        values:
+            a.summary:
+                static: "random summary"
+    two:
+        content:
+            inline: |-
+                {{ a.alpha }}
+                {{ b.bravo }}
+                {{ c.charlie }}
+                {{ d.delta }}
+                {{ e.echo }}
+        values:
+            a.alpha:
+              prompt: "alpha"
+            b.bravo:
+              shell: "printf bravo"
+            c.charlie:
+              static: "charlie"
+            d.delta:
+                select:
+                    text: Select the version level that shall be incremented
+                    options:
+                      alpha:
+                        display: alpha
+                        value:
+                          static: alpha
+                      bravo:
+                        display: bravo
+                        value:
+                          shell: printf bravo
+            e.echo:
+                check:
+                    text: Select the components that are affected
+                    separator: ", "
+                    options:
+                      alpha:
+                        display: alpha
+                        value:
+                          static: alpha
+                      bravo:
+                        display: bravo
+                        value:
+                          shell: printf bravo
 
 "###
     .to_owned()
 }
 
-async fn async_main() -> Result<()> {
+async fn async_main() -> Result<(), Box<dyn std::error::Error>> {
     let cmd = crate::args::ClapArgumentLoader::load_from_cli().await?;
     cmd.validate().await?;
 
@@ -80,6 +82,6 @@ async fn async_main() -> Result<()> {
     }
 }
 
-fn main() -> Result<()> {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     block_on(async_main())
 }

src/render/cli.rs

@@ -1,6 +1,6 @@
 use super::UserInput;
 use async_trait::async_trait;
-use std::io::Result;
+use std::result::Result;
 
 pub struct CLIBackend<'a> {
     shell_trust: &'a super::ShellTrust,
@@ -14,22 +14,25 @@ impl<'a> CLIBackend<'a> {
 
 #[async_trait]
 impl<'a> UserInput for CLIBackend<'a> {
-    async fn prompt(&self, text: &str) -> Result<String> {
-        dialoguer::Input::new()
+    async fn prompt(&self, text: &str) -> Result<String, Box<dyn std::error::Error>> {
+        match dialoguer::Input::new()
             .allow_empty(true)
             .with_prompt(text)
-            .interact()
+            .interact() {
+                Ok(res) => Ok(res),
+                Err(_) => Err(Box::new(crate::error::Failed::default()))
+            }
     }
 
-    async fn shell(&self, command: &str, shell_trust: &super::ShellTrust) -> Result<String> {
+    async fn shell(&self, command: &str, shell_trust: &super::ShellTrust) -> Result<String, Box<dyn std::error::Error>> {
         super::shell(command, shell_trust, &super::Backend::CLI).await
     }
 
     async fn select(
         &self,
         prompt: &str,
         options: &std::collections::BTreeMap<String, super::Option>,
-    ) -> Result<String> {
+    ) -> Result<String, Box<dyn std::error::Error>> {
         let keys = options.keys().cloned().collect::<Vec<String>>();
         let display_vals = options
             .values()
@@ -53,7 +56,7 @@ impl<'a> UserInput for CLIBackend<'a> {
         prompt: &str,
         separator: &str,
         options: &std::collections::BTreeMap<String, super::Option>,
-    ) -> Result<String> {
+    ) -> Result<String, Box<dyn std::error::Error>> {
         let keys = options.keys().cloned().collect::<Vec<String>>();
         let display_vals = options
             .values()