refactor: improve InventoryTemplate API by taking ownership of context

- Change InventoryTemplate::new() to take InventoryContext by value instead of reference
- Add Clone trait to InventoryContext to support the API change
- Update all call sites throughout the codebase (e2e_tests, integration tests, unit tests)
- Simplify internal implementation by removing manual cloning
- Move ansible_host.rs and ssh_private_key_file.rs to context/ subdirectory
- Move InventoryContext* types and tests to context/mod.rs for better organization

This improves the API ergonomics and eliminates unnecessary complexity in the
InventoryTemplate constructor while maintaining backward compatibility in usage patterns.

Author: josecelano

src/bin/e2e_tests.rs

@@ -157,7 +157,7 @@ impl TestEnvironment {
                 .context("Failed to create InventoryContext")?
         };
         let inventory_template =
-            InventoryTemplate::new(&inventory_template_file, &inventory_context)
+            InventoryTemplate::new(&inventory_template_file, inventory_context)
                 .context("Failed to create InventoryTemplate")?;
 
         inventory_template

…appers/ansible/inventory/ansible_host.rs …nsible/inventory/context/ansible_host.rssrc/template/wrappers/ansible/inventory/ansible_host.rs renamed to src/template/wrappers/ansible/inventory/context/ansible_host.rs src/template/wrappers/ansible/inventory/ansible_host.rs renamed to src/template/wrappers/ansible/inventory/context/ansible_host.rs

@@ -0,0 +1,229 @@
+pub mod ansible_host;
+pub mod ssh_private_key_file;
+
+use serde::Serialize;
+use thiserror::Error;
+
+#[cfg(test)]
+use std::str::FromStr;
+
+pub use ansible_host::{AnsibleHost, AnsibleHostError};
+pub use ssh_private_key_file::{SshPrivateKeyFile, SshPrivateKeyFileError};
+
+/// Errors that can occur when creating an `InventoryContext`
+#[derive(Debug, Error)]
+pub enum InventoryContextError {
+    #[error("Invalid ansible host: {0}")]
+    InvalidAnsibleHost(#[from] AnsibleHostError),
+
+    #[error("Invalid SSH private key file: {0}")]
+    InvalidSshPrivateKeyFile(#[from] SshPrivateKeyFileError),
+
+    #[error("Missing ansible host - must be set before building")]
+    MissingAnsibleHost,
+
+    #[error("Missing SSH private key file - must be set before building")]
+    MissingSshPrivateKeyFile,
+}
+
+#[derive(Serialize, Debug, Clone)]
+pub struct InventoryContext {
+    ansible_host: AnsibleHost,
+    ansible_ssh_private_key_file: SshPrivateKeyFile,
+}
+
+/// Builder for `InventoryContext` with fluent interface
+#[derive(Debug, Default)]
+pub struct InventoryContextBuilder {
+    ansible_host: Option<AnsibleHost>,
+    ansible_ssh_private_key_file: Option<SshPrivateKeyFile>,
+}
+
+impl InventoryContextBuilder {
+    /// Creates a new empty builder
+    #[must_use]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Sets the Ansible host for the builder.
+    #[must_use]
+    pub fn with_host(mut self, ansible_host: AnsibleHost) -> Self {
+        self.ansible_host = Some(ansible_host);
+        self
+    }
+
+    /// Sets the SSH private key file path for the builder.
+    #[must_use]
+    pub fn with_ssh_priv_key_path(mut self, ssh_private_key_file: SshPrivateKeyFile) -> Self {
+        self.ansible_ssh_private_key_file = Some(ssh_private_key_file);
+        self
+    }
+
+    /// Builds the `InventoryContext`
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if either `ansible_host` or `ansible_ssh_private_key_file` is missing
+    pub fn build(self) -> Result<InventoryContext, InventoryContextError> {
+        let ansible_host = self
+            .ansible_host
+            .ok_or(InventoryContextError::MissingAnsibleHost)?;
+
+        let ansible_ssh_private_key_file = self
+            .ansible_ssh_private_key_file
+            .ok_or(InventoryContextError::MissingSshPrivateKeyFile)?;
+
+        Ok(InventoryContext {
+            ansible_host,
+            ansible_ssh_private_key_file,
+        })
+    }
+}
+
+impl InventoryContext {
+    /// Creates a new `InventoryContext` using typed parameters
+    ///
+    /// # Errors
+    ///
+    /// This method cannot fail with the current implementation since it takes
+    /// already validated types, but returns Result for consistency with builder pattern
+    pub fn new(
+        ansible_host: AnsibleHost,
+        ansible_ssh_private_key_file: SshPrivateKeyFile,
+    ) -> Result<Self, InventoryContextError> {
+        Ok(Self {
+            ansible_host,
+            ansible_ssh_private_key_file,
+        })
+    }
+
+    /// Creates a new builder for `InventoryContext` with fluent interface
+    #[must_use]
+    pub fn builder() -> InventoryContextBuilder {
+        InventoryContextBuilder::new()
+    }
+
+    /// Get the ansible host value as a string
+    #[must_use]
+    pub fn ansible_host(&self) -> String {
+        self.ansible_host.as_str()
+    }
+
+    /// Get the ansible SSH private key file path as a string
+    #[must_use]
+    pub fn ansible_ssh_private_key_file(&self) -> String {
+        self.ansible_ssh_private_key_file.as_str()
+    }
+
+    /// Get the ansible host wrapper
+    #[must_use]
+    pub fn ansible_host_wrapper(&self) -> &AnsibleHost {
+        &self.ansible_host
+    }
+
+    /// Get the ansible SSH private key file wrapper
+    #[must_use]
+    pub fn ansible_ssh_private_key_file_wrapper(&self) -> &SshPrivateKeyFile {
+        &self.ansible_ssh_private_key_file
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_should_provide_access_to_wrapper_types() {
+        let host = AnsibleHost::from_str("10.0.0.1").unwrap();
+        let ssh_key = SshPrivateKeyFile::new("/path/to/key").unwrap();
+        let context = InventoryContext::builder()
+            .with_host(host)
+            .with_ssh_priv_key_path(ssh_key)
+            .build()
+            .unwrap();
+
+        // Test wrapper access
+        let host_wrapper = context.ansible_host_wrapper();
+        let key_wrapper = context.ansible_ssh_private_key_file_wrapper();
+
+        assert_eq!(host_wrapper.as_str(), "10.0.0.1");
+        assert_eq!(key_wrapper.as_str(), "/path/to/key");
+    }
+
+    #[test]
+    fn it_should_support_builder_pattern_fluent_interface() {
+        // Test the fluent builder interface as requested
+        let host = AnsibleHost::from_str("192.168.1.100").unwrap();
+        let ssh_key = SshPrivateKeyFile::new("/home/user/.ssh/id_rsa").unwrap();
+        let inventory_context = InventoryContext::builder()
+            .with_host(host)
+            .with_ssh_priv_key_path(ssh_key)
+            .build()
+            .unwrap();
+
+        assert_eq!(inventory_context.ansible_host(), "192.168.1.100");
+        assert_eq!(
+            inventory_context.ansible_ssh_private_key_file(),
+            "/home/user/.ssh/id_rsa"
+        );
+    }
+
+    #[test]
+    fn it_should_work_with_builder_typed_parameters() {
+        // Test builder with typed parameters instead of strings
+        let host = AnsibleHost::from_str("10.0.0.1").unwrap();
+        let ssh_key = SshPrivateKeyFile::new("/path/to/key").unwrap();
+
+        let inventory_context = InventoryContext::builder()
+            .with_host(host)
+            .with_ssh_priv_key_path(ssh_key)
+            .build()
+            .unwrap();
+
+        assert_eq!(inventory_context.ansible_host(), "10.0.0.1");
+        assert_eq!(
+            inventory_context.ansible_ssh_private_key_file(),
+            "/path/to/key"
+        );
+    }
+
+    #[test]
+    fn it_should_fail_when_builder_missing_host() {
+        // Test that builder fails when host is missing
+        let ssh_key = SshPrivateKeyFile::new("/path/to/key").unwrap();
+        let result = InventoryContext::builder()
+            .with_ssh_priv_key_path(ssh_key)
+            .build();
+
+        assert!(result.is_err());
+        let error_msg = result.unwrap_err().to_string();
+        assert!(error_msg.contains("Missing ansible host"));
+    }
+
+    #[test]
+    fn it_should_fail_when_builder_missing_ssh_key() {
+        // Test that builder fails when SSH key is missing
+        let host = AnsibleHost::from_str("192.168.1.100").unwrap();
+        let result = InventoryContext::builder().with_host(host).build();
+
+        assert!(result.is_err());
+        let error_msg = result.unwrap_err().to_string();
+        assert!(error_msg.contains("Missing SSH private key file"));
+    }
+
+    #[test]
+    fn it_should_create_new_inventory_context_with_typed_parameters() {
+        // Test the new direct constructor with typed parameters
+        let host = AnsibleHost::from_str("192.168.1.50").unwrap();
+        let ssh_key = SshPrivateKeyFile::new("/etc/ssh/test_key").unwrap();
+
+        let inventory_context = InventoryContext::new(host, ssh_key).unwrap();
+
+        assert_eq!(inventory_context.ansible_host(), "192.168.1.50");
+        assert_eq!(
+            inventory_context.ansible_ssh_private_key_file(),
+            "/etc/ssh/test_key"
+        );
+    }
+}