cargo-caps 0.0.2

Audit what a crate is capable of by analyzing what linker symbols it emits
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

use cargo_metadata::camino::Utf8PathBuf;

use crate::print::PrintOptions;

#[derive(clap::Parser)]
pub struct SymbolCommand {
    /// Paths to the binary files
    pub binary_paths: Vec<Utf8PathBuf>,

    /// Show symbols at given depth (0=summary only, 1=categories, 2=symbols)
    #[arg(short, long, default_value = "2")]
    pub depth: u32,

    /// Filter to show only symbols under the given tree path (e.g., "crates/std/sync")
    #[arg(short, long)]
    pub filter: Option<String>,

    /// Include mangled symbol names alongside demangled names
    #[arg(short = 'm', long, default_value = "false")]
    pub mangled: bool,

    /// Show symbol metadata (scope and kind)
    #[arg(long, default_value = "false")]
    pub show_metadata: bool,

    /// Include local compilation symbols (excluded by default)
    #[arg(long, default_value = "false")]
    pub include_local: bool,

    /// Include all symbol kinds (by default, only executable code symbols are shown)
    #[arg(long, default_value = "false")]
    pub include_all_kinds: bool,
}

impl SymbolCommand {
    pub fn execute(&self) -> anyhow::Result<()> {
        if self.binary_paths.is_empty() {
            // Print help and return error
            use clap::CommandFactory as _;
            Self::command().print_help()?;
            println!();
            anyhow::bail!("At least one binary file path must be provided");
        }

        let options = PrintOptions {
            depth: self.depth,
            filter: self.filter.clone(),
            include_mangled: self.mangled,
            show_metadata: self.show_metadata,
        };

        for (i, binary_path) in self.binary_paths.iter().enumerate() {
            if !binary_path.exists() {
                anyhow::bail!("Binary file does not exist: {binary_path}");
            }

            // Add separator between multiple files
            if i > 0 {
                println!("\n{}", "=".repeat(80));
            }

            let symbols = crate::extract_symbols(binary_path)?;
            let original_count = symbols.len();
            let filtered_symbols =
                crate::filter_symbols(symbols, self.include_local, self.include_all_kinds);

            if self.show_metadata && filtered_symbols.len() < original_count {
                println!(
                    "Filtered {} -> {} symbols (use --include-local and/or --include-all-kinds to show more)",
                    original_count,
                    filtered_symbols.len()
                );
            }

            crate::print::print_symbols(binary_path, &filtered_symbols, &options);
        }
        Ok(())
    }
}