ietf-rfc 0.1.0

A CLI tool to search, retrieve, and display IETF RFCs and drafts
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use anyhow::Result;
use clap::{Args, Parser, Subcommand};

use rfc::commands;
use rfc::SearchFilter;

#[derive(Parser)]
#[command(name = "rfc", version)]
#[command(about = "Search, retrieve, and display IETF RFCs and drafts")]
#[command(args_conflicts_with_subcommands = true)]
#[command(arg_required_else_help = true)]
struct Cli {
    /// RFC number or draft name to view (default action — uses cache when present)
    document: Option<String>,

    /// Program to open the document with (defaults to $EDITOR, then $PAGER)
    #[arg(short = 'o', long, value_name = "PROGRAM", conflicts_with = "web")]
    open_with: Option<String>,

    /// Open document in web browser (IETF Datatracker)
    #[arg(short = 'w', long, requires = "document")]
    web: bool,

    #[command(subcommand)]
    command: Option<Command>,
}

#[derive(Subcommand)]
enum Command {
    /// Fetch a document from the API and cache it without opening it
    Fetch {
        /// RFC number or draft name to fetch
        document: String,
    },

    /// Search the IETF Datatracker
    Search(SearchArgs),

    /// Manage the local document cache
    #[command(subcommand)]
    Cache(CacheCmd),
}

#[derive(Args)]
struct SearchArgs {
    /// Query string (whitespace-separated tokens are AND-ed together)
    #[arg(required = true, num_args = 1..)]
    query: Vec<String>,

    #[command(flatten)]
    filter: SearchFilterArgs,

    /// Maximum number of results to display
    #[arg(short, long, default_value_t = 25)]
    limit: usize,
}

#[derive(Args)]
#[group(multiple = false)]
struct SearchFilterArgs {
    /// Only show Internet-Drafts
    #[arg(short, long)]
    drafts: bool,

    /// Show both RFCs and drafts
    #[arg(short, long)]
    all: bool,
}

impl From<&SearchFilterArgs> for SearchFilter {
    fn from(a: &SearchFilterArgs) -> Self {
        if a.drafts {
            SearchFilter::DraftsOnly
        } else if a.all {
            SearchFilter::Both
        } else {
            SearchFilter::RfcsOnly
        }
    }
}

#[derive(Subcommand)]
enum CacheCmd {
    /// List cached documents
    List {
        /// Show full titles without truncation
        #[arg(short, long)]
        wide: bool,
    },
    /// Show cache location and total size
    Info,
    /// Remove a single document from the cache
    Remove {
        /// RFC number or draft name to remove
        document: String,
    },
    /// Remove every cached document
    Clear,
}

#[tokio::main]
async fn main() -> Result<()> {
    let cli = Cli::parse();

    match cli.command {
        Some(Command::Fetch { document }) => commands::fetch::run(&document).await,
        Some(Command::Search(args)) => {
            let filter = SearchFilter::from(&args.filter);
            commands::search::run(commands::search::Args {
                query: args.query.join(" "),
                filter,
                limit: args.limit,
            })
            .await
        }
        Some(Command::Cache(c)) => match c {
            CacheCmd::List { wide } => commands::cache::list(wide),
            CacheCmd::Info => commands::cache::info(),
            CacheCmd::Remove { document } => commands::cache::remove(&document),
            CacheCmd::Clear => commands::cache::clear(),
        },
        None => match cli.document {
            Some(doc) => commands::view::run(&doc, cli.open_with.as_deref(), cli.web).await,
            // arg_required_else_help handles the "no args at all" case.
            None => Ok(()),
        },
    }
}