Rust 命令行工具开发：Clap、TUI 与发布工程

use clap::Parser;

/// 一个示例文件搜索工具
#[derive(Parser, Debug)]
#[command(name = "rgx", version, about, author)]
struct Args {
    /// 搜索的目录（默认当前目录）
    #[arg(default_value = ".")]
    path: String,

    /// 要搜索的关键词
    query: String,

    /// 忽略大小写
    #[arg(short, long)]
    ignore_case: bool,

    /// 显示行号
    #[arg(short = 'n', long = "line-number")]
    line_numbers: bool,

    /// 最大深度
    #[arg(short, long, default_value_t = 5)]
    max_depth: usize,
}

fn main() {
    let args = Args::parse();
    println!("搜索 {} 在 {}，忽略大小写={}", args.query, args.path, args.ignore_case);
}

#[derive(Parser, Debug)]
struct Args {
    /// 端口号（自动校验 u16 范围）
    #[arg(short, long, default_value_t = 8080)]
    port: u16,

    /// 日志级别
    #[arg(short, long, value_enum, default_value_t = LogLevel::Info)]
    level: LogLevel,

    /// 多次出现的参数 → Vec
    #[arg(long)]
    tag: Vec<String>,
}

#[derive(clap::ValueEnum, Clone, Copy, Debug, Default)]
enum LogLevel { #[default] Info, Debug, Warn, Error }

use clap::{Parser, Subcommand};

#[derive(Parser, Debug)]
#[command(name = "pm", about = "项目包管理器")]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand, Debug)]
enum Commands {
    /// 初始化新项目
    Init {
        /// 项目名称
        name: String,
        #[arg(long, default_value = "false")]
        git: bool,
    },
    /// 构建项目
    Build {
        #[arg(long, default_value_t = false)]
        release: bool,
    },
    /// 发布项目
    Publish {
        /// 只检查，不实际发布
        #[arg(long)]
        dry_run: bool,
    },
}

fn main() {
    let cli = Cli::parse();
    match cli.command {
        Commands::Init { name, git } => {
            println!("初始化 {name}，git={git}");
        }
        Commands::Build { release } => {
            println!("构建，release={release}");
        }
        Commands::Publish { dry_run } => {
            println!("发布，dry_run={dry_run}");
        }
    }
}

/// 指定多个主机：--host a.com,b.com
#[arg(long, value_delimiter = ',')]
host: Vec<String>,

use ratatui::{
    backend::CrosstermBackend,
    layout::{Constraint, Layout, Direction},
    widgets::{Block, Borders, List, ListItem, Paragraph, Style},
    Terminal,
};
use crossterm::event::{self, Event, KeyCode};
use crossterm::terminal::{enable_raw_mode, disable_raw_mode};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    enable_raw_mode()?;
    let mut terminal = Terminal::new(CrosstermBackend::new(std::io::stdout()))?;

    // 模拟数据源
    let (tx, mut rx) = tokio::sync::mpsc::channel::<String>(8);
    tokio::spawn(async move {
        for i in 1..=100 {
            tx.send(format!("日志行 {i}")).await.unwrap();
            tokio::time::sleep(std::time::Duration::from_millis(200)).await;
        }
    });

    let mut lines: Vec<String> = Vec::new();
    loop {
        terminal.draw(|f| {
            let chunks = Layout::default()
                .direction(Direction::Vertical)
                .constraints([Constraint::Percentage(80), Constraint::Percentage(20)])
                .split(f.area());
            let list = List::new(
                lines.iter().map(|l| ListItem::new(l.clone())).collect::<Vec<_>>()
            ).block(Block::default().borders(Borders::ALL).title("实时日志"));
            f.render_widget(list, chunks[0]);
            f.render_widget(Paragraph::new("q: 退出"), chunks[1]);
        })?;

        if event::poll(std::time::Duration::from_millis(100))? {
            if let Event::Key(k) = event::read()? {
                if k.code == KeyCode::Char('q') { break; }
            }
        }
        while let Ok(line) = rx.try_recv() {
            lines.push(line);
        }
    }
    disable_raw_mode()?;
    Ok(())
}

use tracing::{info, warn, error, debug, instrument};
use tracing_subscriber::{EnvFilter, fmt};

#[instrument]
async fn process_request(id: u64) {
    debug!(id, "开始处理请求");
    tokio::time::sleep(std::time::Duration::from_millis(10)).await;
    info!(id, "处理完成");
}

#[tokio::main]
async fn main() {
    // 初始化：从环境变量 RUST_LOG 读取过滤级别
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .with_target(false)
        .init();

    process_request(1).await;
}

use serde::{Deserialize, Serialize};
use std::path::PathBuf;

#[derive(Serialize, Deserialize, Default)]
struct Config {
    #[serde(default = "default_api_url")]
    api_url: String,
    #[serde(default = "default_timeout")]
    timeout_secs: u64,
    verbose: bool,
}

fn default_api_url() -> String { "https://api.example.com".into() }
fn default_timeout() -> u64 { 30 }

fn load_config(args: &Args) -> Config {
    let mut cfg = Config::default();

    // 1. 配置文件（~/.config/mycli/config.toml）
    if let Some(path) = config_path() {
        if path.exists() {
            let text = std::fs::read_to_string(path).unwrap_or_default();
            cfg = toml::from_str(&text).unwrap_or_default();
        }
    }

    // 2. 环境变量覆盖
    if let Ok(url) = std::env::var("MYCLI_API_URL") {
        cfg.api_url = url;
    }

    // 3. 命令行参数优先
    if let Some(url) = &args.api_url { cfg.api_url = url.clone(); }
    if let Some(t) = args.timeout { cfg.timeout_secs = t; }

    cfg
}

fn config_path() -> Option<PathBuf> {
    std::env::var_os("XDG_CONFIG_HOME")
        .map(PathBuf::from)
        .or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".config")))
        .map(|p| p.join("mycli/config.toml"))
}

use std::process::ExitCode;

fn main() -> ExitCode {
    match run() {
        Ok(()) => ExitCode::SUCCESS,
        Err(e) => {
            eprintln!("错误: {e}"); // 输出到 stderr，不污染 stdout 管道
            ExitCode::FAILURE
        }
    }
}

fn run() -> anyhow::Result<()> {
    let args = Args::parse();
    let data = std::fs::read_to_string(&args.file)
        .with_context(|| format!("读取文件 {} 失败", args.file))?;
    // ... 业务逻辑
    Ok(())
}

use indicatif::{ProgressBar, ProgressStyle};

fn main() {
    let pb = ProgressBar::new(100);
    pb.set_style(
        ProgressStyle::with_template("{spinner:.green} [{bar:40.cyan/blue}] {pos}/{len} {msg}")
            .unwrap()
            .progress_chars("#>-"),
    );
    for i in 0..100 {
        std::thread::sleep(std::time::Duration::from_millis(30));
        pb.inc(1);
        pb.set_message(format!("处理第 {i} 项"));
    }
    pb.finish_with_message("完成 ✅");
}

# 初始化
cargo dist init

# 构建发布产物
cargo dist build --tag v1.0.0

# GitHub Actions 自动化（生成 install.ps1 / install.sh / install.psh）
cargo dist plan

curl -LsSf https://github.com/you/mycli/releases/latest/download/mycli-installer.sh | sh