feat(template): ease restrictions on format_with_inputs method

Author: lalvarezt

src/lib.rs

@@ -242,12 +242,6 @@
 //! let result = template.format("not_a_list");
 //! assert!(result.is_err());
 //! // Error: "Sort operation can only be applied to lists"
-//!
-//! // Structured template input count validation
-//! let template = Template::parse("A: {upper} B: {lower}").unwrap();
-//! let result = template.format_with_inputs(&[&["only_one"]], &[" ", " "]);
-//! assert!(result.is_err());
-//! // Error: "Expected 2 input slices for 2 template sections, got 1"
 //! ```
 //!
 //! ## Performance Notes

src/pipeline/template.rs

@@ -607,7 +607,15 @@ impl MultiTemplate {
     /// # Returns
     ///
     /// * `Ok(String)` - The formatted result with each template section processed with its joined inputs
-    /// * `Err(String)` - Error if inputs/separators length doesn't match template section count or processing fails
+    /// * `Err(String)` - Error if template section processing fails
+    ///
+    /// # Input/Template/Separator Count Handling
+    ///
+    /// This method gracefully handles mismatches between counts:
+    /// - **Excess inputs**: Extra inputs beyond template section count are truncated/ignored
+    /// - **Insufficient inputs**: Missing inputs are treated as empty strings for remaining template sections
+    /// - **Excess separators**: Extra separators beyond template section count are truncated/ignored
+    /// - **Insufficient separators**: Missing separators default to space " " for remaining template sections
     ///
     /// # Template Section Ordering
     ///
@@ -624,13 +632,6 @@ impl MultiTemplate {
     /// - **Single item `["value"]`**: Uses "value" directly as input
     /// - **Multiple items `["a", "b", "c"]`**: Joins with corresponding separator
     ///
-    /// # Errors
-    ///
-    /// Returns an error if:
-    /// - The number of input slices doesn't match the number of template sections
-    /// - The number of separators doesn't match the number of template sections
-    /// - Any template section processing fails
-    ///
     /// # Examples
     ///
     /// ```rust
@@ -644,21 +645,31 @@ impl MultiTemplate {
     /// ], &[" ", " "]).unwrap();
     /// assert_eq!(result, "Users: JOHN DOE PETER PARKER | Email: admin@example.com");
     ///
-    /// // File batch processing with different separators
-    /// let template = Template::parse("tar -czf {lower}.tar.gz {join: }").unwrap();
+    /// // Excess inputs are truncated
+    /// let template = Template::parse("diff {} {}").unwrap();
     /// let result = template.format_with_inputs(&[
-    ///     &["BACKUP"],
-    ///     &["file1.txt", "file2.txt", "file3.txt"],
+    ///     &["file1.txt"],
+    ///     &["file2.txt"],
+    ///     &["file3.txt"], // This will be ignored
     /// ], &[" ", " "]).unwrap();
-    /// assert_eq!(result, "tar -czf backup.tar.gz file1.txt file2.txt file3.txt");
+    /// assert_eq!(result, "diff file1.txt file2.txt");
     ///
-    /// // Command construction with custom separators
-    /// let template = Template::parse("grep {join:\\|} {join:,}").unwrap();
+    /// // Insufficient inputs use empty strings
+    /// let template = Template::parse("cmd {} {} {}").unwrap();
+    /// let result = template.format_with_inputs(&[
+    ///     &["arg1"],
+    ///     &["arg2"],
+    ///     // Missing third input - will use empty string
+    /// ], &[" ", " ", " "]).unwrap();
+    /// assert_eq!(result, "cmd arg1 arg2 ");
+    ///
+    /// // Insufficient separators default to space
+    /// let template = Template::parse("files: {} more: {}").unwrap();
     /// let result = template.format_with_inputs(&[
-    ///     &["error", "warning"],
-    ///     &["log1.txt", "log2.txt"],
-    /// ], &["|", ","]).unwrap();
-    /// assert_eq!(result, "grep error|warning log1.txt,log2.txt");
+    ///     &["a", "b", "c"],
+    ///     &["x", "y", "z"],
+    /// ], &[","]).unwrap(); // Only one separator provided
+    /// assert_eq!(result, "files: a,b,c more: x y z"); // Second uses default space
     /// ```
     pub fn format_with_inputs(
         &self,
@@ -667,23 +678,30 @@ impl MultiTemplate {
     ) -> Result<String, String> {
         let template_sections_count = self.template_section_count();
 
-        if inputs.len() != template_sections_count {
-            return Err(format!(
-                "Expected {} input slices for {} template sections, got {}",
-                template_sections_count,
-                template_sections_count,
-                inputs.len()
-            ));
-        }
+        // Handle input/template count mismatches gracefully
+        let adjusted_inputs: Vec<&[&str]> = (0..template_sections_count)
+            .map(|i| {
+                if i < inputs.len() {
+                    inputs[i] // Use actual input
+                } else {
+                    &[] as &[&str] // Empty slice for missing inputs
+                }
+            })
+            .collect();
+
+        // Handle separator/template count mismatches gracefully
+        let adjusted_separators: Vec<&str> = (0..template_sections_count)
+            .map(|i| {
+                if i < separators.len() {
+                    separators[i] // Use actual separator
+                } else {
+                    " " // Default to space for missing separators
+                }
+            })
+            .collect();
 
-        if separators.len() != template_sections_count {
-            return Err(format!(
-                "Expected {} separators for {} template sections, got {}",
-                template_sections_count,
-                template_sections_count,
-                separators.len()
-            ));
-        }
+        let inputs = &adjusted_inputs;
+        let separators = &adjusted_separators;
 
         let mut result = String::new();
         let mut template_index = 0;

tests/multi_template_tests.rs

@@ -407,51 +407,146 @@ fn test_format_with_inputs_multiple_sections() {
 }
 
 #[test]
-fn test_format_with_inputs_error_wrong_input_count() {
-    // Test error when input count doesn't match template section count
+fn test_format_with_inputs_input_count_handling() {
+    // Test graceful handling when input count doesn't match template section count
     let template = MultiTemplate::parse("A: {upper} B: {lower}").unwrap();
 
-    // Too few inputs
+    // Too few inputs - should use empty string for missing inputs
     let result = template.format_with_inputs(&[&["only_one"]], &[" ", " "]);
-    assert!(result.is_err());
-    assert!(
-        result
-            .unwrap_err()
-            .contains("Expected 2 input slices for 2 template sections, got 1")
-    );
+    assert!(result.is_ok());
+    assert_eq!(result.unwrap(), "A: ONLY_ONE B: ");
 
-    // Too many inputs
+    // Too many inputs - should truncate excess inputs
     let result = template.format_with_inputs(&[&["one"], &["two"], &["three"]], &[" ", " "]);
-    assert!(result.is_err());
-    assert!(
-        result
-            .unwrap_err()
-            .contains("Expected 2 input slices for 2 template sections, got 3")
+    assert!(result.is_ok());
+    assert_eq!(result.unwrap(), "A: ONE B: two");
+}
+
+#[test]
+fn test_format_with_inputs_excess_inputs() {
+    // Test that excess inputs are truncated gracefully
+    let template = MultiTemplate::parse("diff {} {}").unwrap();
+    let result = template.format_with_inputs(
+        &[
+            &["file1.txt"],
+            &["file2.txt"],
+            &["file3.txt"], // This should be ignored
+            &["file4.txt"], // This should also be ignored
+        ],
+        &[" ", " "],
     );
+
+    assert!(result.is_ok());
+    assert_eq!(result.unwrap(), "diff file1.txt file2.txt");
 }
 
 #[test]
-fn test_format_with_inputs_error_wrong_separator_count() {
-    // Test error when separator count doesn't match template section count
-    let template = MultiTemplate::parse("A: {upper} B: {lower}").unwrap();
+fn test_format_with_inputs_insufficient_inputs() {
+    // Test that missing inputs are treated as empty strings
+    let template = MultiTemplate::parse("cmd {upper} {lower} {trim}").unwrap();
+    let result = template.format_with_inputs(
+        &[
+            &["arg1"],
+            &["ARG2"],
+            // Missing third input
+        ],
+        &[" ", " ", " "],
+    );
 
-    // Too few separators
-    let result = template.format_with_inputs(&[&["one"], &["two"]], &[" "]);
-    assert!(result.is_err());
-    assert!(
-        result
-            .unwrap_err()
-            .contains("Expected 2 separators for 2 template sections, got 1")
+    assert!(result.is_ok());
+    assert_eq!(result.unwrap(), "cmd ARG1 arg2 ");
+}
+
+#[test]
+fn test_format_with_inputs_empty_inputs_array() {
+    // Test with completely empty inputs array
+    let template = MultiTemplate::parse("start {upper} middle {lower} end").unwrap();
+    let result = template.format_with_inputs(&[], &[" ", " "]);
+
+    assert!(result.is_ok());
+    assert_eq!(result.unwrap(), "start  middle  end");
+}
+
+#[test]
+fn test_format_with_inputs_mixed_empty_and_filled() {
+    // Test with mix of empty slices and filled slices
+    let template = MultiTemplate::parse("A:{upper} B:{lower} C:{trim}").unwrap();
+    let result = template.format_with_inputs(
+        &[
+            &[],        // Empty slice for first section
+            &["hello"], // Normal input for second section
+            &[],        // Empty slice for third section
+        ],
+        &[" ", " ", " "],
     );
 
-    // Too many separators
-    let result = template.format_with_inputs(&[&["one"], &["two"]], &[" ", " ", " "]);
-    assert!(result.is_err());
-    assert!(
-        result
-            .unwrap_err()
-            .contains("Expected 2 separators for 2 template sections, got 3")
+    assert!(result.is_ok());
+    assert_eq!(result.unwrap(), "A: B:hello C:");
+}
+
+#[test]
+fn test_format_with_inputs_one_to_one_mode_scenario() {
+    // Test the specific scenario from the original issue
+    let template = MultiTemplate::parse("diff {} {}").unwrap();
+
+    // Simulating OneToOne mode: individual slices for each input
+    let inputs = ["file1.txt", "file2.txt", "file3.txt"];
+    let input_arrays: Vec<&[&str]> = inputs.iter().map(std::slice::from_ref).collect();
+
+    let result = template.format_with_inputs(&input_arrays, &[" ", " "]);
+
+    assert!(result.is_ok());
+    assert_eq!(result.unwrap(), "diff file1.txt file2.txt");
+    // file3.txt should be ignored (truncated)
+}
+
+#[test]
+fn test_format_with_inputs_separator_defaults() {
+    // Test that missing separators default to space " "
+    let template = MultiTemplate::parse("files: {} | items: {} | values: {}").unwrap();
+
+    // Provide separators for only first section
+    let result = template.format_with_inputs(
+        &[
+            &["a", "b", "c"], // First section gets comma separator
+            &["x", "y", "z"], // Second section gets default space separator
+            &["1", "2", "3"], // Third section gets default space separator
+        ],
+        &[","],
     );
+
+    assert!(result.is_ok());
+    assert_eq!(
+        result.unwrap(),
+        "files: a,b,c | items: x y z | values: 1 2 3"
+    );
+}
+
+#[test]
+fn test_format_with_inputs_no_separators_provided() {
+    // Test with no separators provided - all should default to space
+    let template = MultiTemplate::parse("A: {} B: {}").unwrap();
+
+    let result = template.format_with_inputs(&[&["one", "two", "three"], &["a", "b", "c"]], &[]); // No separators provided
+
+    assert!(result.is_ok());
+    assert_eq!(result.unwrap(), "A: one two three B: a b c");
+}
+
+#[test]
+fn test_format_with_inputs_separator_count_handling() {
+    // Test graceful handling when separator count doesn't match template section count
+    let template = MultiTemplate::parse("A: {upper} B: {lower}").unwrap();
+
+    // Too few separators - should use default space for missing separators
+    let result = template.format_with_inputs(&[&["one"], &["two"]], &[","]);
+    assert!(result.is_ok());
+    assert_eq!(result.unwrap(), "A: ONE B: two");
+
+    // Too many separators - should truncate excess separators
+    let result = template.format_with_inputs(&[&["one"], &["two"]], &[",", ";", ":"]);
+    assert!(result.is_ok());
+    assert_eq!(result.unwrap(), "A: ONE B: two");
 }
 
 #[test]
@@ -477,7 +572,7 @@ fn test_format_with_inputs_empty_sections() {
 #[test]
 fn test_format_with_inputs_custom_separators() {
     // Test different separators for each section
-    let template = MultiTemplate::parse("List1: {join:;} | List2: {join:,}").unwrap();
+    let template = MultiTemplate::parse("List1: {} | List2: {}").unwrap();
     let result = template
         .format_with_inputs(&[&["a", "b", "c"], &["x", "y", "z"]], &["-", "|"])
         .unwrap();