Struct CliParser 

pub struct CliParser { /* private fields */ }

CLI Parser - Executes binaries and parses help output

Implementations

impl CliParser

pub fn new() -> Self

Create a new CLI parser with default resource limits

pub fn with_limits(resource_limits: ResourceLimits) -> Self

Create a new CLI parser with custom resource limits

pub fn analyze(&self, binary_path: &Path) -> Result<CliAnalysis>

Analyze a CLI binary and extract its structure

This performs the following steps:

1. Validate binary path
2. Execute with –help to get help output
3. Execute with –version to get version string
4. Parse help output to extract options
5. Detect subcommands recursively
6. Build CliAnalysis structure

Examples

use cli_testing_specialist::analyzer::CliParser;
use std::path::Path;

let parser = CliParser::new();
let analysis = parser.analyze(Path::new("/usr/bin/curl"))?;

println!("Binary: {}", analysis.binary_name);
println!("Version: {:?}", analysis.version);
println!("Options: {}", analysis.metadata.total_options);
println!("Subcommands: {}", analysis.subcommands.len());

With Custom Resource Limits

use cli_testing_specialist::analyzer::CliParser;
use cli_testing_specialist::utils::ResourceLimits;
use std::path::Path;
use std::time::Duration;

let limits = ResourceLimits::new(
    1024 * 1024 * 1024, // 1GB memory
    1024,               // file descriptors
    100,                // max processes
    Duration::from_secs(60), // timeout
);

let parser = CliParser::with_limits(limits);
let analysis = parser.analyze(Path::new("/usr/bin/kubectl"))?;

pub fn parse_options(&self, help_output: &str) -> Vec<CliOption>

Parse CLI options from help output

pub fn parse_required_args(&self, help_output: &str) -> Vec<String>

Parse required positional arguments from help output

Looks for Usage line and extracts <ARG> patterns:

• “Usage: cmd [OPTIONS] <ID>” → [“ID”]
• “Usage: cmd <FILE> <OUTPUT>” → [“FILE”, “OUTPUT”]

Trait Implementations

impl Default for CliParser

fn default() -> Self

Returns the “default value” for a type.