feat: add script::builder

src/script.rs

@@ -1,8 +1,10 @@
 use std::sync::Arc;
 
+use builder::Builder;
 use parameter::Parameter;
 use serde::{Deserialize, Serialize};
 
+mod builder;
 mod parameter;
 
 #[derive(Serialize, Deserialize, Clone, Default, Debug)]
@@ -19,6 +21,10 @@ pub struct Script {
 
 #[allow(dead_code)]
 impl Script {
+    pub fn builder() -> Builder {
+        Builder::new()
+    }
+
     pub fn name(&self) -> &str {
         &self.name
     }
@@ -97,7 +103,7 @@ fn parse_powershell_file(path: &str) -> Result<serde_json::Value, String> {
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
     #![allow(clippy::unwrap_used, clippy::expect_used)]
     use super::*;
 

src/script/builder.rs

@@ -0,0 +1,141 @@
+use std::sync::Arc;
+
+use super::{Script, parameter::Parameter};
+
+#[derive(Debug, Clone)]
+pub struct Builder {
+    name: Option<Arc<str>>,
+    path: Option<Arc<str>>,
+    parameters: Vec<Parameter>,
+    default_parameter_set: Option<Arc<str>>,
+    help_uri: Option<Arc<str>>,
+    supports_paging: Option<Arc<str>>,
+    supports_should_process: Option<bool>,
+    positional_binding: Option<bool>,
+}
+
+impl Builder {
+    pub fn new() -> Self {
+        Self {
+            name: None,
+            path: None,
+            parameters: vec![],
+            default_parameter_set: None,
+            help_uri: None,
+            supports_should_process: None,
+            supports_paging: None,
+            positional_binding: None,
+        }
+    }
+
+    // TODO: Add Custom Error Type
+    #[allow(dead_code)]
+    pub fn build(self) -> Result<Script, String> {
+        match (self.name, self.path) {
+            (None, None) => Err(String::from("Name and Path are required")),
+            (_, None) => Err(String::from("Path is required")),
+            (None, _) => Err(String::from("Name is required")),
+            (Some(name), Some(path)) => Ok(Script {
+                name,
+                path,
+                parameters: self.parameters,
+                default_parameter_set: self.default_parameter_set,
+                help_uri: self.help_uri,
+                supports_should_process: self.supports_should_process,
+                supports_paging: self.supports_paging,
+                positional_binding: self.positional_binding,
+            }),
+        }
+    }
+
+    #[allow(dead_code)]
+    pub fn set_name<T: AsRef<str>>(mut self, name: T) -> Self {
+        self.name = Some(Arc::from(name.as_ref()));
+        self
+    }
+
+    #[allow(dead_code)]
+    pub fn set_path<T: AsRef<str>>(mut self, path: T) -> Self {
+        self.path = Some(Arc::from(path.as_ref()));
+        self
+    }
+
+    #[allow(dead_code)]
+    pub fn add_parameter(mut self, parameter: Parameter) -> Self {
+        self.parameters.push(parameter);
+        self
+    }
+
+    #[allow(dead_code)]
+    pub fn set_parameters(mut self, parameters: Vec<Parameter>) -> Self {
+        self.parameters = parameters;
+        self
+    }
+
+    #[allow(dead_code)]
+    pub fn set_default_parameter_set<T: AsRef<str>>(mut self, param_set: Option<T>) -> Self {
+        if let Some(v) = param_set {
+            self.default_parameter_set = Some(Arc::from(v.as_ref()));
+        } else {
+            self.default_parameter_set = None;
+        }
+        self
+    }
+    #[allow(dead_code)]
+    pub fn set_help_uri<T: AsRef<str>>(mut self, help_uri: Option<T>) -> Self {
+        if let Some(v) = help_uri {
+            self.help_uri = Some(Arc::from(v.as_ref()));
+        } else {
+            self.help_uri = None;
+        }
+        self
+    }
+
+    #[allow(dead_code)]
+    pub fn set_supports_paging<T: AsRef<str>>(mut self, supports_paging: Option<T>) -> Self {
+        if let Some(v) = supports_paging {
+            self.supports_paging = Some(Arc::from(v.as_ref()));
+        } else {
+            self.supports_paging = None;
+        }
+        self
+    }
+
+    #[allow(dead_code)]
+    pub fn set_supports_should_process(mut self, supports_should_process: Option<bool>) -> Self {
+        if let Some(v) = supports_should_process {
+            self.supports_should_process = Some(v);
+        } else {
+            self.supports_should_process = None;
+        }
+        self
+    }
+
+    #[allow(dead_code)]
+    pub fn set_positional_binding(mut self, positional_binding: Option<bool>) -> Self {
+        if let Some(v) = positional_binding {
+            self.positional_binding = Some(v);
+        } else {
+            self.positional_binding = None;
+        }
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::expect_used, unused_imports)]
+    use crate::script::Script;
+
+    #[test]
+    fn builder() {
+        let got = Script::builder()
+            .set_name("test-name")
+            .set_path("test-path")
+            .build()
+            .expect("should always build");
+
+        assert_eq!(got.path(), "test-path");
+        assert_eq!(got.name(), "test-name");
+    }
+}