Initial commit

skills/clap-patterns/templates/builder-pattern.rs

@@ -0,0 +1,112 @@
+/// Builder Pattern Template (Manual API)
+///
+/// This template demonstrates the builder API for advanced use cases:
+/// - Dynamic CLI construction
+/// - Runtime configuration
+/// - Custom help templates
+/// - Complex validation logic
+///
+/// Note: Prefer derive macros unless you need this level of control.
+
+use clap::{Arg, ArgAction, ArgMatches, Command};
+use std::path::PathBuf;
+
+fn build_cli() -> Command {
+    Command::new("advanced-cli")
+        .version("1.0.0")
+        .author("Your Name <you@example.com>")
+        .about("Advanced CLI using builder pattern")
+        .arg(
+            Arg::new("input")
+                .short('i')
+                .long("input")
+                .value_name("FILE")
+                .help("Input file to process")
+                .required(true)
+                .value_parser(clap::value_parser!(PathBuf)),
+        )
+        .arg(
+            Arg::new("output")
+                .short('o')
+                .long("output")
+                .value_name("FILE")
+                .help("Output file (optional)")
+                .value_parser(clap::value_parser!(PathBuf)),
+        )
+        .arg(
+            Arg::new("verbose")
+                .short('v')
+                .long("verbose")
+                .help("Enable verbose output")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new("count")
+                .short('c')
+                .long("count")
+                .value_name("NUM")
+                .help("Number of items to process")
+                .default_value("10")
+                .value_parser(clap::value_parser!(usize)),
+        )
+        .arg(
+            Arg::new("format")
+                .short('f')
+                .long("format")
+                .value_name("FORMAT")
+                .help("Output format")
+                .value_parser(["json", "yaml", "toml"])
+                .default_value("json"),
+        )
+        .arg(
+            Arg::new("tags")
+                .short('t')
+                .long("tag")
+                .value_name("TAG")
+                .help("Tags to apply (can be specified multiple times)")
+                .action(ArgAction::Append),
+        )
+}
+
+fn process_args(matches: &ArgMatches) {
+    let input = matches.get_one::<PathBuf>("input").unwrap();
+    let output = matches.get_one::<PathBuf>("output");
+    let verbose = matches.get_flag("verbose");
+    let count = *matches.get_one::<usize>("count").unwrap();
+    let format = matches.get_one::<String>("format").unwrap();
+    let tags: Vec<_> = matches
+        .get_many::<String>("tags")
+        .unwrap_or_default()
+        .map(|s| s.as_str())
+        .collect();
+
+    if verbose {
+        println!("Configuration:");
+        println!("  Input: {:?}", input);
+        println!("  Output: {:?}", output);
+        println!("  Count: {}", count);
+        println!("  Format: {}", format);
+        println!("  Tags: {:?}", tags);
+    }
+
+    // Your processing logic here
+    println!("Processing {} items from {}", count, input.display());
+
+    if !tags.is_empty() {
+        println!("Applying tags: {}", tags.join(", "));
+    }
+
+    if let Some(output_path) = output {
+        println!("Writing {} format to {}", format, output_path.display());
+    }
+}
+
+fn main() {
+    let matches = build_cli().get_matches();
+    process_args(&matches);
+}
+
+// Example usage:
+//
+// cargo run -- -i input.txt -o output.json -v -c 20 -f yaml -t alpha -t beta
+// cargo run -- --input data.txt --format toml --tag important