...

src/rhai/buildah.rs

@@ -56,6 +56,8 @@ fn register_bah_types(engine: &mut Engine) -> Result<(), Box<EvalAltResult>> {
     engine.register_get("container_id", get_builder_container_id);
     engine.register_get("name", get_builder_name);
     engine.register_get("image", get_builder_image);
+    engine.register_get("debug", get_builder_debug);
+    engine.register_set("debug", set_builder_debug);
     
     // Register Image type and methods (same as before)
     engine.register_type_with_name::<Image>("BuildahImage");
@@ -217,6 +219,16 @@ pub fn get_builder_image(builder: &mut Builder) -> String {
     builder.image().to_string()
 }
 
+/// Get the debug flag from a Builder
+pub fn get_builder_debug(builder: &mut Builder) -> bool {
+    builder.debug()
+}
+
+/// Set the debug flag on a Builder
+pub fn set_builder_debug(builder: &mut Builder, debug: bool) {
+    builder.set_debug(debug);
+}
+
 // Reset function for Builder
 pub fn builder_reset(builder: &mut Builder) -> Result<(), Box<EvalAltResult>> {
     bah_error_to_rhai_error(builder.reset())

src/rhai/mod.rs

@@ -9,6 +9,7 @@ mod process;
 mod buildah;
 mod nerdctl;
 mod git;
+mod text;
 
 #[cfg(test)]
 mod tests;
@@ -56,6 +57,16 @@ pub use nerdctl::{
 pub use git::register_git_module;
 pub use crate::git::{GitTree, GitRepo};
 
+// Re-export text module
+pub use text::register_text_module;
+// Re-export text functions directly from text module
+pub use crate::text::{
+    // Fix functions
+    name_fix, path_fix,
+    // Dedent functions
+    dedent, prefix
+};
+
 // Rename copy functions to avoid conflicts
 pub use os::copy as os_copy;
 
@@ -89,11 +100,14 @@ pub fn register(engine: &mut Engine) -> Result<(), Box<rhai::EvalAltResult>> {
     
     // Register Nerdctl module functions
     nerdctl::register_nerdctl_module(engine)?;
-    
     // Register Git module functions
     git::register_git_module(engine)?;
     
+    // Register Text module functions
+    text::register_text_module(engine)?;
+    
     // Future modules can be registered here
     
+    
     Ok(())
 }

src/rhai/text.rs

@@ -0,0 +1,229 @@
+//! Rhai wrappers for Text module functions
+//!
+//! This module provides Rhai wrappers for the functions in the Text module.
+
+use rhai::{Engine, EvalAltResult, Array, Dynamic, Map, Position};
+use std::collections::HashMap;
+use crate::text::{
+    TextReplacer, TextReplacerBuilder,
+    TemplateBuilder,
+    dedent, prefix,
+    name_fix, path_fix
+};
+
+/// Register Text module functions with the Rhai engine
+///
+/// # Arguments
+///
+/// * `engine` - The Rhai engine to register the functions with
+///
+/// # Returns
+///
+/// * `Result<(), Box<EvalAltResult>>` - Ok if registration was successful, Err otherwise
+pub fn register_text_module(engine: &mut Engine) -> Result<(), Box<EvalAltResult>> {
+    // Register types
+    register_text_types(engine)?;
+    
+    // Register TextReplacer functions
+    engine.register_fn("text_replacer_new", text_replacer_new);
+    
+    // Register TextReplacer instance methods
+    engine.register_fn("pattern", builder_pattern);
+    engine.register_fn("replacement", builder_replacement);
+    engine.register_fn("regex", builder_regex);
+    engine.register_fn("case_insensitive", builder_case_insensitive);
+    engine.register_fn("and", builder_and);
+    engine.register_fn("build", builder_build);
+    engine.register_fn("replace", replacer_replace);
+    engine.register_fn("replace_file", replacer_replace_file);
+    engine.register_fn("replace_file_in_place", replacer_replace_file_in_place);
+    engine.register_fn("replace_file_to", replacer_replace_file_to);
+    
+    // Register TemplateBuilder functions
+    engine.register_fn("template_builder_open", template_builder_open);
+    
+    // Register TemplateBuilder instance methods
+    engine.register_fn("add_var", template_add_var_string);
+    engine.register_fn("add_var", template_add_var_int);
+    engine.register_fn("add_var", template_add_var_float);
+    engine.register_fn("add_var", template_add_var_bool);
+    engine.register_fn("add_var", template_add_var_array);
+    engine.register_fn("add_vars", template_add_vars);
+    engine.register_fn("render", template_render);
+    engine.register_fn("render_to_file", template_render_to_file);
+    
+    // Register Fix functions
+    engine.register_fn("name_fix", crate::text::name_fix);
+    engine.register_fn("path_fix", crate::text::path_fix);
+    
+    // Register Dedent functions
+    engine.register_fn("dedent", crate::text::dedent);
+    engine.register_fn("prefix", crate::text::prefix);
+    
+    Ok(())
+}
+
+/// Register Text module types with the Rhai engine
+fn register_text_types(engine: &mut Engine) -> Result<(), Box<EvalAltResult>> {
+    // Register TextReplacerBuilder type
+    engine.register_type_with_name::<TextReplacerBuilder>("TextReplacerBuilder");
+    
+    // Register TextReplacer type
+    engine.register_type_with_name::<TextReplacer>("TextReplacer");
+    
+    // Register TemplateBuilder type
+    engine.register_type_with_name::<TemplateBuilder>("TemplateBuilder");
+    
+    // Register getters for TextReplacer properties (if any)
+    
+    // Register getters for TemplateBuilder properties (if any)
+    
+    Ok(())
+}
+
+// Helper functions for error conversion
+fn io_error_to_rhai_error<T>(result: std::io::Result<T>) -> Result<T, Box<EvalAltResult>> {
+    result.map_err(|e| {
+        Box::new(EvalAltResult::ErrorRuntime(
+            format!("IO error: {}", e).into(),
+            Position::NONE
+        ))
+    })
+}
+
+fn tera_error_to_rhai_error<T>(result: Result<T, tera::Error>) -> Result<T, Box<EvalAltResult>> {
+    result.map_err(|e| {
+        Box::new(EvalAltResult::ErrorRuntime(
+            format!("Template error: {}", e).into(),
+            Position::NONE
+        ))
+    })
+}
+
+fn string_error_to_rhai_error<T>(result: Result<T, String>) -> Result<T, Box<EvalAltResult>> {
+    result.map_err(|e| {
+        Box::new(EvalAltResult::ErrorRuntime(
+            e.into(),
+            Position::NONE
+        ))
+    })
+}
+
+// TextReplacer implementation
+
+/// Creates a new TextReplacerBuilder
+pub fn text_replacer_new() -> TextReplacerBuilder {
+    TextReplacerBuilder::default()
+}
+
+/// Sets the pattern to search for
+pub fn builder_pattern(builder: TextReplacerBuilder, pat: &str) -> TextReplacerBuilder {
+    builder.pattern(pat)
+}
+
+/// Sets the replacement text
+pub fn builder_replacement(builder: TextReplacerBuilder, rep: &str) -> TextReplacerBuilder {
+    builder.replacement(rep)
+}
+
+/// Sets whether to use regex
+pub fn builder_regex(builder: TextReplacerBuilder, yes: bool) -> TextReplacerBuilder {
+    builder.regex(yes)
+}
+
+/// Sets whether the replacement should be case-insensitive
+pub fn builder_case_insensitive(builder: TextReplacerBuilder, yes: bool) -> TextReplacerBuilder {
+    builder.case_insensitive(yes)
+}
+
+/// Adds another replacement operation to the chain and resets the builder for a new operation
+pub fn builder_and(builder: TextReplacerBuilder) -> TextReplacerBuilder {
+    builder.and()
+}
+
+/// Builds the TextReplacer with all configured replacement operations
+pub fn builder_build(builder: TextReplacerBuilder) -> Result<TextReplacer, Box<EvalAltResult>> {
+    string_error_to_rhai_error(builder.build())
+}
+
+/// Applies all configured replacement operations to the input text
+pub fn replacer_replace(replacer: &mut TextReplacer, input: &str) -> String {
+    replacer.replace(input)
+}
+
+/// Reads a file, applies all replacements, and returns the result as a string
+pub fn replacer_replace_file(replacer: &mut TextReplacer, path: &str) -> Result<String, Box<EvalAltResult>> {
+    io_error_to_rhai_error(replacer.replace_file(path))
+}
+
+/// Reads a file, applies all replacements, and writes the result back to the file
+pub fn replacer_replace_file_in_place(replacer: &mut TextReplacer, path: &str) -> Result<(), Box<EvalAltResult>> {
+    io_error_to_rhai_error(replacer.replace_file_in_place(path))
+}
+
+/// Reads a file, applies all replacements, and writes the result to a new file
+pub fn replacer_replace_file_to(replacer: &mut TextReplacer, input_path: &str, output_path: &str) -> Result<(), Box<EvalAltResult>> {
+    io_error_to_rhai_error(replacer.replace_file_to(input_path, output_path))
+}
+
+// TemplateBuilder implementation
+
+/// Creates a new TemplateBuilder with the specified template path
+pub fn template_builder_open(template_path: &str) -> Result<TemplateBuilder, Box<EvalAltResult>> {
+    io_error_to_rhai_error(TemplateBuilder::open(template_path))
+}
+
+/// Adds a string variable to the template context
+pub fn template_add_var_string(builder: TemplateBuilder, name: &str, value: &str) -> TemplateBuilder {
+    builder.add_var(name, value)
+}
+
+/// Adds an integer variable to the template context
+pub fn template_add_var_int(builder: TemplateBuilder, name: &str, value: i64) -> TemplateBuilder {
+    builder.add_var(name, value)
+}
+
+/// Adds a float variable to the template context
+pub fn template_add_var_float(builder: TemplateBuilder, name: &str, value: f64) -> TemplateBuilder {
+    builder.add_var(name, value)
+}
+
+/// Adds a boolean variable to the template context
+pub fn template_add_var_bool(builder: TemplateBuilder, name: &str, value: bool) -> TemplateBuilder {
+    builder.add_var(name, value)
+}
+
+/// Adds an array variable to the template context
+pub fn template_add_var_array(builder: TemplateBuilder, name: &str, value: Array) -> TemplateBuilder {
+    // Convert Rhai Array to Vec<String>
+    let vec: Vec<String> = value.iter()
+        .filter_map(|v| v.clone().into_string().ok())
+        .collect();
+    
+    builder.add_var(name, vec)
+}
+
+/// Adds multiple variables to the template context from a Map
+pub fn template_add_vars(builder: TemplateBuilder, vars: Map) -> TemplateBuilder {
+    // Convert Rhai Map to Rust HashMap
+    let mut hash_map = HashMap::new();
+    
+    for (key, value) in vars.iter() {
+        if let Ok(val_str) = value.clone().into_string() {
+            hash_map.insert(key.to_string(), val_str);
+        }
+    }
+    
+    // Add the variables
+    builder.add_vars(hash_map)
+}
+
+/// Renders the template with the current context
+pub fn template_render(builder: &mut TemplateBuilder) -> Result<String, Box<EvalAltResult>> {
+    tera_error_to_rhai_error(builder.render())
+}
+
+/// Renders the template and writes the result to a file
+pub fn template_render_to_file(builder: &mut TemplateBuilder, output_path: &str) -> Result<(), Box<EvalAltResult>> {
+    io_error_to_rhai_error(builder.render_to_file(output_path))
+}