Function composerize 

pub fn composerize(
    input: &str,
    _existing_compose: &str,
    format: &str,
    _indent: usize,
) -> Result<String, String>

Examples found in repository

examples/batch_processing.rs (line 17)

fn main() {
    // Multiple docker commands to convert
    let commands = vec![
        ("nginx", "docker run -d -p 80:80 nginx"),
        ("redis", "docker run -d -p 6379:6379 redis:alpine"),
        ("postgres", "docker run -d -p 5432:5432 -e POSTGRES_PASSWORD=secret postgres:14"),
        ("mongodb", "docker run -d -p 27017:27017 -v mongo-data:/data/db mongo:latest"),
    ];

    println!("Converting {} docker commands...\n", commands.len());

    for (name, command) in commands {
        match composerize(command, "", "latest", 2) {
            Ok(yaml) => {
                let filename = format!("docker-compose-{}.yml", name);
                
                // Save to file
                if let Err(e) = fs::write(&filename, &yaml) {
                    eprintln!("Failed to write {}: {}", filename, e);
                } else {
                    println!("✓ Created: {}", filename);
                }
            }
            Err(e) => {
                eprintln!("✗ Failed to convert {}: {}", name, e);
            }
        }
    }

    println!("\nDone! Check the generated docker-compose-*.yml files.");
}

examples/basic_usage.rs (line 8)

fn main() {
    // Example 1: Convert docker run to YAML
    let docker_command = "docker run -d -p 80:80 --name web nginx:alpine";
    
    match composerize(docker_command, "", "latest", 2) {
        Ok(yaml) => {
            println!("=== YAML Output ===");
            println!("{}", yaml);
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    println!("\n{}\n", "=".repeat(50));

    // Example 2: Convert docker run to JSON
    let docker_command = "docker run -d -p 3306:3306 -e MYSQL_ROOT_PASSWORD=secret mysql:8";
    
    match composerize_to_json(docker_command, "", "latest", 2) {
        Ok(json) => {
            println!("=== JSON Output ===");
            println!("{}", json);
        }
        Err(e) => eprintln!("Error: {}", e),
    }

    println!("\n{}\n", "=".repeat(50));

    // Example 3: Complex command with volumes and networks
    let docker_command = "docker run -d \
        --name ml-service \
        --network ml-net \
        -v ml-models:/models \
        -v ml-cache:/cache \
        -p 5000:5000 \
        -e MODEL_PATH=/models \
        tensorflow/tensorflow:latest-gpu";
    
    match composerize(docker_command, "", "v3x", 2) {
        Ok(yaml) => {
            println!("=== Complex Example (v3x) ===");
            println!("{}", yaml);
        }
        Err(e) => eprintln!("Error: {}", e),
    }
}

examples/advanced_usage.rs (line 25)

fn main() {
    // Example: Process command and extract service name
    let docker_command = "docker run -d -p 8080:80 --name my-app nginx:alpine";
    
    // Extract service name from image
    let image = "nginx:alpine";
    let service_name = get_service_name(image);
    println!("Service name extracted: {}", service_name);
    
    println!("\n{}\n", "=".repeat(50));
    
    // Convert with different formats
    let formats = vec![
        ("latest", "Latest (no version)"),
        ("v3x", "Docker Compose v3.x"),
        ("v2x", "Docker Compose v2.x"),
    ];
    
    for (format, description) in formats {
        println!("=== {} ===", description);
        
        match composerize(docker_command, "", format, 2) {
            Ok(yaml) => {
                // Show first few lines
                let lines: Vec<&str> = yaml.lines().take(5).collect();
                println!("{}", lines.join("\n"));
                println!("...\n");
            }
            Err(e) => eprintln!("Error: {}", e),
        }
    }
    
    println!("{}\n", "=".repeat(50));
    
    // Example: Different indentation levels
    println!("=== Different Indentation ===");
    
    for indent in [2, 4] {
        println!("\nIndent: {} spaces", indent);
        match composerize("docker run -p 80:80 nginx", "", "latest", indent) {
            Ok(yaml) => {
                let lines: Vec<&str> = yaml.lines().take(4).collect();
                println!("{}", lines.join("\n"));
            }
            Err(e) => eprintln!("Error: {}", e),
        }
    }
}

examples/error_handling.rs (line 9)

fn main() {
    // Example 1: Valid command
    println!("=== Example 1: Valid Command ===");
    let valid_command = "docker run -p 80:80 nginx";
    
    match composerize(valid_command, "", "latest", 2) {
        Ok(yaml) => println!("Success!\n{}", yaml),
        Err(e) => eprintln!("Error: {}", e),
    }

    println!("\n{}\n", "=".repeat(50));

    // Example 2: Missing image
    println!("=== Example 2: Missing Image (Error) ===");
    let invalid_command = "docker run -d -p 80:80";
    
    match composerize(invalid_command, "", "latest", 2) {
        Ok(yaml) => println!("Success!\n{}", yaml),
        Err(e) => eprintln!("Expected error: {}", e),
    }

    println!("\n{}\n", "=".repeat(50));

    // Example 3: Invalid format
    println!("=== Example 3: Invalid Format (Error) ===");
    let command = "docker run nginx";
    
    match composerize(command, "", "invalid-format", 2) {
        Ok(yaml) => println!("Success!\n{}", yaml),
        Err(e) => eprintln!("Expected error: {}", e),
    }

    println!("\n{}\n", "=".repeat(50));

    // Example 4: Proper error handling in production code
    println!("=== Example 4: Production-style Error Handling ===");
    
    fn convert_with_fallback(command: &str) -> String {
        composerize(command, "", "latest", 2)
            .unwrap_or_else(|e| {
                eprintln!("Conversion failed: {}", e);
                // Return a default compose file
                "services:\n  default:\n    image: alpine\n".to_string()
            })
    }
    
    let result = convert_with_fallback("docker run nginx");
    println!("Result:\n{}", result);
}