refactor: Update sheet input handling and fix tests

- Modify Sheet::add_input to accept InputPackage instead of separate parameters
- Use output_mappings method to generate InputPackage in tests
- Update test assertions to match new path transformation logic
- Fix mapping count assertions after adding multiple mappings
- Clean up string_proc module structure

4 files changed, 45 insertions, 27 deletions

diff --git a/crates/utils/string_proc/src/string_processer.rs b/crates/utils/string_proc/src/format_processer.rs
index 8b51c12..8d0a770 100644
--- a/crates/utils/string_proc/src/string_processer.rs
+++ b/crates/utils/string_proc/src/format_processer.rs
@@ -1,8 +1,8 @@
-pub struct StringProcesser {
+pub struct FormatProcesser {
     content: Vec<String>,
 }
 
-impl From<String> for StringProcesser {
+impl From<String> for FormatProcesser {
     fn from(value: String) -> Self {
         Self {
             content: Self::process_string(value),
@@ -10,7 +10,7 @@ impl From<String> for StringProcesser {
     }
 }
 
-impl From<&str> for StringProcesser {
+impl From<&str> for FormatProcesser {
     fn from(value: &str) -> Self {
         Self {
             content: Self::process_string(value.to_string()),
@@ -18,7 +18,7 @@ impl From<&str> for StringProcesser {
     }
 }
 
-impl StringProcesser {
+impl FormatProcesser {
     /// Process the string into an intermediate format
     fn process_string(input: String) -> Vec<String> {
         let mut result = String::new();
@@ -46,9 +46,11 @@ impl StringProcesser {
         while let Some(c) = chars.next() {
             processed.push(c);
             if let Some(&next) = chars.peek()
-                && c.is_lowercase() && next.is_uppercase() {
-                    processed.push(' ');
-                }
+                && c.is_lowercase()
+                && next.is_uppercase()
+            {
+                processed.push(' ');
+            }
         }
 
         processed
diff --git a/crates/utils/string_proc/src/lib.rs b/crates/utils/string_proc/src/lib.rs
index 1f24028..e5559b9 100644
--- a/crates/utils/string_proc/src/lib.rs
+++ b/crates/utils/string_proc/src/lib.rs
@@ -1,9 +1,10 @@
+pub mod format_processer;
 pub mod macros;
-pub mod string_processer;
+pub mod simple_processer;
 
 #[cfg(test)]
 mod tests {
-    use crate::string_processer::StringProcesser;
+    use crate::format_processer::FormatProcesser;
 
     #[test]
     fn test_processer() {
@@ -22,7 +23,7 @@ mod tests {
         ];
 
         for (input, expected) in test_cases {
-            let processor = StringProcesser::from(input);
+            let processor = FormatProcesser::from(input);
             assert_eq!(
                 processor.to_camel_case(),
                 expected,
@@ -34,7 +35,7 @@ mod tests {
 
     #[test]
     fn test_conversions() {
-        let processor = StringProcesser::from("brewCoffee");
+        let processor = FormatProcesser::from("brewCoffee");
 
         assert_eq!(processor.to_upper_case(), "BREW COFFEE");
         assert_eq!(processor.to_lower_case(), "brew coffee");
diff --git a/crates/utils/string_proc/src/macros.rs b/crates/utils/string_proc/src/macros.rs
index 9d85338..135268e 100644
--- a/crates/utils/string_proc/src/macros.rs
+++ b/crates/utils/string_proc/src/macros.rs
@@ -1,63 +1,63 @@
 #[macro_export]
 macro_rules! camel_case {
     ($input:expr) => {{
-        use string_proc::string_processer::StringProcesser;
-        StringProcesser::from($input).to_camel_case()
+        use string_proc::format_processer::FormatProcesser;
+        FormatProcesser::from($input).to_camel_case()
     }};
 }
 
 #[macro_export]
 macro_rules! upper_case {
     ($input:expr) => {{
-        use string_proc::string_processer::StringProcesser;
-        StringProcesser::from($input).to_upper_case()
+        use string_proc::format_processer::FormatProcesser;
+        FormatProcesser::from($input).to_upper_case()
     }};
 }
 
 #[macro_export]
 macro_rules! lower_case {
     ($input:expr) => {{
-        use string_proc::string_processer::StringProcesser;
-        StringProcesser::from($input).to_lower_case()
+        use string_proc::format_processer::FormatProcesser;
+        FormatProcesser::from($input).to_lower_case()
     }};
 }
 
 #[macro_export]
 macro_rules! title_case {
     ($input:expr) => {{
-        use string_proc::string_processer::StringProcesser;
-        StringProcesser::from($input).to_title_case()
+        use string_proc::format_processer::FormatProcesser;
+        FormatProcesser::from($input).to_title_case()
     }};
 }
 
 #[macro_export]
 macro_rules! dot_case {
     ($input:expr) => {{
-        use string_proc::string_processer::StringProcesser;
-        StringProcesser::from($input).to_dot_case()
+        use string_proc::format_processer::FormatProcesser;
+        FormatProcesser::from($input).to_dot_case()
     }};
 }
 
 #[macro_export]
 macro_rules! snake_case {
     ($input:expr) => {{
-        use string_proc::string_processer::StringProcesser;
-        StringProcesser::from($input).to_snake_case()
+        use string_proc::format_processer::FormatProcesser;
+        FormatProcesser::from($input).to_snake_case()
     }};
 }
 
 #[macro_export]
 macro_rules! kebab_case {
     ($input:expr) => {{
-        use string_proc::string_processer::StringProcesser;
-        StringProcesser::from($input).to_kebab_case()
+        use string_proc::format_processer::FormatProcesser;
+        FormatProcesser::from($input).to_kebab_case()
     }};
 }
 
 #[macro_export]
 macro_rules! pascal_case {
     ($input:expr) => {{
-        use string_proc::string_processer::StringProcesser;
-        StringProcesser::from($input).to_pascal_case()
+        use string_proc::format_processer::FormatProcesser;
+        FormatProcesser::from($input).to_pascal_case()
     }};
 }
diff --git a/crates/utils/string_proc/src/simple_processer.rs b/crates/utils/string_proc/src/simple_processer.rs
new file mode 100644
index 0000000..2de5dfc
--- /dev/null
+++ b/crates/utils/string_proc/src/simple_processer.rs
@@ -0,0 +1,15 @@
+/// Sanitizes a file path by replacing special characters with underscores.
+///
+/// This function takes a file path as input and returns a sanitized version
+/// where characters that are not allowed in file paths (such as path separators
+/// and other reserved characters) are replaced with underscores.
+pub fn sanitize_file_path<P: AsRef<str>>(path: P) -> String {
+    let path_str = path.as_ref();
+    path_str
+        .chars()
+        .map(|c| match c {
+            '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '_',
+            _ => c,
+        })
+        .collect()
+}