unsafe-review-cli 0.3.8

CLI adapter for unsafe-review
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

use super::*;

pub(super) fn apply_check_arg(
    args: &[String],
    idx: usize,
    options: &mut CheckOptions,
) -> Result<usize, String> {
    try_apply_check_arg(args, idx, options)?
        .ok_or_else(|| format!("unknown argument `{}`", args[idx]))
}

pub(super) fn try_apply_check_arg(
    args: &[String],
    idx: usize,
    options: &mut CheckOptions,
) -> Result<Option<usize>, String> {
    match args[idx].as_str() {
        "--root" => {
            options.root = PathBuf::from(value(args, idx + 1, "--root")?);
            Ok(Some(2))
        }
        arg if arg.starts_with("--root=") => {
            options.root = PathBuf::from(inline_value(arg, "--root")?);
            Ok(Some(1))
        }
        "--base" => {
            options.base = Some(value(args, idx + 1, "--base")?.to_string());
            Ok(Some(2))
        }
        arg if arg.starts_with("--base=") => {
            options.base = Some(inline_value(arg, "--base")?.to_string());
            Ok(Some(1))
        }
        "--diff" => {
            options.diff = Some(parse_diff_input(value(args, idx + 1, "--diff")?));
            Ok(Some(2))
        }
        arg if arg.starts_with("--diff=") => {
            options.diff = Some(parse_diff_input(inline_value(arg, "--diff")?));
            Ok(Some(1))
        }
        "--format" => {
            options.format = parse_format(value(args, idx + 1, "--format")?)?;
            Ok(Some(2))
        }
        arg if arg.starts_with("--format=") => {
            options.format = parse_format(inline_value(arg, "--format")?)?;
            Ok(Some(1))
        }
        "--policy" => {
            options.policy = parse_policy(value(args, idx + 1, "--policy")?)?;
            Ok(Some(2))
        }
        arg if arg.starts_with("--policy=") => {
            options.policy = parse_policy(inline_value(arg, "--policy")?)?;
            Ok(Some(1))
        }
        "--json" => {
            options.format = Format::Json;
            Ok(Some(1))
        }
        "--markdown" => {
            options.format = Format::Markdown;
            Ok(Some(1))
        }
        "--out" => {
            options.out = Some(PathBuf::from(value(args, idx + 1, "--out")?));
            Ok(Some(2))
        }
        arg if arg.starts_with("--out=") => {
            options.out = Some(PathBuf::from(inline_value(arg, "--out")?));
            Ok(Some(1))
        }
        "--max-cards" => {
            options.max_cards = Some(parse_max_cards_arg(args, idx + 1, "--max-cards")?);
            Ok(Some(2))
        }
        arg if arg.starts_with("--max-cards=") => {
            options.max_cards = Some(parse_max_cards_inline(arg, "--max-cards")?);
            Ok(Some(1))
        }
        _ => Ok(None),
    }
}

fn parse_max_cards_arg(args: &[String], idx: usize, flag: &str) -> Result<usize, String> {
    parse_max_cards(value(args, idx, flag)?)
}

fn parse_max_cards_inline(arg: &str, flag: &str) -> Result<usize, String> {
    parse_max_cards(inline_value(arg, flag)?)
}