Rust命令行工具开发库proto_cli的使用指南

概述

proto_cli是一个用于快速构建高效命令行界面(CLI)应用的Rust库，特别适合需要处理协议数据的工具开发。它提供了简洁的API和强大的功能，帮助开发者快速实现命令行工具。

主要特性

1. 简洁的命令行参数解析
2. 内置协议处理功能
3. 自动生成帮助信息
4. 支持子命令
5. 高效错误处理

安装

在Cargo.toml中添加依赖：

[dependencies]
proto_cli = "0.3.0"

基本使用方法

1. 创建简单CLI应用

use proto_cli::{ProtoApp, ProtoCommand, ProtoArg};

fn main() {
    // 创建新的CLI应用
    let app = ProtoApp::new("myapp")
        .version("1.0.0")
        .author("Your Name")
        .about("A simple CLI application")
        .arg(ProtoArg::new("input")
            .short('i')
            .long("input")
            .help("Input file path")
            .required(true))
        .arg(ProtoArg::new("output")
            .short('o')
            .long("output")
            .help("Output file path"));

    // 解析命令行参数
    let matches = app.get_matches();
    
    // 获取参数值
    let input = matches.value_of("input").unwrap();
    let output = matches.value_of("output").unwrap_or("default.txt");
    
    println!("Processing {} to {}", input, output);
}

2. 使用子命令

use proto_cli::{ProtoApp, ProtoCommand};

fn main() {
    // 创建带子命令的CLI应用
    let app = ProtoApp::new("network-tool")
        .subcommand(ProtoCommand::new("send")
            .about("Send data to a server")
            .arg(ProtoArg::new("host")
                .required(true)
                .help("Server host address")))
        .subcommand(ProtoCommand::new("receive")
            .about("Receive data from a server")
            .arg(ProtoArg::new("port")
                .short('p')
                .help("Port to listen on")));

    // 解析命令行参数
    let matches = app.get_matches();
    
    // 处理子命令
    match matches.subcommand() {
        Some(("send", sub_m)) => {
            let host = sub_m.value_of("host").unwrap();
            println!("Sending data to {}", host);
        }
        Some(("receive", sub_m)) => {
            let port = sub_m.value_of("port").unwrap_or("8080");
            println!("Listening on port {}", port);
        }
        _ => unreachable!(),
    }
}

3. 协议处理功能

use proto_cli::{ProtoApp, ProtoCommand};
use proto_cli::protocol::{Protocol, ProtocolType};

fn main() {
    // 创建协议分析工具
    let app = ProtoApp::new("protocol-analyzer")
        .arg(ProtoArg::new("protocol")
            .short('p')
            .long("protocol")
            .help("Protocol type (http, tcp, udp)")
            .required(true))
        .arg(ProtoArg::new("data")
            .help("Data to analyze")
            .required(true));

    // 解析命令行参数
    let matches = app.get_matches();
    
    // 获取参数值
    let protocol_type = matches.value_of("protocol").unwrap();
    let data = matches.value_of("data").unwrap();
    
    // 创建协议处理器并分析数据
    let protocol = Protocol::new(ProtocolType::from_str(protocol_type).unwrap());
    let analysis = protocol.analyze(data);
    
    println!("Analysis result: {:?}", analysis);
}

高级功能

自定义验证器

use proto_cli::{ProtoApp, ProtoArg};

// 自定义端口验证函数
fn validate_port(port: &str) -> Result<(), String> {
    port.parse::<u16>()
        .map(|_| ())
        .map_err(|_| format!("'{}' is not a valid port number", port))
}

fn main() {
    // 创建带验证器的CLI应用
    let app = ProtoApp::new("port-checker")
        .arg(ProtoArg::new("port")
            .validator(validate_port)
            .required(true));

    let matches = app.get_matches();
    let port = matches.value_of("port").unwrap();
    println!("Valid port: {}", port);
}

自动补全支持

use proto_cli::{ProtoApp, ProtoCommand, ProtoArg};

fn main() {
    // 创建支持自动补全的CLI应用
    let app = ProtoApp::new("autocomplete-demo")
        .arg(ProtoArg::new("mode")
            .possible_values(&["fast", "slow", "debug"])
            .required(true));
    
    // 生成补全脚本
    // 通常在build.rs中调用
    // ProtoApp::gen_completions("myapp", Shell::Bash, "./completions");
}

完整示例Demo

下面是一个结合多个特性的完整示例，展示如何构建一个功能完善的网络工具：

use proto_cli::{ProtoApp, ProtoCommand, ProtoArg};
use proto_cli::protocol::{Protocol, ProtocolType};
use std::sync::Arc;

// 自定义验证器 - 验证IP地址格式
fn validate_ip(ip: &str) -> Result<(), String> {
    if ip.split('.').count() == 4 && 
       ip.split('.').all(|s| s.parse::<u8>().is_ok()) {
        Ok(())
    } else {
        Err(format!("'{}' is not a valid IPv4 address", ip))
    }
}

fn main() {
    // 共享数据
    let shared_config = Arc::new("v1.0-config".to_string());
    
    // 创建CLI应用
    let app = ProtoApp::new("network-utils")
        .version("1.0.0")
        .author("Network Team")
        .about("Advanced network utilities")
        // 全局参数
        .arg(ProtoArg::new("verbose")
            .short('v')
            .long("verbose")
            .help("Enable verbose output"))
        // 子命令 - ping
        .subcommand(ProtoCommand::new("ping")
            .about("Ping a network host")
            .arg(ProtoArg::new("host")
                .validator(validate_ip)
                .required(true)
                .help("Host to ping")))
        // 子命令 - analyze
        .subcommand(ProtoCommand::new("analyze")
            .about("Analyze protocol data")
            .arg(ProtoArg::new("protocol")
                .short('p')
                .long("protocol")
                .possible_values(&["http", "tcp", "udp"])
                .required(true)
                .help("Protocol type"))
            .arg(ProtoArg::new("data")
                .required(true)
                .help("Data to analyze")));

    // 解析参数
    let matches = app.get_matches();
    
    // 处理全局verbose标志
    let verbose = matches.is_present("verbose");
    if verbose {
        println!("Running in verbose mode with config: {}", shared_config);
    }
    
    // 处理子命令
    match matches.subcommand() {
        Some(("ping", sub_m)) => {
            let host = sub_m.value_of("host").unwrap();
            println!("Pinging {}...", host);
            // 实际ping逻辑...
        }
        Some(("analyze", sub_m)) => {
            let protocol_type = sub_m.value_of("protocol").unwrap();
            let data = sub_m.value_of("data").unwrap();
            
            let protocol = Protocol::new(ProtocolType::from_str(protocol_type).unwrap());
            let analysis = protocol.analyze(data);
            
            println!("Analysis result:");
            println!("Protocol: {}", protocol_type);
            println!("Data size: {} bytes", data.len());
            println!("Details: {:?}", analysis);
        }
        _ => {
            println!("No subcommand specified. Use --help for usage information.");
        }
    }
}

最佳实践

1. 对于复杂的CLI应用，使用子命令组织功能
2. 为所有参数和子命令添加详细的帮助信息
3. 使用验证器确保输入数据的有效性
4. 考虑为常用工具添加自动补全支持
5. 使用Protocol特性处理特定协议数据时，遵循相关RFC标准

性能提示

1. 避免在参数解析过程中进行大量计算
2. 对于频繁调用的工具，考虑使用Arc共享数据
3. 使用Protocol的批处理模式处理大量数据

proto_cli通过简洁的API和强大的功能，使得开发命令行工具变得更加高效和愉快。无论是简单的脚本还是复杂的协议分析工具，都能从中受益。