cargo-features-manager 0.12.0

A tui tool to enable/disable & prune dependency features
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
129
130
131

#![warn(clippy::unwrap_used)]

use clap::{Args, CommandFactory, Parser, Subcommand};
use clap_complete::{Shell, generate};
use color_eyre::Result;
use console::Term;

use crate::edit::display::Display;
use crate::project::document::Document;
use crate::prune::prune;

mod edit;
mod prune;

mod project;

mod io;

#[derive(Parser)]
#[command(name = "cargo")]
#[command(bin_name = "cargo")]
enum CargoCli {
    Features(FeaturesArgs),
}

#[derive(Parser)]
#[command(author, version, about, long_about = None)]
struct FeaturesArgs {
    #[arg(long = "generate", value_enum)]
    generator: Option<Shell>,

    #[arg(long, short)]
    package: Option<String>,

    #[arg(long, short)]
    dependency: Option<String>,

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

#[derive(Subcommand)]
enum FeaturesSubCommands {
    Prune(PruneArgs),
}

#[derive(Args)]
pub struct PruneArgs {
    #[arg(long)]
    dry_run: bool,
    #[arg(long)]
    skip_tests: bool,
    /// do not copy the project into a temporary directory
    #[arg(long, short = 't')]
    no_tmp: bool,
    /// `cargo clean` will run after each <CLEAN>
    #[arg(long, short, default_value_t, value_enum)]
    clean: CleanLevel,
    /// only check features that enable extra dependencies
    #[arg(long, short = 'd')]
    only_dependency: bool,
}

#[derive(clap::ValueEnum, Clone, Default, Debug)]
enum CleanLevel {
    #[default]
    Never,
    Package,
    Dependency,
}

fn main() -> Result<()> {
    color_eyre::install()?;

    let CargoCli::Features(args) = CargoCli::parse();

    if let Some(generator) = args.generator {
        let cmd = &mut FeaturesArgs::command();
        eprintln!("Generating completion file for {generator:?}...");
        generate(
            generator,
            cmd,
            cmd.get_name().to_string(),
            &mut std::io::stdout(),
        );
        return Ok(());
    }

    run(args)
}

fn run(args: FeaturesArgs) -> Result<()> {
    let _ = ctrlc::set_handler(|| {
        let term = Term::stdout();
        term.show_cursor().expect("could not enable cursor");
    });

    if let Some(sub) = args.sub {
        match sub {
            FeaturesSubCommands::Prune(args) => {
                prune(&args)?;
            }
        }
    } else {
        let document = Document::new(".")?;
        let package_name = document
            .get_local_package()?
            .map(|package| package.name.clone());

        let mut display = Display::new(document)?;

        if let Some(name) = args.package {
            display.set_selected_package(name)?
        } else if let Some(name) = package_name {
            display.set_selected_package(name)?
        }

        if let Some(name) = args.dependency {
            display.set_selected_dep(name)?
        }

        if let Err(err) = display.start() {
            // print empty line so we can see the error message
            println!();

            return Err(err);
        }
    }

    Ok(())
}